PHP 8.3.17 Released!

Arrays

Un array en PHP es en realidad un mapa ordenado. Un mapa es un tipo de datos que asocia valores con claves. Este tipo se optimiza para varios usos diferentes; se puede emplear como un array, lista (vector), tabla asociativa (tabla hash - una implementación de un mapa), diccionario, colección, pila, cola, y posiblemente más. Ya que los valores de un array pueden ser otros arrays, también son posibles árboles y arrays multidimensionales.

Una explicación sobre tales estructuras de datos está fuera del alcance de este manual, aunque se proporciona al menos un ejemplo de cada uno de ellos. Para más información, consulte la extensa literatura que existe sobre este amplio tema.

Sintaxis

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 [].

Ejemplo #1 Un array simple

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

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

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.

Ejemplo #2 Ejemplo de amoldamiento de tipo y sobrescritura

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

El resultado del ejemplo sería:

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

Como todas las claves en el ejemplo anterior se convierten en 1, los valores serán sobrescritos en cada nuevo elemento, por lo que el último valor asignado "d" es el único que queda.

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

Ejemplo #3 Claves mixtas integer y string

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

El resultado del ejemplo sería:

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.

Ejemplo #4 Arrays indexados sin clave

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

El resultado del ejemplo sería:

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:

Ejemplo #5 Claves no en todos los elementos

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

El resultado del ejemplo sería:

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

Como se puede ver, al último valor "d" se le asignó la clave 7. Esto es debido a que la mayor clave integer anterior era 6.

Ejemplo #6 Ejemplo de Conversión y Sobrescritura de tipos complejos

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', // Al no tratarse de un entero en un string, este NO sobrescribirá la clave 1
'1.5' => 'f', // Al no tratarse de un entero en un string, este NO sobrescribirá la clave 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" será asignado a la clave 2. Esto es porque la clave entero más grande hasta el momento es 1
2 => 'l', // El valor "k" será sobrescrito por "l"
);

var_dump($array);
?>

El resultado del ejemplo sería:

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

Cuando asignas una clave entera negativa n, PHP se encargará de asignar la siguiente clave a n+1.

<?php
$array
= [];

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

var_dump($array);
?>

El resultado del ejemplo sería:

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 por lo tanto mostraría:

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

Ejemplo #8 Acceso a elementos de un 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 resultado del ejemplo sería:

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.

Ejemplo #9 Hacer referencia al resultado array de funciones

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

$secondElement = getArray()[1];
?>

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.

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

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

$arr["x"] = 42; // Esto agrega un nuevo elemento a
// el array con la clave "x"

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

unset($arr); // Esto elimina el array completo
?>

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.

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

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

echo
$foo; // Imprime "foo"
echo $bar; // Imprime "bar"
echo $baz; // Imprime "baz"
?>

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

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

foreach (
$source_array as [$id, $name]) {
// Aquí la lógica con $id y $name
}
?>

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

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

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

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

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.

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

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

echo
$three; // Imprime 3

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

// Assign the element at index 2 to the variable $baz
[2 => $baz] = $source_array;

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

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

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

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

echo
$a; // Imprime 2
echo $b; // Imprime 1
?>

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.

Funciones útiles

Hay un buen número de funciones útiles para trabajar con arrays. Véase la sección funciones de array.

Nota:

La función unset() permite eliminar claves de un array. Tenga en cuenta que el array no es re-indexado. Si se desea un verdadero comportamiento "eliminar y desplazar", el array puede ser re-indexado usando la función array_values().

<?php
$a
= array(1 => 'uno', 2 => 'dos', 3 => 'tres');
unset(
$a[2]);
/* producirá un array que se ha definido como
$a = array(1 => 'uno', 3 => 'tres');
y NO
$a = array(1 => 'uno', 2 =>'tres');
*/

$b = array_values($a);
// Ahora $b es array(0 => 'uno', 1 =>'tres')
?>

La estructura de control foreach existe específicamente para arrays. Ésta provee una manera fácil de recorrer un array.

Recomendaciones sobre arrays y cosas a evitar

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

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

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.

Advertencia

La alternativa de tratar una constante indefinida como string vacío genera un error de nivel E_NOTICE. Este comportamiento está obsoleto desde PHP 7.2.0, y emite un error de nivel E_WARNING. Desde PHP 8.0.0, ha sido eliminado y lanza una excepción Error.

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:

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

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

// Correcto
print $arr['fruit']; // apple
print $arr['veggie']; // carrot

// Incorrecto. Esto funciona pero también genera un error de PHP de
// nivel E_NOTICE ya que no hay definida una constante llamada fruit
//
// Notice: Use of undefined constant fruit - assumed 'fruit' in...
print $arr[fruit]; // apple

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

// Note la diferencia ahora
print $arr['fruit']; // apple
print $arr[fruit]; // carrot

// Lo siguiente está bien ya que se encuentra al interior de una cadena. Las constantes no son procesadas al
// interior de cadenas, así que no se produce un error E_NOTICE aquí
print "Hello $arr[fruit]"; // Hello apple

// Con una excepción, los corchetes que rodean las matrices al
// interior de cadenas permiten el uso de constantes
print "Hello {$arr[fruit]}"; // Hello carrot
print "Hello {$arr['fruit']}"; // Hello apple

// Esto no funciona, resulta en un error de intérprete como:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Esto por supuesto se aplica también al uso de superglobales en cadenas
print "Hello $arr['fruit']";
print
"Hello $_GET['foo']";

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

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:

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

Este es un ejemplo del uso de un valor devuelto por 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 produjo una advertencia";
$error_descriptions[E_NOTICE] = "Esta es una noticia informal";
?>

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:

<?php
$error_descriptions
[1] = "Ha ocurrido un error fatal";
$error_descriptions[2] = "PHP produjo una advertencia";
$error_descriptions[8] = "Esta es una noticia informal";
?>

ya que E_ERROR es igual a 1, etc.

¿Entonces porqué está mal?

En algún momento en el futuro, puede que el equipo de PHP quiera usar otra constante o palabra clave, o una constante proveniente de otro código puede interferir. Por ejemplo, en este momento no puede usar las palabras empty y default de esta forma, ya que son palabras clave reservadas.

Nota: Reiterando, al interior de un valor string entre comillas dobles, es válido no rodear los índices de array con comillas, así que "$foo[bar]" es válido. Consulte los ejemplos anteriores para más detalles sobre el porqué, así como la sección sobre procesamiento de variables en cadenas.

Conversión a array

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

Si convierte un object 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 integer son inaccesibles; las variables privadas tienen el nombre de la clase al comienzo del nombre de la variable; las variables protegidas tienen un caracter '*' al comienzo del nombre de la variable. Estos valores adicionados al inicio tienen bytes NUL en cualquier lado. Las propiedades tipificadas no inicializadas se descartan silenciosamente.

<?php

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

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

El resultado del ejemplo sería:

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

Estos NUL pueden generar algún comportamiento inesperado:

<?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 resultado del ejemplo sería:

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

En el ejemplo anterior parecerá que se tienen dos claves llamadas 'AA', aunque en realidad una de ellas se llama '\0A\0A'.

Si convierte un valor null a array, obtiene un array vacío.

Comparación

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

Desempaquetando arrays

Un array precedido por ... será expandido en su lugar durante la definición del array. Solo los arrays y objetos que implementan Traversable pueden ser expandidos. El desempaquetado de arrays con el operador ... está disponible desde PHP 7.4.0.

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

Ejemplo #10 Desempaquetado simple de array

<?php
// Utilizando la sintaxis corta.
// Tambien 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']
?>

Desempaquetando un array con el operador ... sigue la semántica de la función array_merge(). Es decir, las claves de los arrays desempaquetados se reindexan si son numéricas y se sobrescriben si son cadenas:

Ejemplo #11 Desempaquetado arrays con claves duplicadas

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

// integer key
$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 no se han conservado las claves enteras originales.
?>

Nota:

Las claves que no son números enteros ni cadenas lanzan un TypeError. Estas claves solo pueden generarse mediante un objeto Traversable.

Nota:

Antes de PHP 8.1, no se permitía desempaquetar un array que tuviera una clave de tipo string:

<?php

$arr1
= [1, 2, 3];
$arr2 = ['a' => 4];
$arr3 = [...$arr1, ...$arr2];
// Fatal error: Uncaught Error: Cannot unpack array with string keys in example.php:5

$arr4 = [1, 2, 3];
$arr5 = [4, 5];
$arr6 = [...$arr4, ...$arr5]; // works. [1, 2, 3, 4, 5]
?>

Ejemplos

El tipo array en PHP es bastante versátil. Aquí hay algunos ejempos:

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

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

// . . .es completamente equivalente a
$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 se ejecute el código, $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').
?>

Ejemplo #12 Uso de array()

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

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

$switching = array( 10, // key = 0
5 => 6,
3 => 7,
'a' => 4,
11, // key = 6 (el índice entero máximo era 5)
'8' => 2, // key = 8 (integer!)
'02' => 77, // key = '02'
0 => 12 // el valor 10 será reemplazado por 12
);

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

Ejemplo #13 Colección

<?php
$colors
= array('rojo', 'azul', 'verde', 'amarillo');

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

?>

El resultado del ejemplo sería:

¿Le gusta el rojo?
¿Le gusta el azul?
¿Le gusta el verde?
¿Le gusta el amarillo?

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

Ejemplo #14 Cambiando elemento en el bucle

<?php
foreach ($colors as &$color) {
$color = strtoupper($color);
}
unset(
$color); /* Se asegura de que escrituras subsiguientes a $color
no modifiquen el último elemento del array */

print_r($colors);
?>

El resultado del ejemplo sería:

Array
(
    [0] => ROJO
    [1] => AZUL
    [2] => VERDE
    [3] => AMARILLO
)

Este ejemplo crea un array con base uno.

Ejemplo #15 Índice con base 1

<?php
$firstquarter
= array(1 => 'Enero', 'Febrero', 'Marzo');
print_r($firstquarter);
?>

El resultado del ejemplo sería:

Array
(
    [1] => 'Enero'
    [2] => 'Febrero'
    [3] => 'Marzo'
)

Ejemplo #16 Llenado de un array

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

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

Ejemplo #17 Ordenado de un array

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

Dado que el valor de un array puede ser cualquier cosa, también puede ser otro array. De esta forma es posible crear arrays recursivas y multi-dimensionales.

Ejemplo #18 Arrays recursivos y multi-dimensionales

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

// Algunos ejemplos que hacen referencia a los valores del array anterior
echo $fruits["holes"][5]; // Imprime "second"
echo $fruits["fruits"]["a"]; // Imprime "orange"
unset($fruits["holes"][0]); // Elimina "first"

// Crear una nueva array multi-dimensional
$juices["apple"]["green"] = "good";
?>

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

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

$arr3 = &$arr1;
$arr3[] = 4; // ahora $arr1 y $arr3 son iguales
?>
add a note

User Contributed Notes 5 notes

up
128
mlvljr
13 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).
up
74
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"
up
59
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.
up
55
jeff splat codedread splot com
19 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 )
up
37
chris at ocportal dot com
11 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.
To Top