Especificando com array()

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 a direita do último elemento é usada frequentemente, para permitir a adição de forma simples de novos elementos ao final.

A partir do PHP 5.4 você também pode utilizar a sintaxe contraída de array, que troca array() por [].

A chave pode ser um inteiro ou uma string. O valor pode ser de qualquer tipo.

Adicionalmente, as seguites coerções ocorrerão a chave:

• Strings contendo inteiros válidos, serão convertidos para o tipo inteiro. 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.
• Floats também são convertidos para inteiros, isso significa que a parte fracionada será removida. Por exemplo, a chave 8.7 será na verdade armazenada como 8.
• Booleanos são convertidos para inteiros, igualmente, por exemplo, a chave true, será na verdade armazenada como 1 e a chave false como 0.
• Null será convertido para uma string vazia, por exemplo, a chave null na verdade será armazenada como "".
• Arrays e objetos não podem ser usados como chaves. Fazer isso resultará em um aviso: 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.

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

As chaves dos arrays no PHP podem conter, ao mesmo tempo, inteiro e string, por que o PHP não faz distinção entre arrays indexados e associativos.

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

A chave é opcional. Se não for especificada, o PHP utilizará o incremento da chave do tipo inteiro com maior valor utilizado.

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:

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

Acessando elementos do array com colchetes

Elementos do array podem ser acessados utilizando a sintaxe array[chave].

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

Nota:

Tanto colchetes quanto chaves podem ser utilizados intercambiávelmente para acessar elementos de um array (por exemplo, $array[42] e $array{42} irão fazer a mesma coisa que o exemplo anterior).

A partir do PHP 5.4 é possível referenciar um elemento de um array como resultado de uma função ou método chamado diretamente. Antes, era possível somente através de uma variável temporária.

A partir do PHP 5.5 é possível referenciar elementos de um array literal.

Nota:

Tentativas de acesso a uma chave de array que não foi defina é o mesmo que acessar qualquer outra variável indefinida: uma mensagem de erro de nível E_NOTICE será emitida, e o resultado será NULL.

Criando/modificando com a sintaxe de colchetes

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 integer quanto uma string
// valor pode ser qualquer valor de qualquer tipo

Se ainda $arr não existir, 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á recomentado a inicialização de uma variável por atribuição direta.

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() nele.

Nota:

Como mencionado acima, se nenhuma chave for especificada, o maior índice inteiro é obtido, e a nova chave será esse o máximo + 1. Se nenhum índice inteiro 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. 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 irá imprimir:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)

Porque $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:

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). O PHP, no futuro, pode definir constantes que, infelizmente em algum código, pode ter os mesmos nome. 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.

Nota: Isto não que significa 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 irá imprimir:

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:

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:

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:

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:

porque E_ERROR é igual a 1, e assim por diante.