Arrays

Um array no PHP é atualmente um mapa ordenado. Um mapa é um tipo que relaciona valores para chaves. Este tipo é otimizado de várias maneiras, então você pode usá-lo como um array real, ou uma lista (vetor), hashtable (que é uma implementação de mapa), dicionário, coleção, pilha, fila e provavelmente mais. Como você pode ter outro array PHP como um valor, você pode facilmente simular árvores.

A explicação dessas estruturas estão além do escopo desse manual, mas você pode encontrar exemplos para cada uma dessas estruturas a seguir. Para mais informações sobre estruturas, refira-se a literatura externa sobre esses tópicos.

Sintaxe

Especificando com array()

Um array pode ser criado com o construtor de linguagem array(). Ele pega um certo número de pares separados por vírgula chave => valor .

Uma chave pode ser tanto um inteiro ou uma string. Se a chave é uma representação padrão de um inteiro, ele será interpretado assim (por exemplo, "8" será interpretado como 8, enquanto "08" será interpretado como "08").

O valor pode ser qualquer coisa.

Se omitir a chave, o maior índice inteiro é obtido, e a nova chave será esse máximo + 1. Como inteiros podem ser negativos, isto também é verdadeiro para índices negativos. Sendo, por exemplo, o maior índice -6, resultará em um novo índice -5. Se nenhum índice inteiro existir ainda, a chave será 0 (zero). Se você especifica uma chave que já possui um valor assimilada a ela, então o valor é sobrescrito.

Utilizar true como chave será interpretado como inteiro 1 na chave. Utilizando false como chave será avaliado como o inteiro 0. Usar NULL como chave é interpretado como uma string vazia. Usar uma string vazia como chave irá criar (ou sobrescerver) uma chave com uma string vazia e seu valor, e isto não é o mesmo que usar colchetes vazios.

Você não pode usar arrays ou objetos como chaves. Fazendo isso resultará em um alerta: Illegal offset type.

array( [chave =>] valor
     , ...
     )
// chave pode ser string ou integer não negativo
// valor pode ser qualquer coisa

Criando/modificando com a sintaxe de colchetes

Você pode também modificar um array existente, explicitando assimilando valores.

Isto é feito apenas assimilando valores para o array enquanto especificando a chave em colchetes. Você pode omitir a chave, colocando um par vazio de colchetes ("[]").
$arr[chave] = valor;
$arr[] = valor;
// chave tanto um string ou inteiro não negativo
// valor pode ser qualquer coisa
Se $arr não existir ainda, ele será criado. Então isto é um meio alternativo para especificar um array. Para mudar um certo valor, apenas assimile um novo valor para nele. Se você quiser remover um par chave/valor, você precisa aplicar unset() nele.

Funções úteis

Há uma série de funções muito úteis para trabalhar com arrays, veja a seção sobre arrays .

Nota: A função unset() permite apagar chaves de um array. Esteja avisado que o array NÃO vai ser reindexado.

$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');
*/

foreach existe especificamente para lidar com arrays. Ele provém uma maneira fácil de percorrer qualquer array.

Array: faça e não faça

Porque $foo[bar] está errado?

Você sempre deve usar delimitadores em volta um índice de um array associativo. Por exemplo, utilizar $foo['bar'] e não $foo[bar]. Mas porque $foo[bar] está errado? Afinal de contas, você vê essa sintaxe nos scripts antigos:

$foo[bar] = 'inimigo';
echo $foo[bar];
// etc

Isto está errado, mas funciona. Então, porque está errado? A razão está neste código, que tem uma constante indefinida (bar) em vez de uma string ('bar' - repare nos delimitadores), e o PHP pode no futuro definir constantes que, infelizmente em seu código, podem ter o mesmo nome. Isto funciona, porque constantes não definidas são convertidas em uma string com o mesmo nome.

Como explicado na seção sintaxe, a chave precisa estar entre colchetes ('[' e ']'). Isto significa que você pode escrever coisas como isso:

echo $arr[ foo(true) ];

Isto é um exemplo de utilização de um valor de retorno de função como um índice de array. O PHP conhece constantes, como você deve ter visto E_* antes.

$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 é um identificador válido, assim como bar no primeiro exemplo. Mas no último exemplo seria a mesma coisa que escrevendo:

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

Então, como é possível que $foo[bar] funcione? Funciona porque bar, na sintaxe onde é utilizada é esperada como uma expressão constante. Entretanto, nesse caso não existe constante com o nome bar. O PHP, hoje, assume que você quer bar literalmente, como a string "bar", mas que você esqueceu de escrever os delimitadores.

Então, porque isso é tão mal?

Se em algum ponto do futuro, o time do PHP quiser acrescentar outra constante ou palavra chave, você terá problemas. Por exemplo, se você já não pode utilizar as palavras empty e default dessa maneira, desde que elas são palavras reservadas especiais.

Nota: Quando você liga error_reporting em E_ALL, você irá ver as notícias que o PHP gera quando um índice é utilizado sem ser definido (coloque a linha error_reporting(E_ALL); em seu script).

Nota: Com strings delimitadas por aspas, uma outra sintaxe é válida. Veja interpretação de variáveis em string para mais detalhes.

Exemplos

O tipo array do PHP é muito versátil, por isso temos aqui alguns exemplos para mostrar todo o poder dos arrays.

// isto
$a = array( 'color' => 'vermelha'
          , 'taste' => 'doce'
          , 'shape' => 'redonda'
          , 'name'  => 'maçã'
          ,            4        // a chave será 0
          );

// isto é equivalente a acima
$a['cor'] = 'vermelha';
$a['sabor'] = 'doce';
$a['formato'] = 'redonda';
$a['nome'] = 'maçã';
$a[]        = 4;        // a chave será 0

$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// o mesmo de array( 0 => 'a' , 1 => 'b' , 2 => 'c' ),
// ou simplesmente array('a', 'b', 'c')

Exemplo 7-4. Utilizando array()

// Array como (propriedade-)mapa
$map = array( 'versão'     => 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 7-5. Coleção

$cores = array('vermelho','azul','verde','amarelo');

foreach ( $cores as $cor ) {
    echo "Você gosta de $cor?\n";
}

/* saida:
Você gosta de vermelho?
Você gosta de azul?
Você gosta de verde?
Você gosta de amarelo?
*/

Note que atualmente não se pode mudar os valores de um array diretamente dentro de um loop. Superar essa limitação é possível da seguinte forma:

Exemplo 7-6. Coleção

foreach ($cores as $key => $cor) {
    // não funciona:
    //$cor = strtoupper($cor);

    //funciona:
    $cores[$key] = strtoupper($cor);
}
print_r($cores);

/* saida:
Array
(
    [0] => VERMELHO
    [1] => AZUL
    [2] => VERDE
    [3] => AMARELO
)
*/

Este exemplo cria um array na base 1.

Exemplo 7-7. Array baseado em 1

$primeiroquarto  = array(1 => 'Janeiro', 'Fevereiro', 'Março');
print_r($primeiroquarto);

/* saida:
Array
(
    [1] => 'Janeiro'
    [2] => 'Fevereiro'
    [3] => 'Março'
)
*/

Exemplo 7-8. Preenchendo um array real

// preenchendo um array com todos os itens de um diretório
$handle = opendir('.');
while ($file = readdir($handle))
{
    $files[] = $file;
}
closedir($handle);

Arrays são ordenados. Você pode mudar sua ordem utilizando vários funções de ordenação. Veja as funções de arrays para mais informações.

Exemplo 7-9. Ordenando arrays

sort($files);
print_r($files);

Porque o valor de um array pode ser qualquer coisa, isto pode ser outro array. Isto pode criar arrays recursivos e multidimensionais.

Exemplo 7-10. Arrays recursivos e multidimensionais

$fruits = array ( "frutas"  => array ( "a" => "laranja"
                                     , "b" => "banana"
                                     , "c" => "maçã"
                                     )
                , "numeros" => array ( 1
                                     , 2
                                     , 3
                                     , 4
                                     , 5
                                     , 6
                                     )
                , "buracos" => array (      "primeiro"
                                     , 5 => "segundo"
                                     ,      "terceiro"
                                     )
                );