Especificación con array()

Un array puede ser creado con el constructor del lenguaje array(). Éste toma cualquier número de parejas 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, pudiéndose omitir. Esto normalmente se hace para arrays de una única línea, es decir, es preferible array(1, 2) que array(1, 2, ). Por otra parte, para arrays multilínea, la coma final se usa frecuentemente, ya que permite una adición más sencilla de nuevos elementos al final.

Existe una sintaxis de array corta, la cual reemplaza array() con [].

La clave puede ser un integer (entero) o un string (una cadena de texto). El valor puede ser de cualquier tipo.

Además, se darán los siguientes amoldamientos de clave:

• Strings que contiene un decimal válido integer, a menos que el número esté precedido por un signo +, será amoldado al tipo integer. Por ejemplo, la llave "8" será en realidad almacenado como 8. Por otro lado "08" no será moldeado, ya que no es un entero decimal válido.
• Un floats también será amoldado a integer, lo que significa que la parte fraccionaria se elimina. P.ej., la clave 8.7 en realidad será almacenada como 8.
• Un booleano son amoldados a integers también, es decir, la clave true en realidad será almacenada como 1 y la clave false como 0.
• Un null será amoldado a un string vacío, es decir, la clave null en realidad será almacenada como "".
• Los arrays y los objects no se pueden utilizar como claves. Si se hace, dará lugar a una advertencia: Illegal offset type.

Si varios elementos en la declaración del array usan la misma clave, sólo se utilizará la última, siendo los demás sobrescritos.

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

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

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 de tipo integer mayor utilizada anteriormente.

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

Es posible especificar la clave sólo para algunos elementos y excluir a los demás:

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 elementos de array con la sintaxis de corchete

Los elementos de array se pueden acceder utilizando la sintaxis array[key].

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

Nota:

Antes de PHP 8.0.0, tanto los corchetes como las llaves pueden ser utilizados de forma intercambiable para acceder a los elementos de un array (p.ej.: $array[42] y $array{42} tendrán el mismo resultado en el ejemplo anterior). La sintaxis de llaves se ha marcado como obsoleta en PHP 7.4.0 y se ha eliminado en PHP 8.0.0.

Nota:

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

Nota:

Array que dereferencia un valor escalar que no es un string arroja null. Antes de PHP 7.4.0, sin emitir un mensaje de error. Desde PHP 7.4.0, emite un error de nivel E_NOTICE; desde PHP 8.0.0, emite un error de nivel E_WARNING;

Creación/modificación con la sintaxis de corchete

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

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

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

Si $arr aún no existe, se creará, siendo también esta forma una alternativa de crear un array. Sin embargo, se desaconsejada esta práctica porque que si $arr ya contiene algún valor (p.ej. un string de una variable de petición), este estará en su lugar y [] puede significar realmente el operador de acceso a strings. Siempre es mejor inicializar variables mediante una asignación directa.

Nota: Desde PHP 7.1.0, aplicar el operador de índice vacío en un string lanza un error fatal. Antes, el string se convertía silenciosamente en un array.

Nota: Desde PHP 8.1.0, la creación de un array a partir de false está obsoleta. Aún se permite crear un array a partir de null y valores no definidos.

Para cambiar un valor determinado se debe asignar un nuevo valor a ese elemento empleando su clave. Para quitar una pareja clave/valor, se debe llamar a la función unset() con éste.

Nota:

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

Tenga en cuenta que la clave integer máxima utilizada para éste no es necesario que actualmente exista en el array. Ésta sólo debe haber existido en el array en algún momento desde la última vez que el array fué re-indexado. El siguiente ejemplo ilustra este comportamiento:

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

// Ahora elimina cada elemento, pero deja el mismo array intacto:
foreach ($array as $i => $value) {
unset($array[$i]);
}
print_r($array);

// Agregar un elemento (note que la nueva clave es 5, en lugar de 0).
$array[] = 6;
print_r($array);

// Re-indexar:
$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 arrays

Los arrays pueden ser desestructurados usando [] (desde PHP 7.1.0) o mediante el constructor de lenguaje list(). Estos constructores se pueden utilizar para desestructurar un array en distintas variables.

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

Se pueden ignorar elementos de un array al no proporcionar una variable. La desestructuración de arrays siempre comienza en el índice 0.

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

La desestructuración de arrays se puede utilizar para intercambiar fácilmente dos variables.

Nota:

El operador spread de propagación (...) no se admite en las asignaciones.

Nota:

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

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

Siempre deben usarse comillas alrededor de un índice de array tipo string 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 viejos:

Esto está mal, pero funciona. La razón es que este código tiene una constante indefinida (bar) en lugar de un string ('bar' - observe las comillas). Funciona porque PHP automáticamente convierte un string puro (un string sin comillas que no corresponde con ningún símbolo conocido) en un string que contiene el string puro. Por ejemplo, si no se ha definido una constante llamada bar, entonces PHP reemplazará su valor por el string 'bar' y usará éste último.

Nota: Esto no quiere decir que siempre haya que usar comillas en la clave. No use comillas con claves que sean constantes o variables, ya que en tal caso PHP no podrá interpretar sus valores.

<?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 "Mal: " . $array['$i'] . "\n";
echo "Bien: " . $array[$i] . "\n";
echo "Mal: {$array['$i']}\n";
echo "Bien: {$array[$i]}\n";
}
?>

El resultado del ejemplo sería:

Revisando 0:
Notice: Undefined index:  $i in /path/to/script.html on line 9
Mal:
Bien: 1
Notice: Undefined index:  $i in /path/to/script.html on line 11
Mal:
Bien: 1

Revisando 1:
Notice: Undefined index:  $i in /path/to/script.html on line 9
Mal:
Bien: 2
Notice: Undefined index:  $i in /path/to/script.html on line 11
Mal:
Bien: 2

Más ejemplos para demostrar este comportamiento:

Cuando se habilita error_reporting para mostrar errores de nivel E_NOTICE (como por ejemplo definiendo el valor E_ALL), este tipo de usos serán inmediatamente visibles. Por omisión, error_reporting se encuentra configurado para no mostrarlos.

Tal y como se indica en la sección de sintaxis, lo que existe entre los corchetes cuadrados ('[' y ']') debe ser una expresión. Esto quiere decir que código como el siguiente funciona:

Este es un ejemplo del uso de un valor devuelto por una función como índice del array. PHP también conoce las constantes:

Note que E_ERROR es también un identificador válido, asi como bar en el primer ejemplo. Pero el último ejemplo es equivalente a escribir:

ya que E_ERROR es igual a 1, etc.