PHP: Hypertext Preprocessor

Arrays

Un array en PHP es en realidad un mapa ordenado. Un mapa es un tipo que asocia valores a claves. Este tipo está optimizado para varios usos diferentes; puede ser tratado como un array, lista (vector), tabla hash (una implementación de un mapa), diccionario, colección, pila, cola, y probablemente más. Como los valores array pueden ser otros arrays, árboles y arrays arrays multidimensionales también son posibles.

La explicación de esas estructuras de datos está fuera del alcance de este manual, pero al menos se proporciona un ejemplo para cada una de ellas. Para más información, consulte la considerable literatura que existe sobre este amplio tema.

Sintaxis

Especificación con array()

Un array puede ser creado usando la construcción de lenguaje array(). Toma cualquier número de pares clave => valor separados por comas como argumentos.

array(
    clave  => valor,
    clave2 => valor2,
    clave3 => valor3,
    ...
)

La coma después del último elemento del array es opcional y puede ser omitida. Esto se hace usualmente para arrays de una sola línea, es decir, array(1, 2) es preferido sobre array(1, 2, ). Para arrays de múltiples líneas, por otro lado, la coma final es comúnmente usada, ya que permite una adición más fácil de nuevos elementos al final.

Nota:
Existe una sintaxis corta para arrays que reemplaza array() con [].

Ejemplo #1 Un array simple

<?php
$array1 = array(
    "foo" => "bar",
    "bar" => "foo",
);

// Usando la sintaxis corta de array
$array2 = [
    "foo" => "bar",
    "bar" => "foo",
];

var_dump($array1, $array2);
?>

La clave puede ser un int o un string. El valor puede ser de cualquier tipo.

Además, las siguientes conversiones de clave ocurrirán:

Strings que contienen ints decimales válidos, a menos que el número esté precedido por un signo +, serán convertidos al tipo int. Por ejemplo, la clave "8" será almacenada bajo 8. Por otro lado, "08" no será convertido, ya que no es un entero decimal válido.
Los floats también son convertidos a ints, lo que significa que la parte fraccional será truncada. Por ejemplo, la clave 8.7 será almacenada bajo 8.
Los bools son convertidos a ints también, es decir, la clave true será almacenada bajo 1 y la clave false bajo 0.
Null será convertido a una cadena vacía, es decir, la clave null será almacenada bajo "".
Los arrays y objects no pueden ser usados como claves. Hacerlo resultará en una advertencia: Illegal offset type.

Si múltiples elementos en la declaración del array usan la misma clave, solo el último será usado ya que todos los demás son sobrescritos.

Ejemplo #2 Ejemplo de conversión de tipos y sobrescritura

<?php
$array = array(
    1    => "a",
    "1"  => "b",
    1.5  => "c",
    true => "d",
);
var_dump($array);
?>

El ejemplo anterior mostrará :

array(1) {
  [1]=>
  string(1) "d"
}

Como todas las claves en el ejemplo anterior son convertidas a 1, el valor será sobrescrito en cada nuevo elemento y el último valor asignado "d" es el único que queda.

Los arrays de PHP pueden contener claves int y string al mismo tiempo ya que PHP no distingue entre arrays indexados y asociativos.

Ejemplo #3 Claves int y string mezcladas

<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
    100   => -100,
    -100  => 100,
);
var_dump($array);
?>

El ejemplo anterior mostrará :

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

La clave es opcional. Si no se especifica, PHP usará el incremento de la clave int más grande usada previamente.

Ejemplo #4 Arrays indexados sin clave

<?php
$array = array("foo", "bar", "hello", "world");
var_dump($array);
?>

El ejemplo anterior mostrará :

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hello"
  [3]=>
  string(5) "world"
}

Es posible especificar la clave solo para algunos elementos y omitirla para otros:

Ejemplo #5 Claves no en todos los elementos

<?php
$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);
var_dump($array);
?>

El ejemplo anterior mostrará :

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}

Como puede ver, el último valor "d" fue asignado con la clave 7. Esto es porque la clave entera más grande antes de eso era 6.

Ejemplo #6 Ejemplo complejo de conversión de tipos y sobrescritura

Este ejemplo incluye todas las variaciones de conversión de tipos de claves y sobrescritura de elementos.

<?php
$array = array(
    1    => 'a',
    '1'  => 'b', // el valor "a" será sobrescrito por "b"
    1.5  => 'c', // el valor "b" será sobrescrito por "c"
    -1 => 'd',
    '01'  => 'e', // como esto no es una cadena entera, NO sobrescribirá la clave para 1
    '1.5' => 'f', // como esto no es una cadena entera, NO sobrescribirá la clave para 1
    true => 'g', // el valor "c" será sobrescrito por "g"
    false => 'h',
    '' => 'i',
    null => 'j', // el valor "i" será sobrescrito por "j"
    'k', // el valor "k" es asignado con la clave 2. Esto es porque la clave entera más grande antes de eso era 1
    2 => 'l', // el valor "k" será sobrescrito por "l"
);

var_dump($array);
?>

El ejemplo anterior mostrará :

array(7) {
  [1]=>
  string(1) "g"
  [-1]=>
  string(1) "d"
  ["01"]=>
  string(1) "e"
  ["1.5"]=>
  string(1) "f"
  [0]=>
  string(1) "h"
  [""]=>
  string(1) "j"
  [2]=>
  string(1) "l"
}

Ejemplo #7 Ejemplo de índice negativo

Al asignar una clave entera negativa n, PHP se asegurará de asignar la siguiente clave a n+1.

<?php
$array = [];

$array[-5] = 1;
$array[] = 2;

var_dump($array);
?>

El ejemplo anterior mostrará :

array(2) {
  [-5]=>
  int(1)
  [-4]=>
  int(2)
}

Advertencia

Antes de PHP 8.3.0, asignar una clave entera negativa n asignaría la siguiente clave a 0, el ejemplo anterior produciría por lo tanto:

array(2) {
  [-5]=>
  int(1)
  [0]=>
  int(2)
}

Accediendo a elementos de array con sintaxis de corchetes

Los elementos de array pueden ser accedidos usando la sintaxis array[clave].

Ejemplo #8 Accediendo a elementos de array

<?php
$array = array(
    "foo" => "bar",
    42    => 24,
    "multi" => array(
         "dimensional" => array(
             "array" => "foo"
         )
    )
);

var_dump($array["foo"]);
var_dump($array[42]);
var_dump($array["multi"]["dimensional"]["array"]);
?>

El ejemplo anterior mostrará :

string(3) "bar"
int(24)
string(3) "foo"

Nota:
Antes de PHP 8.0.0, los corchetes y las llaves podían ser usados indistintamente para acceder a elementos de array (por ejemplo, $array[42] y $array{42} harían lo mismo en el ejemplo anterior). La sintaxis de llaves fue deprecada a partir de PHP 7.4.0 y ya no es soportada a partir de PHP 8.0.0.

Ejemplo #9 Desreferenciación de array

<?php
function getArray() {
    return array(1, 2, 3);
}

$secondElement = getArray()[1];

var_dump($secondElement);
?>

Nota:
Intentar acceder a una clave de array que no ha sido definida es lo mismo que acceder a cualquier otra variable no definida: se emitirá un mensaje de error de nivel E_WARNING (nivel E_NOTICE antes de PHP 8.0.0) y el resultado será null.

Nota:
La desreferenciación de array de un valor escalar que no es un string produce null. Antes de PHP 7.4.0, esto no emitía un mensaje de error. A partir de PHP 7.4.0, esto emite E_NOTICE; a partir de PHP 8.0.0, esto emite E_WARNING.

Creando/modificando con sintaxis de corchetes

Un array existente puede ser modificado asignando explícitamente valores en él.

Esto se hace asignando valores al array, especificando la clave entre corchetes. La clave también puede ser omitida, resultando en un par vacío de corchetes ([]).

$arr[clave] = valor;
$arr[] = valor;
// clave puede ser un int o string
// valor puede ser cualquier valor de cualquier tipo

Si $arr no existe aún o está establecido a null o false, será creado, por lo que esto es también una forma alternativa de crear un array. Sin embargo, esta práctica es desaconsejada porque si $arr ya contiene algún valor (por ejemplo, string de una variable de solicitud) entonces este valor permanecerá en su lugar y [] puede en realidad representar el operador de acceso a string. Siempre es mejor inicializar una variable mediante una asignación directa.

Nota: A partir de PHP 7.1.0, aplicar el operador de índice vacío en un string lanza un error fatal. Anteriormente, el string era convertido silenciosamente a un array.

Nota: A partir de PHP 8.1.0, crear un nuevo array a partir de un valor false está deprecado. Crear un nuevo array a partir de valores null y no definidos sigue estando permitido.

Para cambiar un cierto valor, asigne un nuevo valor a ese elemento usando su clave. Para eliminar un par clave/valor, llame a la función unset() sobre él.

Ejemplo #10 Usando corchetes con arrays

<?php
$arr = array(5 => 1, 12 => 2);

$arr[] = 56;    // Esto es lo mismo que $arr[13] = 56;
                // en este punto del script

$arr["x"] = 42; // Esto añade un nuevo elemento al
                // array con clave "x"

unset($arr[5]); // Esto elimina el elemento del array

var_dump($arr);

unset($arr);    // Esto elimina todo el array

var_dump($arr);
?>

Nota:
Como se mencionó anteriormente, si no se especifica una clave, se toma el máximo de los índices int existentes, y la nueva clave será ese valor máximo más 1 (pero al menos 0). Si no existen índices int aún, la clave será 0 (cero).

Tenga en cuenta que el índice entero máximo usado para esto no necesita existir actualmente en el array. Solo necesita haber existido en el array en algún momento desde la última vez que el array fue reindexado. El siguiente ejemplo lo ilustra:
<?php // Crear un array simple. $array = array(1, 2, 3, 4, 5); print_r($array); // Ahora eliminar cada elemento, pero dejar el array en sí intacto: foreach ($array as $i => $value) { unset($array[$i]); } print_r($array); // Añadir un elemento (note que la nueva clave es 5, en lugar de 0). $array[] = 6; print_r($array); // Reindexar: $array = array_values($array); $array[] = 7; print_r($array); ?>

El ejemplo anterior mostrará :
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)

Desestructuración de arrays

Los arrays pueden ser desestructurados usando la construcción de lenguaje [] (a partir de PHP 7.1.0) o list(). Estas construcciones pueden ser usadas para desestructurar un array en variables distintas.

Ejemplo #11 Desestructuración de arrays

<?php
$source_array = ['foo', 'bar', 'baz'];

[$foo, $bar, $baz] = $source_array;

echo $foo, PHP_EOL;    // imprime "foo"
echo $bar, PHP_EOL;    // imprime "bar"
echo $baz, PHP_EOL;    // imprime "baz"
?>

La desestructuración de arrays puede ser usada en foreach para desestructurar un array multidimensional mientras se itera sobre él.

Ejemplo #12 Desestructuración de arrays en foreach

<?php
$source_array = [
    [1, 'John'],
    [2, 'Jane'],
];

foreach ($source_array as [$id, $name]) {
    echo "{$id}: '{$name}'\n";
}
?>

Los elementos del array serán ignorados si la variable no es proporcionada. La desestructuración de arrays siempre comienza en el índice 0.

Ejemplo #13 Ignorando elementos

<?php
$source_array = ['foo', 'bar', 'baz'];

// Asignar el elemento en el índice 2 a la variable $baz
[, , $baz] = $source_array;

echo $baz;    // imprime "baz"
?>

A partir de PHP 7.1.0, los arrays asociativos también pueden ser desestructurados. Esto también permite una selección más fácil del elemento correcto en arrays indexados numéricamente ya que el índice puede ser especificado explícitamente.

Ejemplo #14 Desestructuración de arrays asociativos

<?php
$source_array = ['foo' => 1, 'bar' => 2, 'baz' => 3];

// Asignar el elemento en el índice 'baz' a la variable $three
['baz' => $three] = $source_array;

echo $three, PHP_EOL;  // imprime 3

$source_array = ['foo', 'bar', 'baz'];

// Asignar el elemento en el índice 2 a la variable $baz
[2 => $baz] = $source_array;

echo $baz, PHP_EOL;    // imprime "baz"
?>

La desestructuración de arrays puede ser usada para un intercambio fácil de dos variables.

Ejemplo #15 Intercambiando dos variables

<?php
$a = 1;
$b = 2;

[$b, $a] = [$a, $b];

echo $a, PHP_EOL;    // imprime 2
echo $b, PHP_EOL;    // imprime 1
?>

Nota:
El operador de propagación (...) no es soportado en asignaciones.

Nota:
Intentar acceder a una clave de array que no ha sido definida es lo mismo que acceder a cualquier otra variable no definida: se emitirá un mensaje de error de nivel E_WARNING (nivel E_NOTICE antes de PHP 8.0.0) y el resultado será null.

Funciones útiles

Hay bastantes funciones útiles para trabajar con arrays. Vea la sección de funciones de array.

Nota:
La función unset() permite eliminar claves de un array. Tenga en cuenta que el array no será reindexado. Si se desea un comportamiento de "eliminar y desplazar", el array puede ser reindexado usando la función array_values().

Ejemplo #16 Eliminando elementos intermedios

<?php $a = array(1 => 'one', 2 => 'two', 3 => 'three'); /* producirá un array que habría sido definido como $a = array(1 => 'one', 3 => 'three'); y NO $a = array(1 => 'one', 2 =>'three'); */ unset($a[2]); var_dump($a); $b = array_values($a); // Ahora $b es array(0 => 'one', 1 =>'three') var_dump($b); ?>

La estructura de control foreach existe específicamente para arrays. Proporciona una forma fácil de recorrer un array.

Qué hacer y qué no hacer con arrays

¿Por qué `$foo[bar]` está mal?

Siempre use comillas alrededor de un índice de array literal de cadena. Por ejemplo, $foo['bar'] es correcto, mientras que $foo[bar] no lo es. Pero, ¿por qué? Es común encontrar este tipo de sintaxis en scripts antiguos:

<?php
$foo[bar] = 'enemy';
echo $foo[bar];
// etc
?>

Esto está mal, pero funciona. La razón es que este código tiene una constante no definida (bar) en lugar de un string ('bar' - note las comillas). Funciona porque PHP convierte automáticamente una cadena sin comillas (una cadena sin comillas que no corresponde a ningún símbolo conocido) en un string que contiene la cadena sin comillas. Por ejemplo, si no hay una constante definida llamada bar, entonces PHP sustituirá la cadena 'bar' y la usará.

Advertencia

La opción de tratar una constante no definida como una cadena sin comillas emite un error de nivel E_NOTICE. Esto ha sido deprecado a partir de PHP 7.2.0, y emite un error de nivel E_WARNING. A partir de PHP 8.0.0, ha sido eliminado y lanza una excepción Error.

Esto no significa que siempre se deban poner comillas a la clave. No ponga comillas a las claves que son constantes o variables, ya que esto evitará que PHP las interprete.

Ejemplo #17 Claves con comillas

<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);

// Array simple:
$array = array(1, 2);
$count = count($array);

for ($i = 0; $i < $count; $i++) {
    echo "\nRevisando $i: \n";
    echo "Incorrecto: " . $array['$i'] . "\n";
    echo "Correcto: " . $array[$i] . "\n";
    echo "Incorrecto: {$array['$i']}\n";
    echo "Correcto: {$array[$i]}\n";
}
?>

El ejemplo anterior mostrará :

Revisando 0:
Notice: Índice no definido: $i en /ruta/al/script.html en la línea 9
Incorrecto:
Correcto: 1
Notice: Índice no definido: $i en /ruta/al/script.html en la línea 11
Incorrecto:
Correcto: 1

Revisando 1:
Notice: Índice no definido: $i en /ruta/al/script.html en la línea 9
Incorrecto:
Correcto: 2
Notice: Índice no definido: $i en /ruta/al/script.html en la línea 11
Incorrecto:
Correcto: 2

Más ejemplos para demostrar este comportamiento:

Ejemplo #18 Más ejemplos

<?php
// Mostrar todos los errores
error_reporting(E_ALL);

$arr = array('fruit' => 'apple', 'veggie' => 'carrot');

// Correcto
echo $arr['fruit'], PHP_EOL;  // apple
echo $arr['veggie'], PHP_EOL; // carrot

// Incorrecto. Esto funciona pero también lanza un error de PHP debido a
// una constante no definida llamada fruit
//
// Error: Constante no definida "fruit"
try {
    echo $arr[fruit];    // apple
} catch (Error $e) {
    echo get_class($e), ': ', $e->getMessage(), PHP_EOL;
}

// Esto define una constante para demostrar lo que está pasando. El valor 'veggie'
// es asignado a una constante llamada fruit.
define('fruit', 'veggie');

// Note la diferencia ahora
echo $arr['fruit'], PHP_EOL;  // apple
echo $arr[fruit], PHP_EOL;    // carrot

// Lo siguiente está bien, ya que está dentro de una cadena. Las constantes no son buscadas
// dentro de cadenas, por lo que no ocurre E_NOTICE aquí
echo "Hello $arr[fruit]", PHP_EOL;      // Hello apple

// Con una excepción: las llaves que rodean arrays dentro de cadenas permiten que las constantes
// sean interpretadas
echo "Hello {$arr[fruit]}", PHP_EOL;    // Hello carrot
echo "Hello {$arr['fruit']}", PHP_EOL;  // Hello apple

// La concatenación es otra opción
echo "Hello " . $arr['fruit'], PHP_EOL; // Hello apple
?>

<?php
// Esto no funcionará, y resultará en un error de análisis, como:
// Error de análisis: error de análisis, esperando T_STRING o T_VARIABLE o T_NUM_STRING'
// Esto, por supuesto, también se aplica al usar superglobals en cadenas
print "Hello $arr['fruit']";
print "Hello $_GET['foo']";
?>

Cuando error_reporting está configurado para mostrar errores de nivel E_NOTICE (configurándolo a E_ALL, por ejemplo), tales usos se harán inmediatamente visibles. Por defecto, error_reporting está configurado para no mostrar notificaciones.

Como se establece en la sección de sintaxis, lo que está dentro de los corchetes ('[' y ']') debe ser una expresión. Esto significa que el código como este funciona:

<?php
echo $arr[somefunc($bar)];
?>

Este es un ejemplo de usar el valor de retorno de una función como índice del array. PHP también conoce las constantes:

<?php
$error_descriptions[E_ERROR]   = "Ha ocurrido un error fatal";
$error_descriptions[E_WARNING] = "PHP emitió una advertencia";
$error_descriptions[E_NOTICE]  = "Esto es solo una notificación informal";
?>

Note que E_ERROR también es un identificador válido, al igual que bar en el primer ejemplo. Pero el último ejemplo es de hecho lo mismo que escribir:

<?php
$error_descriptions[1] = "Ha ocurrido un error fatal";
$error_descriptions[2] = "PHP emitió una advertencia";
$error_descriptions[8] = "Esto es solo una notificación informal";
?>

porque E_ERROR es igual a 1, etc.

Entonces, ¿por qué está mal?

En algún momento en el futuro, el equipo de PHP podría querer añadir otra constante o palabra clave, o una constante en otro código podría interferir. Por ejemplo, ya está mal usar las palabras empty y default de esta manera, ya que son palabras clave reservadas.

Nota: Para reiterar, dentro de una cadena entre comillas dobles, es válido no rodear los índices de array con comillas, por lo que "$foo[bar]" es válido. Vea los ejemplos anteriores para más detalles sobre por qué, así como la sección sobre análisis de variables en cadenas.

Conversión a array

Para cualquiera de los tipos int, float, string, bool y resource, convertir un valor a un array resulta en un array con un solo elemento con índice cero y el valor del escalar que fue convertido. En otras palabras, (array) $scalarValue es exactamente lo mismo que array($scalarValue).

Si un object es convertido a un array, el resultado es un array cuyos elementos son las propiedades del object. Las claves son los nombres de las variables miembro, con algunas excepciones notables: las propiedades enteras son inaccesibles; las variables privadas tienen el nombre de la clase antepuesto al nombre de la variable; las variables protegidas tienen un '*' antepuesto al nombre de la variable. Estos valores antepuestos tienen bytes NUL en ambos lados. Las propiedades tipadas no inicializadas son descartadas silenciosamente.

Ejemplo #19 Conversión a un array

<?php

class A {
    private $B;
    protected $C;
    public $D;
    function __construct()
    {
        $this->{1} = null;
    }
}

var_export((array) new A());
?>

El ejemplo anterior mostrará :

array (
  '' . "\0" . 'A' . "\0" . 'B' => NULL,
  '' . "\0" . '*' . "\0" . 'C' => NULL,
  'D' => NULL,
  1 => NULL,
)

Estos NUL pueden resultar en algún comportamiento inesperado:

Ejemplo #20 Conversión de un objeto a un array

<?php

class A {
    private $A; // Esto se convertirá en '\0A\0A'
}

class B extends A {
    private $A; // Esto se convertirá en '\0B\0A'
    public $AA; // Esto se convertirá en 'AA'
}

var_dump((array) new B());
?>

El ejemplo anterior mostrará :

array(3) {
  ["BA"]=>
  NULL
  ["AA"]=>
  NULL
  ["AA"]=>
  NULL
}

Lo anterior parecerá tener dos claves llamadas 'AA', aunque una de ellas está realmente llamada '\0A\0A'.

Convertir null a un array resulta en un array vacío.

Comparación

Es posible comparar arrays con la función array_diff() y con los operadores de array.

Desempaquetado de arrays

Un array precedido por ... será expandido en su lugar durante la definición del array. Solo arrays y objetos que implementan Traversable pueden ser expandidos. El desempaquetado de arrays con ... está disponible a partir de PHP 7.4.0. Esto también se llama el operador de propagación.

Es posible expandir múltiples veces, y añadir elementos normales antes o después del operador ...:

Ejemplo #21 Desempaquetado simple de arrays

<?php
// Usando sintaxis corta de array.
// También funciona con la sintaxis array().
$arr1 = [1, 2, 3];
$arr2 = [...$arr1]; // [1, 2, 3]
$arr3 = [0, ...$arr1]; // [0, 1, 2, 3]
$arr4 = [...$arr1, ...$arr2, 111]; // [1, 2, 3, 1, 2, 3, 111]
$arr5 = [...$arr1, ...$arr1]; // [1, 2, 3, 1, 2, 3]

function getArr() {
  return ['a', 'b'];
}
$arr6 = [...getArr(), 'c' => 'd']; // ['a', 'b', 'c' => 'd']

var_dump($arr1, $arr2, $arr3, $arr4, $arr5, $arr6);
?>

El desempaquetado de un array con el operador ... sigue la semántica de la función array_merge(). Es decir, las claves de cadena posteriores sobrescriben las anteriores y las claves enteras son renumeradas:

Ejemplo #22 Desempaquetado de arrays con clave duplicada

<?php
// clave de cadena
$arr1 = ["a" => 1];
$arr2 = ["a" => 2];
$arr3 = ["a" => 0, ...$arr1, ...$arr2];
var_dump($arr3); // ["a" => 2]

// clave entera
$arr4 = [1, 2, 3];
$arr5 = [4, 5, 6];
$arr6 = [...$arr4, ...$arr5];
var_dump($arr6); // [1, 2, 3, 4, 5, 6]
// Que es [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
// donde las claves enteras originales no han sido retenidas.
?>

Nota:
Las claves que no son ni enteras ni cadenas lanzan un TypeError. Tales claves solo pueden ser generadas por un objeto Traversable.

Nota:
Antes de PHP 8.1, el desempaquetado de un array que tiene una clave de cadena no es soportado:

<?php $arr1 = [1, 2, 3]; $arr2 = ['a' => 4]; $arr3 = [...$arr1, ...$arr2]; // Error fatal: Error no capturado: No se puede desempaquetar un array con claves de cadena en example.php:5 $arr4 = [1, 2, 3]; $arr5 = [4, 5]; $arr6 = [...$arr4, ...$arr5]; // funciona. [1, 2, 3, 4, 5] ?>

Ejemplos

El tipo array en PHP es muy versátil. Aquí hay algunos ejemplos:

Ejemplo #23 Versatilidad de arrays

<?php
// Esto:
$a = array( 'color' => 'red',
            'taste' => 'sweet',
            'shape' => 'round',
            'name'  => 'apple',
            4        // la clave será 0
          );

$b = array('a', 'b', 'c');

var_dump($a, $b);

// . . .es completamente equivalente a esto:
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name']  = 'apple';
$a[]        = 4;        // la clave será 0

$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';

// Después de que el código anterior sea ejecutado, $a será el array
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
// 'name' => 'apple', 0 => 4), y $b será el array
// array(0 => 'a', 1 => 'b', 2 => 'c'), o simplemente array('a', 'b', 'c').

var_dump($a, $b);
?>

Ejemplo #24 Usando array()

<?php
// Array como (mapa de propiedades)
$map = array( 'version'    => 4,
              'OS'         => 'Linux',
              'lang'       => 'english',
              'short_tags' => true
            );
var_dump($map);

// claves estrictamente numéricas
// esto es lo mismo que array(0 => 7, 1 => 8, ...)
$array = array( 7,
                8,
                0,
                156,
                -10
              );
var_dump($array);

$switching = array(         10, // clave = 0
                    5    =>  6,
                    3    =>  7,
                    'a'  =>  4,
                            11, // clave = 6 (el máximo de los índices enteros era 5)
                    '8'  =>  2, // clave = 8 (¡entero!)
                    '02' => 77, // clave = '02'
                    0    => 12  // el valor 10 será sobrescrito por 12
                  );
var_dump($switching);

// array vacío
$empty = array();
var_dump($empty);
?>

Ejemplo #25 Colección

<?php
$colors = array('red', 'blue', 'green', 'yellow');

foreach ($colors as $color) {
    echo "¿Te gusta $color?\n";
}

?>

El ejemplo anterior mostrará :

¿Te gusta red?
¿Te gusta blue?
¿Te gusta green?
¿Te gusta yellow?

Cambiar los valores del array directamente es posible pasándolos por referencia.

Ejemplo #26 Cambiar elemento en el bucle

<?php
$colors = array('red', 'blue', 'green', 'yellow');

foreach ($colors as &$color) {
    $color = mb_strtoupper($color);
}
unset($color); /* asegurar que las siguientes escrituras a
$color no modificarán el último elemento del array */

print_r($colors);
?>

El ejemplo anterior mostrará :

Array
(
    [0] => RED
    [1] => BLUE
    [2] => GREEN
    [3] => YELLOW
)

Este ejemplo crea un array basado en uno.

Ejemplo #27 Índice basado en uno

<?php
$firstquarter = array(1 => 'January', 'February', 'March');
print_r($firstquarter);
?>

El ejemplo anterior mostrará :

Array
(
    [1] => January
    [2] => February
    [3] => March
)

Ejemplo #28 Llenando un array

<?php
// llenar un array con todos los elementos de un directorio
$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
    $files[] = $file;
}
closedir($handle);

var_dump($files);
?>

Los arrays están ordenados. El orden puede ser cambiado usando varias funciones de ordenamiento. Vea la sección de funciones de array para más información. La función count() puede ser usada para contar el número de elementos en un array.

Ejemplo #29 Ordenando un array

<?php
sort($files);
print_r($files);
?>

Debido a que el valor de un array puede ser cualquier cosa, también puede ser otro array. Esto permite la creación de arrays recursivos y multidimensionales.

Ejemplo #30 Arrays recursivos y multidimensionales

<?php
$fruits = array ( "fruits"  => array ( "a" => "orange",
                                       "b" => "banana",
                                       "c" => "apple"
                                     ),
                  "numbers" => array ( 1,
                                       2,
                                       3,
                                       4,
                                       5,
                                       6
                                     ),
                  "holes"   => array (      "first",
                                       5 => "second",
                                            "third"
                                     )
                );
var_dump($fruits);

// Algunos ejemplos para direccionar valores en el array anterior
echo $fruits["holes"][5];    // imprime "second"
echo $fruits["fruits"]["a"]; // imprime "orange"
unset($fruits["holes"][0]);  // elimina "first"

// Crear un nuevo array multidimensional
$juices["apple"]["green"] = "good";
var_dump($juices);
?>

La asignación de array siempre implica la copia de valores. Use el operador de referencia para copiar un array por referencia.

Ejemplo #31 Copiado de arrays

<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 es cambiado,
             // $arr1 sigue siendo array(2, 3)

$arr3 = &$arr1;
$arr3[] = 4; // ahora $arr1 y $arr3 son los mismos

var_dump($arr1, $arr2, $arr3);
?>

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 5 notes

down

126

mlvljr ¶

14 years ago

please note that when arrays are copied, the "reference status" of their members is preserved (http://www.php.net/manual/en/language.references.whatdo.php).

down

thomas tulinsky ¶

9 years ago

I think your first, main example is needlessly confusing, very confusing to newbies:

$array = array(
    "foo" => "bar",
    "bar" => "foo",
);

It should be removed.
 
For newbies:
An array index can be any string value, even a value that is also a value in the array. 
The value of array["foo"] is "bar".
The value of array["bar"] is "foo"

The following expressions are both true:
$array["foo"] == "bar"
$array["bar"] == "foo"

down

ken underscore yap atsign email dot com ¶

17 years ago

"If you convert a NULL value to an array, you get an empty array."



This turns out to be a useful property. Say you have a search function that returns an array of values on success or NULL if nothing found.



<?php $values = search(...); ?>



Now you want to merge the array with another array. What do we do if $values is NULL? No problem:



<?php $combined = array_merge((array)$values, $other); ?>



Voila.

down

jeff splat codedread splot com ¶

20 years ago

Beware that if you're using strings as indices in the $_POST array, that periods are transformed into underscores:

<html>
<body>
<?php
    printf("POST: "); print_r($_POST); printf("<br/>");
?>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
    <input type="hidden" name="Windows3.1" value="Sux">
    <input type="submit" value="Click" />
</form>
</body>
</html>

Once you click on the button, the page displays the following:

POST: Array ( [Windows3_1] => Sux )

down

chris at ocportal dot com ¶

12 years ago

Note that array value buckets are reference-safe, even through serialization.



<?php

$x='initial';

$test=array('A'=>&$x,'B'=>&$x);

$test=unserialize(serialize($test));

$test['A']='changed';

echo $test['B']; // Outputs "changed"

?>



This can be useful in some cases, for example saving RAM within complex structures.

＋add a note

Arrays

Sintaxis

Especificación con array()

Accediendo a elementos de array con sintaxis de corchetes

Creando/modificando con sintaxis de corchetes

Desestructuración de arrays

Funciones útiles

Qué hacer y qué no hacer con arrays

¿Por qué $foo[bar] está mal?

Entonces, ¿por qué está mal?

Conversión a array

Comparación

Desempaquetado de arrays

Ejemplos

Found A Problem?

User Contributed Notes 5 notes

¿Por qué `$foo[bar]` está mal?