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).
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.
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:
+
, 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.
8.7
será almacenada bajo 8
.
true
será almacenada bajo 1
y la clave false
bajo 0
.
null
será almacenada bajo ""
.
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) }
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) }
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
(nivelE_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 emiteE_NOTICE
; a partir de PHP 8.0.0, esto emiteE_WARNING
.
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 valoresnull
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 )
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
(nivelE_NOTICE
antes de PHP 8.0.0) y el resultado seránull
.
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.
$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á.
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.
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.
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'.
Es posible comparar arrays con la función array_diff() y con los operadores de array.
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]
?>
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);
?>
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).
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"
"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.
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 )
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.