Arrays em PHP

Por que arrays merecem a sua atenção total

Se você pro­gra­ma em PHP há mais de uma sem­ana, já usou arrays. Se pro­gra­ma há mais de um mês, provavel­mente já ficou pre­so depu­ran­do um array que não se com­por­ta­va como esper­a­va. Isso acon­tece porque arrays em PHP são, ao mes­mo tem­po, a estru­tu­ra de dados mais sim­ples e a mais com­plexa da lin­guagem.

Difer­ente de lin­gua­gens como Java ou C++, onde arrays são coleções de taman­ho fixo com tipo definido, o PHP tra­ta arrays como mapas orde­na­dos: estru­turas que podem armazenar qual­quer tipo de val­or, crescer dinami­ca­mente, mis­tu­rar chaves numéri­c­as e tex­tu­ais, e ser per­cor­ri­das de múlti­plas for­mas. Essa flex­i­bil­i­dade é um pre­sente e uma armadil­ha ao mes­mo tem­po.

Neste guia, você vai apren­der não só o que arrays são, mas como pen­sá-los, manip­ulá-los com efi­ciên­cia e evi­tar os erros que cus­tam horas de debug. Vamos cobrir des­de a cri­ação bási­ca até téc­ni­cas avançadas com funções fun­cionais, pas­san­do por per­for­mance, boas práti­cas e casos de uso reais.

Para quem é este guia

Desen­volve­dores PHP de qual­quer nív­el que querem ir além do bási­co e enten­der arrays com pro­fun­di­dade. Todo exem­p­lo é com­patív­el com PHP 7.4+ e tes­ta­do no PHP 8.3.

---

1. O que é um array em PHP, de verdade

A doc­u­men­tação ofi­cial do PHP define array como “um mapa orde­na­do que asso­cia val­ores a chaves”. Essa definição é mais pro­fun­da do que parece. Em out­ras lin­gua­gens, um array é uma sequên­cia con­tígua de memória. No PHP, um array é uma tabela hash com ordem de inserção preser­va­da. Isso sig­nifi­ca que:

1. Chaves podem ser inteiros ou strings
2. A ordem de inserção é sem­pre man­ti­da
3. Val­ores podem ser de qual­quer tipo, inclu­sive out­ros arrays
4. O mes­mo array pode ter chaves numéri­c­as e tex­tu­ais ao mes­mo tem­po

Inter­na­mente, o PHP imple­men­ta arrays usan­do a estru­tu­ra HashTable, que com­bi­na uma tabela hash para aces­so rápi­do por chave com uma lista dupla­mente encadea­da para preser­var a ordem. Isso garante aces­so em O(1) por chave e per­cur­so em ordem O(n).

Essa arquite­tu­ra tem uma con­se­quên­cia impor­tante: arrays PHP são copi­a­dos por val­or, não por refer­ên­cia. Quan­do você atribui um array a out­ra var­iáv­el, o PHP usa um mecan­is­mo chama­do copy-on-write: a cópia real só acon­tece quan­do uma das var­iáveis é mod­i­fi­ca­da. Isso tor­na a cópia bara­ta enquan­to os dados não mudam.

<?php
$a = [1, 2, 3];
$b = $a;        // nenhuma cópia acontece aqui (copy-on-write)
$b[] = 4;       // só agora o PHP duplica internamentevar_dump($a);   // [1, 2, 3] - não foi alterado
var_dump($b);   // [1, 2, 3, 4]
?>

1.1 Os três sabores de array

Na práti­ca, arrays PHP se apre­sen­tam em três for­mas, cada uma com um uso nat­ur­al:

Array indexado

O tipo mais famil­iar: uma lista de val­ores com índices numéri­cos automáti­cos começan­do em zero.

<?php
$linguagens = ['PHP', 'Python', 'JavaScript', 'Go'];echo $linguagens[0]; // PHP
echo $linguagens[3]; // Go
echo count($linguagens); // 4
?>

Array associativo

Um mapa de chave-val­or onde as chaves são strings com sig­nifi­ca­do semân­ti­co. É o equiv­a­lente PHP de um dicionário (Python), obje­to sim­ples (JavaScript) ou HashMap (Java).

<?php
$usuario = [
    'nome'   => 'Carla Mendes',
    'email'  => 'carla@exemplo.com',
    'idade'  => 32,
    'ativo'  => true,
];echo $usuario['nome'];  // Carla Mendes
echo $usuario['idade']; // 32
?>

Array multidimensional

Arrays que con­têm out­ros arrays como val­ores. Rep­re­sen­tam dados hierárquicos como tabelas de ban­co de dados, respostas de APIs JSON ou estru­turas em árvore.

<?php
$pedidos = [
    ['id' => 1, 'produto' => 'Notebook', 'valor' => 3500.00],
    ['id' => 2, 'produto' => 'Mouse',    'valor' => 89.90],
    ['id' => 3, 'produto' => 'Teclado',  'valor' => 149.90],
];echo $pedidos[0]['produto']; // Notebook
echo $pedidos[2]['valor'];   // 149.90
?>

---

2. Criando e acessando arrays

2.1 Sintaxes de criação

O PHP acei­ta duas sin­tax­es para cri­ar arrays. A sin­taxe mod­er­na com colchetes (disponív­el des­de PHP 5.4) é prefer­ív­el pela leg­i­bil­i­dade:

<?php
// Sintaxe moderna (recomendada)
$frutas = ['maçã', 'banana', 'uva'];// Sintaxe antiga com array()
$frutas = array('maçã', 'banana', 'uva');// Array vazio
$vazio = [];// Array com índices personalizados
$semana = [1 => 'segunda', 2 => 'terça', 3 => 'quarta'];
?>

2.2 Acesso e modificação

O aces­so a ele­men­tos usa colchetes com a chave. Para arrays anin­hados, encadeie os colchetes:

<?php
$config = [
    'banco' => [
        'host' => 'localhost',
        'porta' => 3306,
        'credenciais' => [
            'usuario' => 'root',
            'senha'   => 'secreto'
        ]
    ]
];// Acesso aninhado
echo $config['banco']['host'];                      // localhost
echo $config['banco']['credenciais']['usuario'];    // root// Modificação
$config['banco']['porta'] = 5432;// Adicionar nova chave
$config['banco']['nome'] = 'meu_banco';
?>

Dica de segu­rança
Nun­ca armazene sen­has em tex­to puro em arrays de con­fig­u­ração. Use var­iáveis de ambi­ente com getenv() ou uma bib­liote­ca como vlucas/phpdotenv.

2.3 Null coalescing para acesso seguro

Aces­sar uma chave inex­is­tente gera um avi­so no PHP 8. Use o oper­ador ?? para fornecer um val­or padrão de for­ma ele­gante:

<?php
$dados = ['nome' => 'João'];// Sem proteção - gera aviso se 'email' não existir
$email = $dados['email']; // Warning!// Com null coalescing
$email = $dados['email'] ?? 'não informado';// Encadeado para arrays aninhados
$cidade = $dados['endereco']['cidade'] ?? 'desconhecida';
?>

---

3. Adicionando e removendo elementos

3.1 Inserindo elementos

O PHP ofer­ece várias for­mas de inserir ele­men­tos depen­den­do de onde você quer inseri-los:

<?php
$nums = [2, 3, 4];// Adicionar ao final (as duas formas são equivalentes)
$nums[] = 5;
array_push($nums, 6, 7); // pode empurrar vários de uma vez// Adicionar ao início
array_unshift($nums, 0, 1);// Resultado: [0, 1, 2, 3, 4, 5, 6, 7]// Inserir no meio com array_splice
$letras = ['a', 'b', 'd', 'e'];
array_splice($letras, 2, 0, ['c']); // inserir 'c' na posição 2
// ['a', 'b', 'c', 'd', 'e']
?>

3.2 Removendo elementos

<?php
$nums = [1, 2, 3, 4, 5];// Remover o último elemento e retornar seu valor
$ultimo = array_pop($nums);   // $ultimo = 5, $nums = [1,2,3,4]// Remover o primeiro elemento e retornar seu valor
$primeiro = array_shift($nums); // $primeiro = 1, $nums = [2,3,4]// Remover por índice (não reindexar)
unset($nums[1]); // remove índice 1, deixa buraco nos índices// Remover e reindexar
array_splice($nums, 1, 1); // remove 1 elemento da posição 1
?>

Cuida­do com unset()
O unset() remove o ele­men­to mas não rein­dexa o array. Se você pre­cis­ar que os índices sejam sequen­ci­ais após a remoção, use array_values() para rein­dexar ou pre­fi­ra array_splice().

---

4. Percorrendo arrays com foreach e além

4.1 O foreach e suas variantes

O foreach é o laço preferi­do para per­cor­rer arrays no PHP. Ele é mais legív­el, menos propen­so a erros de índice e fun­ciona tan­to com arrays index­a­dos quan­to asso­cia­tivos:

<?php
// Percorrer apenas valores
$cores = ['azul', 'verde', 'vermelho'];
foreach ($cores as $cor) {
    echo $cor . PHP_EOL;
}// Percorrer chave e valor
$precos = ['maçã' => 3.50, 'banana' => 1.20, 'uva' => 6.00];
foreach ($precos as $fruta => $preco) {
    printf('%s custa R$ %.2f%s', $fruta, $preco, PHP_EOL);
}// Modificar por referência (use &)
$numeros = [1, 2, 3, 4, 5];
foreach ($numeros as &$numero) {
    $numero *= 2;
}
unset($numero); // IMPORTANTE: quebrar a referência após o loop
// $numeros = [2, 4, 6, 8, 10]
?>

4.2 Percorrendo arrays multidimensionais

<?php
$funcionarios = [
    ['nome' => 'Ana',    'depto' => 'TI',      'salario' => 8500],
    ['nome' => 'Bruno',  'depto' => 'RH',      'salario' => 6200],
    ['nome' => 'Carla',  'depto' => 'TI',      'salario' => 9100],
    ['nome' => 'Daniel', 'depto' => 'Vendas',  'salario' => 7300],
];// Calcular total de salários do departamento de TI
$totalTI = 0;
foreach ($funcionarios as $func) {
    if ($func['depto'] === 'TI') {
        $totalTI += $func['salario'];
    }
}
echo 'Total TI: R$ ' . number_format($totalTI, 2, ',', '.'); // R$ 17.600,00
?>

---

5. Funções essenciais de array

O PHP pos­sui mais de 80 funções nati­vas para manip­u­lação de arrays. Con­hecer as prin­ci­pais muda com­ple­ta­mente a qual­i­dade e a veloci­dade do seu códi­go. Vamos cobrir as mais impor­tantes por cat­e­go­ria.

5.1 Ordenação

O PHP ofer­ece diver­sas funções de orde­nação, cada uma com um com­por­ta­men­to especí­fi­co em relação às chaves:

Função	Man­tém chaves?	Uso
sort()	Não	Orde­na val­ores cres­cente, rein­dexa
rsort()	Não	Orde­na val­ores decres­cente, rein­dexa
asort()	Sim	Orde­na val­ores cres­cente, preser­va chaves
arsort()	Sim	Orde­na val­ores decres­cente, preser­va chaves
ksort()	Sim	Orde­na por chave cres­cente
usort()	Não	Orde­na com função per­son­al­iza­da
uasort()	Sim	Orde­na com função per­son­al­iza­da, preser­va chaves

<?php
// Ordenar array de produtos por preço (crescente)
$produtos = [
    ['nome' => 'Teclado',  'preco' => 149.90],
    ['nome' => 'Monitor',  'preco' => 1299.00],
    ['nome' => 'Mouse',    'preco' => 89.90],
];usort($produtos, fn($a, $b) => $a['preco'] <=> $b['preco']);// Resultado: Mouse (89.90), Teclado (149.90), Monitor (1299.00)
foreach ($produtos as $p) {
    echo $p['nome'] . ': R$ ' . $p['preco'] . PHP_EOL;
}
?>

5.2 Busca e filtragem

<?php
$nomes = ['Ana', 'Bruno', 'Carla', 'Ana', 'Daniel'];// Verificar se valor existe
in_array('Bruno', $nomes); // true
in_array('Eduardo', $nomes); // false// Busca com strict type checking
in_array('1', [1, 2, 3]);         // true (loose)
in_array('1', [1, 2, 3], true);   // false (strict)// Obter a chave do valor encontrado
$chave = array_search('Carla', $nomes); // 2// Filtrar com critério personalizado
$maiores = ['Alice' => 28, 'Bob' => 17, 'Carol' => 34, 'Dave' => 15];
$adultos = array_filter($maiores, fn($idade) => $idade >= 18);
// ['Alice' => 28, 'Carol' => 34]
?>

5.3 Transformação com array_map

O array_map apli­ca uma função a cada ele­men­to do array e retor­na um novo array com os resul­ta­dos. É ide­al para trans­for­mações limpas sem efeitos colat­erais:

<?php
$precos = [100, 200, 350, 500];// Aplicar desconto de 10%
$comDesconto = array_map(fn($p) => $p * 0.90, $precos);
// [90, 180, 315, 450]// Trabalhar com múltiplos arrays
$quantidades = [2, 1, 3, 2];
$totais = array_map(fn($p, $q) => $p * $q, $precos, $quantidades);
// [200, 200, 1050, 1000]// Aplicar função nativa
$nomes = ['  Ana  ', 'BRUNO', 'carla'];
$normalizados = array_map('trim', $nomes);
$normalizados = array_map('strtolower', $normalizados);
// ['ana', 'bruno', 'carla']
?>

5.4 Redução com array_reduce

O array_reduce é a naval­ha suíça das funções de array. Ele per­corre o array acu­mu­lan­do um úni­co val­or. Qual­quer oper­ação de agre­gação (soma, pro­du­to, máx­i­mo, con­cat) pode ser fei­ta com ele:

<?php
$pedido = [
    ['produto' => 'Notebook',  'valor' => 3500, 'qtd' => 1],
    ['produto' => 'Mouse',     'valor' => 90,   'qtd' => 2],
    ['produto' => 'Mochila',   'valor' => 200,  'qtd' => 1],
];// Calcular valor total do pedido
$total = array_reduce($pedido, function($carry, $item) {
    return $carry + ($item['valor'] * $item['qtd']);
}, 0);echo 'Total: R$ ' . number_format($total, 2, ',', '.'); // R$ 3.880,00
?>

5.5 Combinação e divisão

<?php
// Unir dois arrays (chaves iguais: o segundo sobrescreve)
$padrao = ['cor' => 'azul', 'tam' => 'M', 'estoque' => true];
$personalizado = ['cor' => 'vermelho', 'tam' => 'G'];
$final = array_merge($padrao, $personalizado);
// ['cor' => 'vermelho', 'tam' => 'G', 'estoque' => true]// Combinar dois arrays em chave-valor
$chaves = ['nome', 'idade', 'cidade'];
$valores = ['Maria', 25, 'Curitiba'];
$pessoa = array_combine($chaves, $valores);
// ['nome' => 'Maria', 'idade' => 25, 'cidade' => 'Curitiba']// Extrair uma fatia
$nums = [10, 20, 30, 40, 50, 60];
$fatia = array_slice($nums, 1, 3);   // [20, 30, 40]
$fim   = array_slice($nums, -2);      // [50, 60]// Dividir em blocos (para paginação, por exemplo)
$itens = range(1, 10);
$paginas = array_chunk($itens, 3);
// [[1,2,3], [4,5,6], [7,8,9], [10]]
?>

5.6 Array e string: implode e explode

A con­ver­são entre strings e arrays é uma das oper­ações mais comuns em PHP, espe­cial­mente ao proces­sar entradas de for­mulários, CSV ou parâmet­ros de URL:

<?php
// Array para string
$tags = ['php', 'arrays', 'backend', 'web'];
echo implode(', ', $tags);  // php, arrays, backend, web
echo implode(' | ', $tags); // php | arrays | backend | web// String para array
$csv = 'Ana,28,Engenheira,São Paulo';
[$nome, $idade, $cargo, $cidade] = explode(',', $csv);// Limitar o número de partes
$url = 'https://exemplo.com/produtos/notebook/preto';
$partes = explode('/', $url, 4);
// ['https:', '', 'exemplo.com', 'produtos/notebook/preto']// Processar CSV completo
$linhas = "Ana,28\nBruno,32\nCarla,25";
$pessoas = array_map(
    fn($linha) => explode(',', $linha),
    explode("\n", $linhas)
);
?>

---

6. Técnicas avançadas

6.1 Programação funcional com arrays

Uma das evoluções mais impor­tantes do PHP mod­er­no foi a incor­po­ração de par­a­dig­mas fun­cionais no tra­bal­ho com arrays. Com­bi­nan­do array_map, array_filter e array_reduce, é pos­sív­el escr­ev­er pipelines de trans­for­mação de dados que são legíveis, testáveis e sem efeitos colat­erais.

<?php
// Cenário: processar relatório de vendas
$vendas = [
    ['vendedor' => 'Ana',    'valor' => 12500, 'mes' => 'jan', 'meta' => 10000],
    ['vendedor' => 'Bruno',  'valor' => 8200,  'mes' => 'jan', 'meta' => 10000],
    ['vendedor' => 'Carla',  'valor' => 15800, 'mes' => 'jan', 'meta' => 12000],
    ['vendedor' => 'Daniel', 'valor' => 9100,  'mes' => 'fev', 'meta' => 10000],
];// 1. Filtrar apenas vendas de janeiro
$janeiro = array_filter($vendas, fn($v) => $v['mes'] === 'jan');// 2. Filtrar quem bateu a meta
$bateram = array_filter($janeiro, fn($v) => $v['valor'] >= $v['meta']);// 3. Extrair apenas os nomes
$nomes = array_map(fn($v) => $v['vendedor'], $bateram);// 4. Formatar para exibição
echo 'Bateram a meta em jan: ' . implode(', ', $nomes);
// Ana, Carla
?>

6.2 Desestruturação de arrays

O PHP 7.1 intro­duz­iu a deses­tru­tu­ração com colchetes, sim­i­lar ao destruc­tur­ing do JavaScript. Ela elim­i­na códi­go repet­i­ti­vo ao extrair múlti­p­los val­ores de um array:

<?php
// Desestruturação simples
$ponto = [10, 25];
[$x, $y] = $ponto;
echo "X: $x, Y: $y"; // X: 10, Y: 25// Ignorar elementos
$dados = ['Ana', 32, 'Engenheira', 'SP'];
[$nome, , $cargo] = $dados; // ignora a idade// Desestruturação de array associativo
$config = ['host' => 'localhost', 'porta' => 3306, 'banco' => 'loja'];
['host' => $host, 'banco' => $banco] = $config;
echo "$host/$banco"; // localhost/loja// Em foreach
$pontos = [[1, 2], [3, 4], [5, 6]];
foreach ($pontos as [$x, $y]) {
    echo "($x, $y) ";
}
?>

6.3 Spread operator em arrays (PHP 8.1+)

O oper­ador spread (...) per­mite expandir um array den­tro de out­ro, sub­sti­tuin­do em muitos casos o array_merge de for­ma mais legív­el:

<?php
$base = [1, 2, 3];
$extra = [4, 5, 6];// Equivalente a array_merge, mas mais legível
$completo = [...$base, ...$extra];
// [1, 2, 3, 4, 5, 6]// Com arrays associativos (PHP 8.1+)
$padrao = ['timeout' => 30, 'retries' => 3];
$custom  = ['timeout' => 60];
$config  = [...$padrao, ...$custom];
// ['timeout' => 60, 'retries' => 3]
?>

6.4 array_column: extraindo colunas de arrays 2D

Uma das funções mais subes­ti­madas do PHP. O array_column extrai uma col­u­na de um array mul­ti­di­men­sion­al, com a opção de rein­dexar por out­ra col­u­na:

<?php
$usuarios = [
    ['id' => 1, 'nome' => 'Ana',   'email' => 'ana@ex.com'],
    ['id' => 2, 'nome' => 'Bruno', 'email' => 'bruno@ex.com'],
    ['id' => 3, 'nome' => 'Carla', 'email' => 'carla@ex.com'],
];// Extrair todos os nomes
$nomes = array_column($usuarios, 'nome');
// ['Ana', 'Bruno', 'Carla']// Reindexar por ID
$porId = array_column($usuarios, null, 'id');
// [1 => ['id'=>1,'nome'=>'Ana',...], 2 => [...], ...]// Extrair emails indexados por nome
$emailsPorNome = array_column($usuarios, 'email', 'nome');
// ['Ana' => 'ana@ex.com', 'Bruno' => 'bruno@ex.com', ...]
?>

---

7. Performance e boas práticas

7.1 Quando arrays começam a custar caro

Arrays PHP são ver­sáteis, mas não gra­tu­itos. Cada ele­men­to de um array PHP 7+ ocu­pa em torno de 40 bytes de memória. Um array com 1 mil­hão de inteiros pode facil­mente con­sumir 40 MB. Para com­para­ção, o mes­mo dado em um array tipa­do de C ocu­paria menos de 8 MB.

Isso não é moti­vo para evi­tar arrays, mas é moti­vo para usá-los com con­sciên­cia. Aqui estão os princí­pios que sep­a­ram códi­go bom de códi­go efi­ciente:

1. Prefer­ên­cia por leitu­ra úni­ca: se você pre­cisa per­cor­rer um resul­ta­do de ban­co de dados ape­nas uma vez, use gen­er­a­tors em vez de car­regar tudo em array.
2. Evite cópias desnecessárias: passe arrays grandes por refer­ên­cia (&$array) em funções que pre­cisam mod­i­ficá-los.
3. Use isset() em vez de array_key_exists() quan­do pos­sív­el: isset() é cer­ca de 2x mais rápi­do (mas retor­na false para val­ores null).
4. Pré-aloque quan­do o taman­ho é con­heci­do: emb­o­ra o PHP não ofer­eça pré-alo­cação explíci­ta, reduzir reatribuições den­tro de loops mel­ho­ra a per­for­mance.

7.2 Boas práticas de nomenclatura e estrutura

<?php
// Ruim: nome genérico, sem clareza sobre o conteúdo
$data = [...];
$arr = [...];
$list = [...];// Bom: nome plural e descritivo
$usuarios = [...];
$produtosAtivos = [...];
$errosDeValidacao = [...];// Ruim: misturar tipos no mesmo array
$info = ['Ana', 28, true, null];// Bom: estrutura consistente e previsível
$usuario = [
    'nome'  => 'Ana',
    'idade' => 28,
    'ativo' => true,
];
?>

7.3 Validação robusta de arrays

Arrays prove­nientes de entra­da exter­na (for­mulários, APIs, arquiv­os) nun­ca devem ser con­fi­a­dos sem val­i­dação. O PHP ofer­ece fer­ra­men­tas nati­vas para isso:

<?php
function validarUsuario(array $dados): array {
    $erros = [];    if (empty($dados['nome']) || strlen($dados['nome']) < 2) {
        $erros[] = 'Nome inválido';
    }    if (!filter_var($dados['email'] ?? '', FILTER_VALIDATE_EMAIL)) {
        $erros[] = 'E-mail inválido';
    }    $idade = filter_var($dados['idade'] ?? 0, FILTER_VALIDATE_INT);
    if ($idade === false || $idade < 18 || $idade > 120) {
        $erros[] = 'Idade inválida';
    }    return $erros;
}$erros = validarUsuario($_POST);
if (!empty($erros)) {
    foreach ($erros as $erro) {
        echo "Erro: $erro" . PHP_EOL;
    }
}
?>

---

8. Casos de uso reais

8.1 Agrupando dados por categoria

Um padrão extrema­mente comum em apli­cações PHP: rece­ber uma lista plana de dados e agrupá-los por algum critério, como cat­e­go­ria, sta­tus ou depar­ta­men­to.

<?php
$produtos = [
    ['nome' => 'iPhone 15',    'categoria' => 'Celular',  'preco' => 5999],
    ['nome' => 'Galaxy S24',   'categoria' => 'Celular',  'preco' => 4799],
    ['nome' => 'MacBook Air',  'categoria' => 'Notebook', 'preco' => 9999],
    ['nome' => 'Dell XPS 13',  'categoria' => 'Notebook', 'preco' => 7499],
    ['nome' => 'iPad Pro',     'categoria' => 'Tablet',   'preco' => 4299],
];// Agrupar por categoria
$porCategoria = [];
foreach ($produtos as $produto) {
    $porCategoria[$produto['categoria']][] = $produto;
}// Calcular preço médio por categoria
foreach ($porCategoria as $cat => $items) {
    $media = array_sum(array_column($items, 'preco')) / count($items);
    printf('%s: R$ %.2f média%s', $cat, $media, PHP_EOL);
}
?>

8.2 Construindo um sistema simples de cache em memória

Arrays podem fun­cionar como cache em memória den­tro de uma req­ui­sição, evi­tan­do chamadas repeti­das ao ban­co de dados ou a APIs exter­nas:

<?php
class CacheDeUsuario {
    private array $cache = [];    public function buscar(int $id): array {
        if (!isset($this->cache[$id])) {
            // Simula busca no banco
            $this->cache[$id] = $this->buscarNoBanco($id);
        }
        return $this->cache[$id];
    }    public function invalidar(int $id): void {
        unset($this->cache[$id]);
    }    public function limparTudo(): void {
        $this->cache = [];
    }    private function buscarNoBanco(int $id): array {
        // Aqui viria a query real
        return ['id' => $id, 'nome' => 'Usuário ' . $id];
    }
}
?>

8.3 Processando JSON de uma API

Prati­ca­mente toda inte­gração mod­er­na com APIs retor­na JSON. O PHP con­verte JSON em arrays asso­cia­tivos com json_decode:

<?php
// Simula resposta de uma API
$json = '{
    "status": "ok",
    "total": 3,
    "dados": [
        {"id": 1, "nome": "Produto A", "estoque": 45},
        {"id": 2, "nome": "Produto B", "estoque": 0},
        {"id": 3, "nome": "Produto C", "estoque": 12}
    ]
}';$resposta = json_decode($json, true); // true = array associativoif ($resposta['status'] !== 'ok') {
    throw new RuntimeException('API retornou erro');
}// Filtrar produtos sem estoque
$semEstoque = array_filter(
    $resposta['dados'],
    fn($p) => $p['estoque'] === 0
);echo 'Produtos sem estoque: ' . count($semEstoque);
?>

---

9. Erros comuns e como evitá-los

9.1 O perigo do foreach por referência sem unset

Um dos bugs mais traiçoeiros do PHP. Quan­do você usa & no foreach, a var­iáv­el do loop con­tin­ua sendo uma refer­ên­cia após o loop ter­mi­nar. Se você usar esse nome de var­iáv­el depois, vai cor­romper o últi­mo ele­men­to do array:

<?php
$nums = [1, 2, 3, 4, 5];foreach ($nums as &$num) {
    $num *= 2;
}
// ERRO: esqueceu o unset(&$num)!foreach ($nums as $num) { // $num ainda é referência ao último elemento!
    echo $num . ' ';
}
// Resultado inesperado: 2 4 6 8 8 (o último elemento fica dobrado)// CORRETO:
foreach ($nums as &$num) { $num *= 2; }
unset($num); // sempre faça isso após foreach por referência
?>

9.2 Confundir == com ===

O PHP tem com­para­ção fra­ca (==) e estri­ta (===) para arrays. A com­para­ção fra­ca pode ger­ar sur­pre­sas:

<?php
$a = [1, 2, 3];
$b = ['1', '2', '3'];var_dump($a == $b);  // true  (PHP converte tipos)
var_dump($a === $b); // false (tipos diferentes)// Ordem importa no ===
$x = ['a' => 1, 'b' => 2];
$y = ['b' => 2, 'a' => 1];var_dump($x == $y);  // true  (mesmos pares chave-valor)
var_dump($x === $y); // false (ordem diferente)
?>

9.3 Modificar array durante o foreach

Mod­i­ficar um array enquan­to o per­corre com foreach pode ger­ar com­por­ta­men­tos ines­per­a­dos. O PHP tra­bal­ha com uma cópia inter­na do array durante o loop:

<?php
// EVITE: modificar o array original dentro do foreach
$items = [1, 2, 3, 4, 5];
foreach ($items as $key => $val) {
    if ($val % 2 === 0) {
        unset($items[$key]); // pode causar comportamento imprevisível
    }
}// PREFERÍVEL: filtrar antes
$impares = array_filter($items, fn($v) => $v % 2 !== 0);
?>

---

10. Arrays vs. outras estruturas de dados

O PHP ofer­ece a SPL (Stan­dard PHP Library) com estru­turas de dados espe­cial­izadas que podem ser mais efi­cientes que arrays em cenários especí­fi­cos:

Estru­tu­ra	Mel­hor para	Pior para	Memória
Array PHP	Uso ger­al, flex­i­bil­i­dade	Dados mas­sivos tipa­dos	Alta
SplDoublyLinkedList	Inserções no meio	Aces­so aleatório	Média
SplStack	Pil­ha LIFO	Aces­so por índice	Baixa
SplQueue	Fila FIFO	Aces­so aleatório	Baixa
SplFixedArray	Dados numéri­cos fixos	Taman­ho dinâmi­co	Muito baixa

Na práti­ca, arrays PHP cobrem 95% dos casos de uso do dia a dia. As estru­turas SPL fazem sen­ti­do em sis­temas com req­ui­si­tos de per­for­mance muito especí­fi­cos ou quan­do o domínio do prob­le­ma mapeia nat­u­ral­mente para uma pil­ha ou fila.

---

Conclusão

Arrays são muito mais do que lis­tas de val­ores. São a espin­ha dor­sal de quase toda apli­cação PHP: estão no proces­sa­men­to de for­mulários, na manip­u­lação de resul­ta­dos de ban­co de dados, na inte­gração com APIs, na con­strução de sis­temas de cache e em dezenas de out­ros con­tex­tos.

O que difer­en­cia um desen­volve­dor PHP ini­ciante de um expe­ri­ente não é ape­nas con­hecer a sin­taxe, mas saber quan­do usar cada função, como escr­ev­er pipelines de trans­for­mação legíveis, como evi­tar os bugs clás­si­cos e como tomar decisões con­scientes sobre per­for­mance.

Neste guia, você viu des­de a arquite­tu­ra inter­na (HashTable com copy-on-write) até téc­ni­cas mod­er­nas como deses­tru­tu­ração, spread oper­a­tor e pro­gra­mação fun­cional. A men­sagem cen­tral é esta: domine arrays e você dom­i­nará boa parte do PHP.

O próx­i­mo pas­so nat­ur­al é apren­der como arrays se encaix­am na Ori­en­tação a Obje­tos, espe­cial­mente ao tra­bal­har com coleções de obje­tos, o padrão Repos­i­to­ry e a inter­face Countable do PHP. Mas isso é assun­to para o próx­i­mo arti­go.