# Funciones Arrays (PHP)
# Básicas
## count
Cuenta los elementos de un array
```php=
<?php
$ages = [12,23,34];
echo count($ages); // 3
?>
```
## range
Crea un array en un rango determinado
```php=
<?php
$range = range(1,5);
print_r($range);
/*
Array
(
[0] => 1
[1] => 2
[2] => 3
[3] => 4
[4] => 5
)
*/
?>
```
## var_export
Muestra el array con sus claves (como print_r)
```php=
<?php
$ages = [12,23,34];
var_export($ages);
/*
Array
(
[0] => 12
[1]=> 23
[2] => 34
)
*/
?>
```
# Conversciones
## implode
Convierte un array en una cadena de texto
```php=
<?php
$ages = [12,23,34];
echo "[" . implode(",", $ages) . "]";
/*
* [12,23,34]
*/
?>
```
## explode
Convierte una string en un array
```php=
<?php
$ages = "12,23,34";
$agesArr = explode(",",$ages);
print_r($agesArr);
/*
Array
(
[0] => 12
[1] => 23
[2] => 34
)
*/
?>
```
## str_split
Convierte una string en un array, en la que cada elemento sera un carácter de la string
```php=
<?php
$ages = "12,23,34";
$agesArr = str_split($ages);
print_r($agesArr);
/*
Array
(
[0] => 1
[1] => 2
[2] => ,
[3] => 2
[4] => 3
[5] => ,
[6] => 3
[7] => 4
)
*/
?>
```
## preg_split
Convierte una string en un array con expresiones regulares
```php=
<?php
$ages = "12,23,34";
$agesArr = preg_split("/[\s,]+/",$ages);
print_r($agesArr);
/*
Array
(
[0] => 12
[1] => 23
[2] => 34
)
*/
?>
```
# Inserción
## array_unshit
Añade elementos al principio del Array
```php=
<?php
$ages = [12,23,34];
array_unshift($ages, 13);
echo "[" . implode(",", $ages) . "]";
/*
* [13,12,23,34]
*/
?>
```
## array_push
Añade elementos al final del Array
```php=
<?php
$ages = [12,23,34];
array_push($ages, 13);
echo "[" . implode(",", $ages) . "]";
/*
* [12,23,34,13]
*/
?>
```
## array_pad
Rellena un array a la longitud especificada con un valor,
no modifica el original, devuelve una copia con el resultado.
```php=
<?php
$ages = [12,23,34];
$copy = array_pad($ages, 9, "edades");
print_r($copy);
/*
Array
(
[0] => 12
[1] => 23
[2] => 34
[3] => edades
[4] => edades
[5] => edades
[6] => edades
[7] => edades
[8] => edades
)
*/
?>
```
# Extracción
## array_shift
Elimina el elemento del principio y lo devuelve
```php=
<?php
$ages = [12,23,34];
echo array_shift($ages) . "\n";
echo "[" . implode(",", $ages) . "]";
/*
* 12
* [23,34]
*/
?>
```
## array_pop
Elimina el elemento del final y lo devuelve
```php=
<?php
$ages = [12,23,34];
echo array_pop($ages) . "\n";
echo "[" . implode(",", $ages) . "]";
/*
* 34
* [12,23]
*/
?>
```
## unset
Destruye una o más variables especificadas (No es exclusivo de arrays)
```php=
<?php
$ages = [12,23,34];
unset($ages[1]);
echo "[" . implode(",", $ages) . "]";
/*
* 12
* [12,34]
*/
?>
```
# Inspección de Arrays
## current
Devuelve el valor del elemento al que actualmente señala el
puntero. Si no hay ningún elemento devuelve FALSE
```php=
<?php
$ages = [12,23,34];
echo current($ages);
/*
* 12
*/
?>
```
## key
Devuelve la clave a la que señala el puntero
```php=
<?php
$ages = [12,23,34];
echo key($ages);
/*
* 0
*/
?>
```
## next
Mueve el puntero al siguiente elemento del array y devuelve su valor. Si el elemento actual es el último, next devuelve false.
```php=
<?php
$ages = [12,23,34];
echo next($ages);
/*
* 23
*/
?>
```
## prev
Mueve el puntero al elemento anterior del array y devuelve su valor. Si el elemento actual es el primero, prev devuelve false.
```php=
<?php
$ages = [12,23,34];
echo next($ages) ."\n";
echo prev($ages);
/*
* 23
* 12
*/
?>
```
## reset
Coloca el puntero en el primer elemento del array y devuelve su valor. Si no hay ningún elemento devuelve false.
```php=
<?php
$ages = [12,23,34];
echo next($ages) ."\n";
echo reset($ages);
/*
* 23
* 12
*/
?>
```
## end
Coloca el puntero en el último elemento y devuelve su valor.
```php=
<?php
$ages = [12,23,34];
echo end($ages);
/*
* 34
*/
?>
```
# Comprobación
## isset
Determina si una variable está definida y no es null, devolviendo 1(true) si lo está y 0(false) en caso contrario (No exclusiva de los arrays)
```php=
<?php
$ages = [12,23,34];
echo isset($ages[1]);
/*
* 1
*/
?>
```
## array_key_exists
Devuelve TRUE si la clave está creada en el array
```php=
<?php
$ages = [12,23,34];
echo array_key_exists(1,$ages);
/*
* 1
*/
?>
```
## is_array
Devuelve TRUE si la variable es un array
```php=
<?php
$ages = [12,23,34];
echo is_array($ages);
/*
* 1
*/
?>
```
## array_search
Busca un valor determinado en un array y devuelve la primera clave correspondiente en caso de éxito.
```php=
<?php
$ages = [12,23,34];
echo array_search(34,$ages);
/*
* 2
*/
?>
```
# Varios
## shuffle
Mezcla los elementos de un array de forma aleatoria
```php=
<?php
$ages = [12,23,34];
shuffle($ages);
echo "[" . implode(",", $ages) . "]";
/*
* [34,12,23]
*/
?>
```
## array_merge
Fusiona dos o más arrays, devolviendo el resultado de la fusión
```php=
<?php
$ages = [12,23,34];
$ages1 = [12,23,34];
$ages2 = [12,23,34];
$merge = array_merge($ages, $ages1, $ages2);
echo "[" . implode(",", $merge) . "]";
/*
* [12,23,34,12,23,34,12,23,34]
*/
?>
```
## array_reverse
Devuelve un array con los elementos en orden inverso
```php=
<?php
$ages = [12,23,34];
$agesReverse = array_reverse($ages);
echo "[" . implode(",", $agesReverse) . "]";
/*
* [34,23,12]
*/
?>
```
## array_unique
Elimina los valores duplicados de un array
```php=
<?php
$ages = [12,12,34];
$agesUnique = array_unique($ages);
echo "[" . implode(",", $agesUnique) . "]";
/*
* [12,34]
*/
?>
```
## array_slice
Devuelve la secuencia de elementos delarray tal y como se especifica en el primer y segundo parámetro.
Si el primer parámetro es negativo, se comensara por el final.
Si el seguno parámetro es negativo, se saltara los n ultimos elementos
```php=
<?php
$ages = [12,23,34,23,24,25,26,27];
$subAges = array_slice($ages,0,1);
$subAgesFirstNegatiove = array_slice($ages,-2,2);
$subAgesSecondNegative = array_slice($ages,2,-3);
// print_r($subAges);
/*
Array
(
[0] => 12
)
*/
// print_r($subAgesFirstNegatiove);
/*
Array
(
[0] => 26
[1] => 27
)
*/
print_r($subAgesSecondNegative);
/*
Array
(
[0] => 34
[1] => 23
[2] => 24
)
*/
?>
```
## array_flip
Intercambia las claves por lo valores
```php=
<?php
$ages = [12,23,34];
$agesArr = array_flip($ages);
print_r($agesArr);
/*
Array
(
[12] => 0
[23] => 1
[34] => 2
)
*/
?>
```
## array_chunk
Divide un array en varios arrays según la longitud que le pasemos como segundo parámetro. Opcionalmente se le puede pasar otro tercer parámetro booleano si queremos que se conserven las claves.
```php=
<?php
$ages = [12,23,34];
$agesArr = array_chunk($ages,1);
print_r($agesArr);
/*
Array
(
[0] => Array
(
[0] => 12
)
[1] => Array
(
[0] => 23
)
[2] => Array
(
[0] => 34
)
)
*/
?>
```
# Orden
Estas funciones modifican el array original.
## asort
Ordena los valores de un array en orden y mantiene la asociación de índices.
```php=
<?php
$people = [
"Juan" => 25,
"Manuel" => 23,
"Pepe" => 12,
"Perico" => 32
];
asort($people);
print_r($people)
/*
Array
(
[Pepe] => 12
[Manuel] => 23
[Juan] => 25
[Perico] => 32
)
*/
?>
```
## arsort
Ordena los valores de un array en orden inverso y mantiene la asociación de índices.
```php=
<?php
$people = [
"Juan" => 25,
"Manuel" => 23,
"Pepe" => 12,
"Perico" => 32
];
arsort($people);
print_r($people)
/*
* Array
(
[Perico] => 32
[Juan] => 25
[Manuel] => 23
[Pepe] => 12
)
*/
?>
```
## ksort
Ordena un array por clave, manteniendo la correlación entre la clave y los datos.
```php=
<?php
$people = [
"Pepe" => 12,
"Perico" => 32,
"Juan" => 25,
"Manuel" => 23
];
ksort($people);
print_r($people)
/*
* Array
(
[Juan] => 25
[Manuel] => 23
[Pepe] => 12
[Perico] => 32
)
*/
?>
```
## krsort
Ordena un array en orden inverso por clave, manteniendo la correlación entre la clave y los datos.
```php=
<?php
$people = [
"Pepe" => 12,
"Perico" => 32,
"Juan" => 25,
"Manuel" => 23
];
krsort($people);
print_r($people)
/*
* Array
(
[Perico] => 32
[Pepe] => 12
[Manuel] => 23
[Juan] => 25
)
*/
?>
```
## sort
Ordena los valores de un array de menor a mayor, perdiendo las claves si lo usamos con un array asociativo.
```php=
<?php
$people = [
"Pepe" => 32,
"Juan" => 25
];
sort($people);
echo "[" . implode(",", $people) . "]";
// [25,32]
?>
```
## usort
Ordena los valores de un array en base a la función que le pasemos como segundo parámetro. Al igual que el sort, pierde las claves si es un array asociativo.
```php=
<?php
$people = [
"Pepe" => 23,
"Juan" => 12
];
usort($people, function ($a, $b) {
return $a <=> $b;
});
echo "[" . implode(",", $people) . "]";
// [12,23]
?>
```
# Extra
## Operador de nave espacial
En php podemos hacer uso de un operador especial **'<=>'**, el operador de nave espacial. Devuelve -1, 0 o 1 cuando $a es respectivamente menor, igual, o mayor que $b.
###### tags: `Platzi` `DSW` `PHP`
Sign in with Wallet
Connect another wallet