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).
Um array no PHP é na verdade um mapa ordenado. Um mapa é um tipo que relaciona valores a chaves. Este tipo é otimizado para várias usos diferentes: ele pode ser tratado como um array, uma lista (vetor), hashtable (que é uma implementação de mapa), dicionário, coleção, pilha, fila e provavelmente mais. Assim como existe a possibilidade dos valores do array serem outros arrays, árvores e arrays multidimensionais.
A explicação dessas estruturas está além do escopo deste manual, mas pelo menos um exemplo é dado para cada uma delas. Para mais informações, busque a considerável literatura que existe sobre esse extenso tópico.
Um array pode ser criado com o construtor de linguagem
array(). Ele leva qualquer quantidade de pares separados por vírgula
chave => valor
como argumentos.
array( chave => valor, chave2 => valor2, chave3 => valor3, ... )
A vírgula após o último elemento do array é opcional e pode ser omitida. Isso geralmente é feito
para arrays em uma única linha, por exemplo, array(1, 2)
é preferível em vez de
array(1, 2, )
. Para arrays escritos em várias linhas, por outro lado, a vírgula à direita do último elemento é
usada frequentemente, para permitir a adição de forma simples de novos elementos ao final.
Nota:
Existe uma sintaxe curta que substitui
array()
por[]
.
Exemplo #1 Um array simples
<?php
$array = array(
"foo" => "bar",
"bar" => "foo",
);
// Utilizando a sintaxe curta
$array = [
"foo" => "bar",
"bar" => "foo",
];
?>
A chave pode ser um int ou uma string. O valor pode ser de qualquer tipo.
Adicionalmente, as seguintes coerções ocorrerão a chave:
+
, serão convertidos para o tipo
int. Por exemplo, a chave"8"
será, na verdade,
armazenada como 8
. Entretanto, "08"
não
será convertido, por não ser um inteiro decimal válido.
8.7
será na verdade
armazenada como 8
.
true
, será na verdade armazenada como 1
e a chave false
como 0
.
null
na verdade será armazenada como ""
.
Illegal offset type
.
Se vários elementos na declaração do array utilizam a mesma chave, apenas o último será utilizado, enquanto todos os outros serão sobrescritos.
Exemplo #2 Exemplo de conversão de tipo e sobrescrita
<?php
$array = array(
1 => "a",
"1" => "b",
1.5 => "c",
true => "d",
);
var_dump($array);
?>
O exemplo acima produzirá:
array(1) { [1]=> string(1) "d" }
Como todas as chaves do exemplo acima foram convertidas para 1
, o valor será sobrescrito
a cada novo elemento e o valor final atribuído "d"
, será o único que restará.
As chaves dos arrays no PHP podem conter, ao mesmo tempo, int e string, porque o PHP não faz distinção entre arrays indexados e associativos.
Exemplo #3 Misturando int e string nas chaves
<?php
$array = array(
"foo" => "bar",
"bar" => "foo",
100 => -100,
-100 => 100,
);
var_dump($array);
?>
O exemplo acima produzirá:
array(4) { ["foo"]=> string(3) "bar" ["bar"]=> string(3) "foo" [100]=> int(-100) [-100]=> int(100) }
A key é opcional. Se não for especificada, o PHP utilizará o incremento da chave do tipo int com maior valor utilizado.
Exemplo #4 Arrays indexados sem chaves
<?php
$array = array("foo", "bar", "hello", "world");
var_dump($array);
?>
O exemplo acima produzirá:
array(4) { [0]=> string(3) "foo" [1]=> string(3) "bar" [2]=> string(5) "hello" [3]=> string(5) "world" }
É possível especificar a chave somente para alguns elementos e omití-las para outros:
Exemplo #5 Chaves em alguns elementos
<?php
$array = array(
"a",
"b",
6 => "c",
"d",
);
var_dump($array);
?>
O exemplo acima produzirá:
array(4) { [0]=> string(1) "a" [1]=> string(1) "b" [6]=> string(1) "c" [7]=> string(1) "d" }
Como pode ver, o último valor "d"
foi atribuído a chave
7
. Isso acontece porque a chave com maior inteiro antes dela
era 6
.
Exemplo #6 Exemplo de sobrescrita e cast de tipo complexo
Este exemplo inclui todas as variações de cast de tipo de chaves e sobrescrita de elementos.
<?php
$array = array(
1 => 'a',
'1' => 'b', // o valor "a" será sobrescrito por "b"
1.5 => 'c', // o valor "b" será sobrescrito por "c"
-1 => 'd',
'01' => 'e', // não é uma string de inteiro e NÃO sobrescreve a chave 1
'1.5' => 'f', // não é uma string de inteiro e NÃO sobrescreve a chave 1
true => 'g', // o valor "c" será sobrescrito por "g"
false => 'h',
'' => 'i',
null => 'j', // o valor "i" será sobrescrito por "j"
'k', // o valor "k" será alocado na chave 2. Isto porque é o maior inteiro após a chave 1
2 => 'l', // o valor "k" será sobrescrito por "l"
);
var_dump($array);
?>
O exemplo acima produzirá:
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" }
Elementos do array podem ser acessados utilizando a sintaxe array[chave]
.
Exemplo #7 Acessando elementos do 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"]);
?>
O exemplo acima produzirá:
string(3) "bar" int(24) string(3) "foo"
Nota:
Anteriormente ao PHP 8.0.0, chaves e colchetes podiam ser utilizados para acessar elementos de um array (por exemplo,
$array[42]
e$array{42}
irão fazer a mesma coisa que o exemplo anterior). O acesso por chaves foi descontinuado a partir do PHP 7.4.0 e não é mais suportado a partir do PHP 8.0.0.
Exemplo #8 Referenciando elemento de um array
<?php
function getArray() {
return array(1, 2, 3);
}
$secondElement = getArray()[1];
?>
Nota:
Tentativas de acesso a uma chave de array que não foi definida é o mesmo que acessar qualquer outra variável indefinida: uma mensagem de erro de nível
E_WARNING
(E_NOTICE
anteriormente ao PHP 8.0.0) será emitida, e o resultado seránull
.
Nota:
Acessar um array através de uma chave que não é string retorna
null
. Anteriormente ao PHP 7.4.0 não era emitida uma mensagem. A partir do PHP 7.4.0 emite umE_NOTICE
; e a partir do PHP 8.0.0 é emitido umE_WARNING
.
Você pode também modificar um array existente explicitamente assimilando valores a ele.
Isto é feito apenas assimilando valores para o array enquanto especifica a
chave em colchetes. Você pode omitir a chave, colocando um par vazio
de colchetes ([]
).
$arr[chave] = valor; $arr[] = valor; // chave pode ser tanto um int quanto uma string // valor pode ser qualquer valor de qualquer tipo
Se $arr não existir ou estiver preenchido com or is set to null
or false
, será criado, servindo como
alternativa para criação de um array. Entretanto, essa prática é
desencorajada por que se $arr conter
algum valor (por exemplo, uma string de uma variável de requisição), então este
valor permanecerá e o []
funcionará como
um operador de acesso
a string. Sempre será recomendado a inicialização de uma variável por atribuição
direta.
Nota: A partir do PHP 7.1.0, aplicar um operador de índice vazio a uma string lança um erro fatal. Antes, a string era silenciosamente convertida em um array.
Nota: A partir do PHP 8.1.0, criar um novo array a partir do valor
false
foi descontinuado. Crir um array a partir denull
e valores indefinidos ainda é permitido.
Para mudar um certo valor, apenas atribua um novo valor para um elemento especificado por sua chave. Se você quiser remover um par chave/valor, você precisa aplicar a função unset() na chave.
<?php
$arr = array(5 => 1, 12 => 2);
$arr[] = 56; // Isto é o mesmo que $arr[13] = 56;
// nesse ponto do script
$arr["x"] = 42; // Isto acrescenta um novo elemento
// para o array com a chave "x"
unset($arr[5]); // Isto remove um elemento do array
unset($arr); // E isto apaga todo o array
?>
Nota:
Como mencionado acima, se nenhuma chave for especificada, o maior índice int é obtido, e a nova chave será esse o máximo + 1. Se nenhum índice int existir ainda, a chave será
0
(zero).Note que a chave inteira de maior valor utilizada não precisa necessariamente existir no array. Ele precisa ter existido no array em algum momento desde sua última reindexação do array. Veja o seguinte exemplo:
<?php
// Criando um array normal
$array = array(1, 2, 3, 4, 5);
print_r($array);
// Agora apagando todos os itens, mas deixando o array intacto:
foreach ($array as $i => $value) {
unset($array[$i]);
}
print_r($array);
// Acrescentando um item (note que a chave é 5, em vez de zero).
$array[] = 6;
print_r($array);
// Reindexando:
$array = array_values($array);
$array[] = 7;
print_r($array);
?>O exemplo acima produzirá:
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 ) Array ( ) Array ( [5] => 6 ) Array ( [0] => 6 [1] => 7 )
Arrays podem ser desconstruídos utilizando []
(a partir do PHP 7.1.0) ou
list(). Esses
constructos podem ser utilizados para desconstruir o array em variáveis distintas.
<?php
$source_array = ['foo', 'bar', 'baz'];
[$foo, $bar, $baz] = $source_array;
echo $foo; // imprime "foo"
echo $bar; // imprime "bar"
echo $baz; // imprime "baz"
?>
A desconstrução de arrays pode ser utilizada no foreach para desconstruir um array multidimensional enquanto o percorre.
<?php
$source_array = [
[1, 'John'],
[2, 'Jane'],
];
foreach ($source_array as [$id, $name]) {
// Aqui $id e $name podem ser utilizados
}
?>
Elementos de arrays serão ignorados se a variável não for providenciada. Desconstrução
de arrays sempre iniciam no índice 0
.
<?php
$source_array = ['foo', 'bar', 'baz'];
// Atribui o elemento de índice 2 na variável $baz
[, , $baz] = $source_array;
echo $baz; // imprime "baz"
?>
A partir do PHP 7.1.0, é possível desconstruir arrays associativos. Isto permite fácil seleção do elemento correto de uma forma indexada numericamente dado que os índices podem ser especificados.
<?php
$source_array = ['foo' => 1, 'bar' => 2, 'baz' => 3];
// Atribui o elemento de índice 'baz' na variável $three
['baz' => $three] = $source_array;
echo $three; // imprime 3
$source_array = ['foo', 'bar', 'baz'];
// Atribui o elemento de índice 2 na variável $baz
[2 => $baz] = $source_array;
echo $baz; // imprime "baz"
?>
Desconstrução de arrays podem ser utilizados para trocar duas variáveis.
<?php
$a = 1;
$b = 2;
[$b, $a] = [$a, $b];
echo $a; // imprime 2
echo $b; // imprime 1
?>
Nota:
O operador de espalhamento (
...
) não é suportado em atribuições.
Nota:
Tentar acessar uma chave indefinida têm o mesmo efeito de acessar uma variável indefinida: um aviso
E_WARNING
(E_NOTICE
anteriormente ao PHP 8.0.0) será emitido, e o resultado seránull
.
Há uma série de funções úteis para trabalhar com arrays. Veja a seção sobre funções para arrays.
Nota:
A função unset() permite apagar chaves de um array. Esteja avisado que o array não será reindexado. Se um comportamento como "remover e deslocar" é o desejado, o array poderá ser reindexado utilizando a função array_values().
<?php
$a = array( 1 => 'um', 2 => 'dois', 3 => 'três' );
unset( $a[2] );
/* irá produzir um array que pode ser definido como
$a = array( 1=>'um', 3=>'três');
e NÃO
$a = array( 1 => 'um', 2 => 'três');
*/
$b = array_values($a);
// Agora $b é o array(0 => 'um', 1 =>'três')
?>
A estrutura de controle foreach existe especificamente para lidar com arrays. Ele provê uma maneira fácil de percorrer um array.
$foo[bar]
está errado?
Sempre utilize delimitadores em torno dos índices do array. Por exemplo,
$foo['bar']
está correto, enquanto que
$foo[bar]
, não está. Mas porque? É comum encontrar
essa sintaxe em scripts antigos:
<?php
$foo[bar] = 'inimigo';
echo $foo[bar];
// etc
?>
Isto está errado, mas funciona. A razão é que este código possui uma
constante indefinida (bar
) em vez de uma string ('bar'
- repare nas
aspas simples). Isto funciona, porque o PHP converte automaticamente uma
string base (uma string não delimitada que
não corresponde a nenhum símbolo conhecido) em uma string que contém
a string base. Por exemplo, se não existir uma constante definida com o
nome bar
, então o PHP irá substituí-la pela
string 'bar'
e usá-la.
O fallback que trata uma constante indefinida como uma string lança um erro
do nível E_NOTICE
.
Isso foi descontinuado desde o PHP 7.2.0, e lança um erro
do nível E_WARNING
.
A partir do PHP 8.0.0, esse fallback foi removido e agora lança uma
exceção Error.
Nota: Isto não significa que deve-se sempre delimitar as chaves. Não delimite chaves que sejam constantes ou variáveis, porque isso impedirá o PHP de interpretá-las.
<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);
// Arrays simples:
$array = array(1, 2);
$count = count($array);
for ($i = 0; $i < $count; $i++) {
echo "\nVerificando $i: \n";
echo "Ruim: " . $array['$i'] . "\n";
echo "Bom: " . $array[$i] . "\n";
echo "Ruim: {$array['$i']}\n";
echo "Bom: {$array[$i]}\n";
}
?>O exemplo acima produzirá:
Verificando 0: Notice: Undefined index: $i in /path/to/script.html on line 9 Ruim: Bom: 1 Notice: Undefined index: $i in /path/to/script.html on line 11 Ruim: Bom: 1 Verificando 1: Notice: Undefined index: $i in /path/to/script.html on line 9 Ruim: Bom: 2 Notice: Undefined index: $i in /path/to/script.html on line 11 Ruim: Bom: 2
Mais exemplos para demonstrar esse comportamento:
<?php
// Mostrando todos os erros
error_reporting(E_ALL);
$arr = array('fruta' => 'maçã', 'legume' => 'cenoura');
// Correto
print $arr['fruta']; // maçã
print $arr['legume']; // cenoura
// Errado. Isto funciona mas lança um erro PHP do
// nível E_NOTICE porque é utilizada uma constante indefinida (fruta)
//
// Repare: Quando utiliza-se a constante indefinida fruta, o PHP assume 'fruta'
print $arr[fruta]; // maçã
// Agora vamos definir uma constante para demonstrar o que pode acontecer. Nós
// vamos assimilar o valor 'legume' para a constante de nome fruta
define('fruta', 'legume');
// Observe a diferença agora
print $arr['fruit']; // maçã
print $arr[fruit]; // cenoura
// O exemplo seguinte é normal dentro de uma string. Constantes não são
// observadas dentro de strings e por isso nenhum E-NOTICE não é lançado aqui
print "Olá $arr[fruta]"; // Olá maçã
// Com uma exceção: chaves envolvendo arrays dentro de strings
// ativam a checagem de constantes, como em
print "Olá {$arr[fruta]}"; // Hello cenoura
print "Olá {$arr['fruta']}"; // Hello maçã
// E isso não funciona, resultando em um erro de interpretação do tipo:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Isso se aplica ao uso de superglobais em strings
print "Olá $arr['fruta']";
print "Olá $_GET['foo']";
// Nesse caso, use concatenação
print "Olá " . $arr['fruta']; // Olá maçã
?>
Quando a diretiva error_reporting for configurada
para mostrar erros de nível E_NOTICE
(configurando-a como
E_ALL
, por exemplo), se tornarão imediatamente
visíveis. Por padrão, a diretiva
error_reporting está configurada para não mostrar avisos.
Como especificado na seção sintaxe,
o que estiver entre os colchetes ('[
' e
']
'), precisa ser uma expressão. Isso significa que códigos como estes
funcionam:
<?php
echo $arr[algumafuncao($bar)];
?>
Isto é um exemplo de utilização de um valor de retorno de função como um índice de array. O PHP também aceita constantes:
<?php
$error_descriptions[E_ERROR] = "Um erro fatal ocorreu";
$error_descriptions[E_WARNING] = "O PHP emitiu um alarme";
$error_descriptions[E_NOTICE] = "Apenas um aviso informal";
?>
Note que E_ERROR
também é um identificador válido, assim como
bar
no primeiro exemplo. Mas no último exemplo seria, na verdade,
o mesmo que escrever:
<?php
$error_descriptions[1] = "Um erro fatal ocorreu";
$error_descriptions[2] = "O PHP emitiu um alarme";
$error_descriptions[8] = "Apenas um aviso informal";
?>
porque E_ERROR
é igual a 1
, e assim por diante.
Se em algum ponto do futuro, o time do PHP quiser acrescentar outra
constante ou palavra chave, ou você mesmo introduzir outra constante na
sua aplicação, você terá problemas. Por exemplo, já não se pode utilizar as palavras empty
e
default
dessa maneira, desde que elas são
palavras reservadas especiais.
Nota: Para reforçar, dentro de uma string delimitada por aspas duplas, é válido não englobar o índice do array com aspas simples, então
"$foo[bar]"
é válido. Veja os exemplos anteriores para detalhes assim como a seção sobre interpretação de variáveis em strings.
Para qualquer dos tipos: int, float,
string, bool e resource,
converter um valor para um array, resultará em um array com um único
elemento com índice zero e valor escalar convertido. Em
outras palavras, (array) $scalarValue
é exatamente o mesmo que
array($scalarValue)
.
Se um object é convertido para um array, o resultado
será um array em que seus elementos serão as propriedades do
object. As chaves serão os nomes das propriedades com pequenas notáveis
exceções: propriedades inteiras serão inacessíveis;
variáveis privadas tem o nome da classe prefixando o nome da
variável; variáveis protegidas tem um '*' prefixando o nome da variável. Esses
valores prefixados têm um byte NUL
em cada lado.
Propriedades tipadas
não inicializadas são ignoradas.
<?php
class A {
private $B;
protected $C;
public $D;
function __construct()
{
$this->{1} = null;
}
}
var_export((array) new A());
?>
O exemplo acima produzirá:
array ( '' . "\0" . 'A' . "\0" . 'B' => NULL, '' . "\0" . '*' . "\0" . 'C' => NULL, 'D' => NULL, 1 => NULL, )
Esses NUL
podem ocasionar comportamentos inesperados:
<?php
class A {
private $A; // Transformado na chave '\0A\0A'
}
class B extends A {
private $A; // Transformado na chave '\0B\0A'
public $AA; // Transformado na chave 'AA'
}
var_dump((array) new B());
?>
O exemplo acima produzirá:
array(3) { ["BA"]=> NULL ["AA"]=> NULL ["AA"]=> NULL }
Acima aparecem duas chaves chamadas 'AA', embora uma delas é, na verdade, nomeada '\0A\0A'.
Converter um valor null
para um array, você terá um
array vazio.
É possível comparar arrays utilizando a função array_diff() e com a utilização dos operadores de array.
Um array prefixado com ...
será expandido no local desse operador.
Somente arrays e objetos que implementem Traversable podem ser expandidos.
A expansão de arrays com ...
está disponível desde o PHP 7.4.0.
É possível realizar a expansão várias vezes, e adicionar elementos antes ou depois do operador...
:
Exemplo #9 Expansão de arrays
<?php
// Utilizando a sintaxe curta.
// Também funciona com a sintax 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']
?>
Expandir um array com ...
segue a semântica da função array_merge().
Ou seja, chaves strings sobrescrevem valores antigo e chaves inteiros são renumerados:
Exemplo #10 Expansão de arrays com chaves 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 resulta em [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
// pois as chaves inteiras anteriores não são preservadas.
?>
Nota:
Chaves que não sejam inteiros ou strings lançam um TypeError. Essas chaves podem ser geradas por um objeto Traversable.
Nota:
Anteriormente ao PHP 8.1, expansão de arrays com chave string não era suportado:
<?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]
?>
O tipo array do PHP é muito versátil. Temos aqui alguns exemplos:
<?php
// Isso:
$a = array( 'color' => 'red',
'taste' => 'sweet',
'shape' => 'round',
'name' => 'apple',
4 // key will be 0
);
$b = array('a', 'b', 'c');
// é equivalente a isso:
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name'] = 'apple';
$a[] = 4; // a chave será 0
$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// Após a execução do código acima, $ será o array
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
// 'name' => 'apple', 0 => 4), e $b será o array
// array(0 => 'a', 1 => 'b', 2 => 'c'), ou simplesmente array('a', 'b', 'c').
?>
Exemplo #11 Utilizando array()
<?php
// Array como (propriedade-)mapa
$map = array( 'versao' => 4,
'OS' => 'Linux',
'lang' => 'inglês',
'short_tags' => true
);
// apenas chaves numéricas
$array = array( 7,
8,
0,
156,
-10
);
// que é o mesmo que array( 0 => 7, 1 => 8, ...)
$switching = array( 10, // chave = 0
5 => 6,
3 => 7,
'a' => 4,
11, // chave = 6 (o índice máximo era 5)
'8' => 2, // chave = 8 (inteiro!)
'02' => 77, // chave = '02'
0 => 12 // o valor 10 será sobrescrito por 12
);
// array vazio
$empty = array();
?>
Exemplo #12 Coleção
<?php
$cores = array('vermelho', 'azul', 'verde', 'amarelo');
foreach ($cores as $cor) {
echo "Você gosta de $cor?\n";
}
?>
O exemplo acima produzirá:
Você gosta de vermelho? Você gosta de azul? Você gosta de verde? Você gosta de amarelo?
É possível alterar diretamente os valores de um array passando-os como referência.
Exemplo #13 Alterando valores em um laço
<?php
foreach ($colors as &$color) {
$color = mb_strtoupper($color);
}
unset($color); /* ensure that following writes to
$color will not modify the last array element */
print_r($colors);
?>
O exemplo acima produzirá:
Array ( [0] => RED [1] => BLUE [2] => GREEN [3] => YELLOW )
Este exemplo cria um array na base 1.
Exemplo #14 Array baseado em 1
<?php
$primeiroquarto = array(1 => 'Janeiro', 'Fevereiro', 'Março');
print_r($primeiroquarto);
?>
O exemplo acima produzirá:
Array ( [1] => 'Janeiro' [2] => 'Fevereiro' [3] => 'Março' )
Exemplo #15 Preenchendo um array
<?php
// preenchendo um array com todos os itens de um diretório
$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
$files[] = $file;
}
closedir($handle);
?>
arrays são ordenados. A ordem pode ser modificada utilizando várias funções de ordenação. Veja a seção de funções de arrays para mais informações. A função count() pode ser utilizada para contar o número de itens em um array.
Exemplo #16 Ordenando arrays
<?php
sort($files);
print_r($files);
?>
Como o valor de um array pode ser qualquer coisa, isso significa que também poderá ser outro array. Isso habilita a criação de arrays recursivos e multidimensionais.
Exemplo #17 Arrays recursivos e multidimensionais
<?php
$fruits = array ( "frutas" => array ( "a" => "laranja",
"b" => "banana",
"c" => "maçã"
),
"numeros" => array ( 1,
2,
3,
4,
5,
6
),
"buracos" => array ( "primeiro",
5 => "segundo",
"terceiro",
)
);
// Alguns exemplo de endereços dos valores do array acima
echo $fruits["buracos"][5]; // imprime "segundo"
echo $fruits["frutas"]["a"]; // imprime "laranja"
unset($fruits["buracos"][0]); // remove "primeiro"
// Criando um novo array multidimensional
$sucos["maca"]["verde"] = "bom";
?>
Atribuições de array sempre envolvem cópias de valores. Use o operador de referência para copiar um array por referência.
<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 é modificado,
// $arr1 continua sendo apenas array(2, 3)
$arr3 = &$arr1;
$arr3[] = 4; // agora $arr1 e $arr3 sao os mesmos
?>
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.