Especificación con array()

Un array puede ser creado usando la construcción del lenguaje array(). Acepta 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 suele hacer 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 [].

<?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, se producirán las siguientes conversiones de clave:

• 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" se almacenará realmente bajo 8. Por otro lado, "08" no será convertido, ya que no es un entero decimal válido.

• Los floats también se convierten a ints, lo que significa que la parte fraccionaria será truncada. Por ejemplo, la clave 8.7 se almacenará realmente bajo 8.

• Los bools se convierten a ints también, es decir, la clave true se almacenará realmente bajo 1 y la clave false bajo 0.

• Null se convertirá en una cadena vacía, es decir, la clave null se almacenará realmente 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.

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

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

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

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

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.

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

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:

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

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

<?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" se asigna a 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);
?>

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"
}

<?php
$array = [];

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

var_dump($array);
?>

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

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

Acceso a elementos de array con sintaxis de corchetes

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

<?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"]);
?>

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

Nota:

Antes de PHP 8.0.0, los corchetes y las llaves podían usarse 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.

<?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:

Desreferenciar 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.

Creación/modificación con sintaxis de corchetes

Un array existente puede ser modificado asignando valores explícitamente 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 de corchetes vacíos ([]).

$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 está desaconsejada porque si $arr ya contiene algún valor (por ejemplo, string de una variable de petición) entonces este valor permanecerá en su lugar y [] podría 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 se convertía 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 null y valores 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.

<?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:

Si no se especifica ninguna clave, la clave será el índice entero máximo existente + 1. Si el array no tiene índices enteros positivos, la clave será 0. A partir de PHP 8.3.0, también puede ser un entero negativo.

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.

<?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,