Sintaxis de un array

Un array puede ser creado utilizando la estructura de lenguaje array(). Toma un número ilimitado de parámetros, cada uno separado por una coma, en forma de un par key => value.

array(
    key  => value,
    key2 => value2,
    key3 => value3,
    ...
)

La coma después del último elemento de un array es opcional y puede no ser añadida. Generalmente, esto se hace para los arrays en una sola línea, i.e. array(1, 2) es preferido a array(1, 2, ). Para los arrays en varias líneas, la coma final generalmente se utiliza, ya que permite añadir más fácilmente nuevos elementos al final.

Nota:

Existe una sintaxis de array corta que reemplaza array() por [].

La clave key puede ser un int, o una string. El valor value puede ser de cualquier tipo.

Además, las siguientes modificaciones de tipo ocurrirán para la clave key :

• Las cadenas de caracteres que contienen un entero válido, a menos que el número esté precedido por un signo + serán modificadas a un tipo entero. I.e. la clave "8" será actualmente almacenada como el entero 8. Por otro lado, "08" no será modificada, sabiendo que no es un entero decimal válido.
• Los números de punto flotante también serán modificados a entero, lo que significa que la parte después de la coma será truncada. I.e. la clave 8.7 será almacenada bajo el entero 8.
• Los booleanos también serán modificados a entero, i.e. la clave true será almacenada bajo el entero 1 y la clave false bajo el entero 0.
• El valor Null será modificado a una cadena vacía, i.e. la clave null será almacenada bajo la cadena de caracteres "".
• Los arrays y los objetos no pueden ser utilizados como clave. Si se intenta, se emitirá la siguiente alerta: Illegal offset type.

Si varios elementos en la declaración de un array utilizan la misma clave, solo la última será utilizada, sobrescribiendo así todas las anteriores.

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

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

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

La clave key es opcional. Si no se especifica, PHP utilizará un incremento de la última clave entera utilizada.

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 no proporcionarla para otros:

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

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

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

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

Acceso a los elementos de un array utilizando la sintaxis a base de corchetes

Los elementos de un array pueden ser accedidos utilizando la sintaxis array[key].

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

Nota:

Anterior a PHP 8.0.0, los corchetes y llaves podían ser utilizados de manera intercambiable para acceder a los elementos de un array (e.g. $array[42] y $array{42} harían ambos lo mismo en el ejemplo anterior). La sintaxis con las llaves fue deprecada en PHP 7.4.0 y ya no es soportada a partir de PHP 8.0.0.

Nota:

Un intento de acceso a una clave de un array que no ha sido definida equivale a intentar acceder a una variable no definida: se emitirá una alerta de nivel E_WARNING (E_NOTICE antes de PHP 8.0.0), y el resultado valdrá null.

Nota:

Referenciar a un array a la salida de una función o un método de un valor escalar que no es una string genera null. Anterior a PHP 7.4.0, esto no generaba ningún mensaje de error. A partir de PHP 7.4.0, esto emite una E_NOTICE; A partir de PHP 8.0.0, esto emite una E_WARNING.

Creación/modificación con corchetes

Un array existente puede ser modificado asignándole explícitamente valores.

La asignación de un valor en un array se realiza especificando la clave, entre corchetes. La clave también puede no ser especificada, en la forma: [].

$arr[clé] = valeur;
$arr[] = valeur;
// clé puede ser un int o una string
// valeur puede ser cualquier tipo

Si durante la asignación $arr no existe o está definido a null o false, será creado; es así una manera indirecta de crear un array. Esta práctica es, sin embargo, desaconsejada porque si $arr contiene ya algunos valores (i.e. string desde la variable solicitada) entonces este valor permanecerá en su lugar y [] puede esperar un operador de acceso sobre una cadena. Es siempre una mejor opción inicializar una variable por asignación directa.

Nota: A partir de PHP 7.1.0, la aplicación del operador de índice vacío sobre una cadena lanza una excepción fatal. Anteriormente, la cadena habría sido convertida silenciosamente en array.

Nota: A partir de PHP 8.1.0, crear un nuevo array a partir de false es obsoleto. Crear un nuevo array desde null y los valores indefinidos sigue estando permitido.

Para modificar un valor en particular, es conveniente asignar un valor especificando su clave. Para borrar un par clave/valor, es conveniente llamar a la función unset() sobre la clave deseada.

Nota:

Como se dijo anteriormente, si no se especifica ninguna clave, el índice máximo existente es reutilizado, y la nueva clave será ese número, más 1 (pero al menos 0). Si no existe ningún índice entero, la clave será 0 (cero).

Tenga en cuenta que la clave entera máxima para esta operación no necesita existir en el array en el momento de la manipulación. Solo debe haber existido en el array en algún momento desde la última vez que el array fue reindexado. Aquí hay un ejemplo que ilustra este principio:

<?php
// Creación de un array simple.
$array = array(1, 2, 3, 4, 5);
print_r($array);

// Ahora, eliminamos todos los elementos, pero conservamos el array:
foreach ($array as $i => $value) {
unset($array[$i]);
}
print_r($array);

// Añadir un elemento (note que la nueva clave es 5, y no 0).
$array[] = 6;
print_r($array);

// Reindexación:
$array = array_values($array);
$array[] = 7;
print_r($array);
?>

El resultado del ejemplo sería:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)

Desestructuración de array

Los arrays pueden ser desestructurados utilizando [] (a partir de PHP 7.1.0) o list(). Estas construcciones pueden ser utilizadas para desestructurar un array en variables distintas.

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

Los elementos del array serán ignorados si la variable no es proporcionada. El array siempre comienza en el índice 0.

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

La desestructuración de array puede ser utilizada para permutar fácilmente dos variables.

Nota:

El operador de descomposición (...) no es soportado en las asignaciones.

Nota:

Un intento de acceso a una clave de un array que no ha sido definida equivale a intentar acceder a una variable no definida: se emitirá una alerta de nivel E_WARNING (E_NOTICE antes de PHP 8.0.0), y el resultado valdrá null.

¿Por qué $foo[bar] es incorrecto?

Utilice siempre comillas alrededor de un índice literal. 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:

Esto es incorrecto, pero funciona. La razón es que este código tiene una constante indefinida (bar) en lugar de una string ('bar' - note las comillas). Esto funciona porque PHP convierte automáticamente una cadena desnuda (una cadena sin comillas que no corresponde a ningún símbolo conocido) en una cadena que la contiene. Actualmente, si no hay ninguna constante llamada bar, entonces PHP sustituirá 'bar' en la cadena y la utilizará.

Esto no significa que siempre se deban poner las claves entre comillas. No utilice comillas con las claves que son constantes o variables, ya que esto impediría que PHP las interpretara.

El resultado del ejemplo sería:

Verificación de 0 :
Notice: Undefined index:  $i in /path/to/script.html on line 9
Incorrecto:
Correcto: 1
Notice: Undefined index:  $i in /path/to/script.html on line 11
Incorrecto:
Correcto: 1

Verificación de 1 :
Notice: Undefined index:  $i in /path/to/script.html on line 9
Incorrecto:
Correcto: 2
Notice: Undefined index:  $i in /path/to/script.html on line 11
Incorrecto:
Correcto: 2

Más ejemplos para explicar este comportamiento:

Cuando error_reporting está definido para mostrar los errores de tipo E_NOTICE (definiéndolo a E_ALL, por ejemplo), tal práctica se vuelve inmediatamente visible. Por defecto, error_reporting no está definido para mostrar todas las alertas.

Como se vio en la sección "sintaxis", lo que se encuentra entre corchetes ('[' y ']') debe ser una expresión. Esto significa que el código siguiente funciona:

Este es un ejemplo de uso de una función que devuelve un valor que será la clave del array. PHP también entiende las constantes:

Notar que E_ERROR también es un identificador válido, al igual que bar en el primer ejemplo. Pero el último ejemplo es finalmente el mismo que este:

porque E_ERROR vale 1, etc.