Arrays em Profundidade

Arrays são a estrutura de dados mais usada no PHP. Praticamente tudo que você fará com o PHP — ler dados de um banco, processar um formulário, construir uma resposta de API — vai envolver arrays de alguma forma. Entender arrays com profundidade não é opcional: é o que separa quem apenas usa PHP de quem realmente o domina.

Neste artigo vamos cobrir criação, acesso, modificação, arrays associativos, multidimensionais e o conjunto de funções nativas que tornam os arrays do PHP tão poderosos.

Criando arrays

O PHP suporta duas sintaxes para criar arrays. A sintaxe com colchetes [] é a moderna e preferida:

<?php
declare(strict_types=1);

// Sintaxe moderna — preferida desde PHP 5.4
$frutas = ["maçã", "banana", "laranja"];

// Sintaxe antiga — ainda funciona, mas evite em código novo
$frutas = array("maçã", "banana", "laranja");

// Array vazio — comum para inicializar antes de preencher
$resultado = [];

// Array com índices explícitos
// Os índices não precisam ser sequenciais
$sparse = [0 => "zero", 5 => "cinco", 10 => "dez"];

// PHP atribui o próximo índice inteiro após o maior existente
$sparse[] = "onze"; // receberá índice 11

// Verificando se é array e seu tamanho
var_dump(is_array($frutas)); // bool(true)
echo count($frutas);         // 3
echo count([]);              // 0

Arrays associativos

Arrays associativos usam strings como chaves em vez de índices numéricos. São equivalentes a dicionários ou mapas em outras linguagens:

<?php
declare(strict_types=1);

// Criando com chaves string
$usuario = [
    "nome"    => "Ana Silva",
    "email"   => "ana@email.com",
    "idade"   => 28,
    "ativo"   => true,
];

// Acessando por chave
echo $usuario["nome"];   // Ana Silva
echo $usuario["idade"];  // 28

// Modificando um valor existente
$usuario["idade"] = 29;

// Adicionando uma nova chave
$usuario["perfil"] = "administrador";

// Removendo uma chave
unset($usuario["ativo"]);

// Verificando se uma chave existe
var_dump(isset($usuario["email"]));          // bool(true)
var_dump(isset($usuario["ativo"]));          // bool(false) — removido
var_dump(array_key_exists("email", $usuario)); // bool(true) — mais preciso que isset

// Listando chaves e valores separadamente
$chaves  = array_keys($usuario);   // ["nome", "email", "idade", "perfil"]
$valores = array_values($usuario); // ["Ana Silva", "ana@email.com", 29, "administrador"]

A diferença entre isset() e array_key_exists() é sutil mas importante: isset() retorna false se a chave existir mas seu valor for null. array_key_exists() retorna true independentemente do valor — verifique apenas se a chave existe.

Arrays multidimensionais

Arrays podem conter outros arrays como valores, criando estruturas multidimensionais. Esse é o padrão usado para representar dados relacionais — exatamente o que vem de um banco de dados:

<?php
declare(strict_types=1);

// Array de arrays associativos — estrutura típica de resultado de banco
$usuarios = [
    [
        "id"    => 1,
        "nome"  => "Ana",
        "email" => "ana@email.com",
        "cargo" => ["titulo" => "Desenvolvedora", "nivel" => "Senior"],
    ],
    [
        "id"    => 2,
        "nome"  => "Bruno",
        "email" => "bruno@email.com",
        "cargo" => ["titulo" => "Designer", "nivel" => "Pleno"],
    ],
];

// Acessando dados aninhados com múltiplos colchetes
echo $usuarios[0]["nome"];              // Ana
echo $usuarios[0]["cargo"]["titulo"];   // Desenvolvedora
echo $usuarios[1]["cargo"]["nivel"];    // Pleno

// Iterando estrutura multidimensional
foreach ($usuarios as $usuario) {
    // $usuario é um array associativo
    echo "{$usuario['nome']} — {$usuario['cargo']['titulo']}\n";
}
// Ana — Desenvolvedora
// Bruno — Designer

// array_column — extrai uma coluna de um array multidimensional
// Equivale a: SELECT nome FROM usuarios
$nomes = array_column($usuarios, "nome");
print_r($nomes); // ["Ana", "Bruno"]

// Também pode usar uma coluna como índice do resultado
$porId = array_column($usuarios, null, "id");
// Agora $porId[1] é o array do usuário com id=1
echo $porId[1]["nome"]; // Ana

Adicionando e removendo elementos

<?php
declare(strict_types=1);

$pilha = ["a", "b", "c"];

// Adicionando ao final
$pilha[] = "d";          // forma mais comum
array_push($pilha, "e"); // equivalente, mas [] é preferido

// Removendo do final — retorna o elemento removido
$ultimo = array_pop($pilha); // "e"

// Adicionando ao início
array_unshift($pilha, "z"); // $pilha = ["z", "a", "b", "c", "d"]

// Removendo do início — retorna o elemento removido
$primeiro = array_shift($pilha); // "z"

// Removendo por índice específico
// unset remove o elemento mas não reindexia
unset($pilha[1]); // remove "b", índices ficam: 0=>"a", 2=>"c", 3=>"d"

// array_splice — remove e opcionalmente insere, reindexia automaticamente
// array_splice($array, $inicio, $quantidade, $substituicao)
$cores = ["vermelho", "verde", "azul", "amarelo"];
$removidas = array_splice($cores, 1, 2); // remove 2 a partir do índice 1
// $cores = ["vermelho", "amarelo"]
// $removidas = ["verde", "azul"]

// Inserindo no meio com array_splice
array_splice($cores, 1, 0, ["roxo", "laranja"]); // insere sem remover
// $cores = ["vermelho", "roxo", "laranja", "amarelo"]

Funções essenciais de array

O PHP tem mais de 70 funções nativas para arrays. Aqui estão as mais importantes:

Busca e verificação

<?php
declare(strict_types=1);

$numeros = [10, 20, 30, 40, 50];
$frutas  = ["maçã", "banana", "laranja"];

// in_array — verifica se um valor existe
var_dump(in_array(30, $numeros));         // bool(true)
var_dump(in_array("banana", $frutas));    // bool(true)
var_dump(in_array("uva", $frutas));       // bool(false)

// Terceiro argumento true = comparação estrita (===)
var_dump(in_array("30", $numeros));        // bool(true) — coerção!
var_dump(in_array("30", $numeros, true));  // bool(false) — estrito

// array_search — retorna a chave do elemento encontrado, ou false
$posicao = array_search(30, $numeros);
var_dump($posicao); // int(2)

$ausente = array_search(99, $numeros);
var_dump($ausente); // bool(false)

// Cuidado: posição 0 e false são ambos falsy!
// Use === false para verificar ausência
if (array_search(10, $numeros) !== false) {
    echo "Encontrado!\n";
}

Ordenação

<?php
declare(strict_types=1);

$numeros = [3, 1, 4, 1, 5, 9, 2, 6];
$nomes   = ["Carlos", "Ana", "Beatriz", "David"];

// sort — ordena por valor, reindexia (destrói chaves originais)
sort($numeros);    // [1, 1, 2, 3, 4, 5, 6, 9]
sort($nomes);      // ["Ana", "Beatriz", "Carlos", "David"]

// rsort — ordem decrescente
rsort($numeros);   // [9, 6, 5, 4, 3, 2, 1, 1]

// asort — ordena por valor, PRESERVA as chaves
$notas = ["Ana" => 9.5, "Bruno" => 7.0, "Carla" => 8.5];
asort($notas);
// ["Bruno" => 7.0, "Carla" => 8.5, "Ana" => 9.5]

// arsort — ordem decrescente, preserva chaves
arsort($notas);
// ["Ana" => 9.5, "Carla" => 8.5, "Bruno" => 7.0]

// ksort — ordena por chave
$config = ["z_timeout" => 30, "a_host" => "localhost", "m_port" => 3306];
ksort($config);
// ["a_host" => ..., "m_port" => ..., "z_timeout" => ...]

// usort — ordenação customizada com função de comparação
$usuarios = [
    ["nome" => "Carlos", "idade" => 35],
    ["nome" => "Ana",    "idade" => 28],
    ["nome" => "Bruno",  "idade" => 42],
];

// Ordena por idade usando spaceship operator
usort($usuarios, fn(array $a, array $b): int => $a["idade"] <=> $b["idade"]);
// Ana(28), Carlos(35), Bruno(42)

Transformação

<?php
declare(strict_types=1);

$numeros = [1, 2, 3, 4, 5];
$precos  = [10.0, 25.5, 8.0, 42.0, 15.0];

// array_map — aplica função a cada elemento, retorna novo array
$dobrados = array_map(fn(int $n): int => $n * 2, $numeros);
// [2, 4, 6, 8, 10]

// array_map com múltiplos arrays
$a = [1, 2, 3];
$b = [10, 20, 30];
$soma = array_map(fn(int $x, int $y): int => $x + $y, $a, $b);
// [11, 22, 33]

// array_filter — mantém apenas os elementos que passam no teste
$pares = array_filter($numeros, fn(int $n): bool => $n % 2 === 0);
// [2, 4] — note: chaves originais são preservadas (1 e 3)

// array_values reindexia após filter
$pares = array_values(array_filter($numeros, fn(int $n): bool => $n % 2 === 0));
// [2, 4] com índices 0 e 1

// array_reduce — reduz o array a um único valor
$total = array_reduce($precos, fn(float $carry, float $item): float => $carry + $item, 0.0);
echo $total; // 100.5

// Calculando média com array_reduce
$media = array_reduce($precos, fn(float $carry, float $item): float => $carry + $item, 0.0) / count($precos);
echo $media; // 20.1

// array_unique — remove valores duplicados
$comDuplicatas = [1, 2, 2, 3, 3, 3, 4];
$unicos = array_unique($comDuplicatas);
// [1, 2, 3, 4]

Fatiamento e combinação

<?php
declare(strict_types=1);

$letras = ["a", "b", "c", "d", "e", "f"];

// array_slice — extrai uma porção do array
$parte = array_slice($letras, 1, 3);       // ["b", "c", "d"]
$final = array_slice($letras, -2);          // ["e", "f"] — índice negativo
$reindexa = array_slice($letras, 2, 3, true); // preserva chaves originais

// array_merge — une dois ou mais arrays
$a = ["maçã", "banana"];
$b = ["laranja", "uva"];
$c = array_merge($a, $b); // ["maçã", "banana", "laranja", "uva"]

// Com arrays associativos — chaves repetidas: o segundo sobrescreve
$padroes = ["tema" => "claro", "idioma" => "pt-BR", "itens" => 10];
$config   = ["tema" => "escuro", "debug" => true];
$final    = array_merge($padroes, $config);
// ["tema" => "escuro", "idioma" => "pt-BR", "itens" => 10, "debug" => true]

// Operador + — alternativo ao merge: a chave do primeiro vence
$final2 = $padroes + $config;
// ["tema" => "claro", "idioma" => "pt-BR", "itens" => 10, "debug" => true]

// array_combine — cria associativo a partir de dois arrays (chaves + valores)
$chaves  = ["nome", "email", "cidade"];
$valores = ["Ana", "ana@email.com", "São Paulo"];
$pessoa  = array_combine($chaves, $valores);
// ["nome" => "Ana", "email" => "ana@email.com", "cidade" => "São Paulo"]

// array_chunk — divide em pedaços
$numeros = [1, 2, 3, 4, 5, 6, 7];
$grupos  = array_chunk($numeros, 3);
// [[1,2,3], [4,5,6], [7]]

Funções de contagem e matemática

<?php
declare(strict_types=1);

$valores = [5, 3, 8, 1, 9, 2, 7, 4, 6];
$precos  = [10.5, 25.0, 8.75, 42.0];

echo count($valores);       // 9 — número de elementos
echo array_sum($precos);    // 86.25 — soma de todos os elementos
echo array_product([1,2,3,4]); // 24 — produto de todos os elementos
echo min($valores);          // 1 — menor valor
echo max($valores);          // 9 — maior valor

// Funções que funcionam com arrays
$arredondados = array_map(fn(float $p): float => round($p, 1), $precos);

// compact e extract — atalhos para criar arrays de variáveis
$nome   = "Ana";
$idade  = 28;
$cidade = "São Paulo";

// compact cria array associativo a partir de variáveis
$dados = compact("nome", "idade", "cidade");
// ["nome" => "Ana", "idade" => 28, "cidade" => "São Paulo"]

// extract faz o inverso — cria variáveis a partir de array
// Use com cuidado: pode sobrescrever variáveis existentes
extract($dados); // cria $nome, $idade, $cidade no escopo atual

Padrões práticos com arrays

<?php
declare(strict_types=1);

// Agrupando dados por critério
$transacoes = [
    ["tipo" => "entrada", "valor" => 500.0],
    ["tipo" => "saida",   "valor" => 120.0],
    ["tipo" => "entrada", "valor" => 300.0],
    ["tipo" => "saida",   "valor" => 80.0],
];

$grupos = [];
foreach ($transacoes as $t) {
    // Agrupa pelo campo "tipo"
    $grupos[$t["tipo"]][] = $t["valor"];
}

// $grupos = [
//   "entrada" => [500.0, 300.0],
//   "saida"   => [120.0, 80.0]
// ]

$totalEntradas = array_sum($grupos["entrada"]); // 800.0
$totalSaidas   = array_sum($grupos["saida"]);   // 200.0

// Pipeline funcional — filtrar, transformar, reduzir
$produtos = [
    ["nome" => "Teclado",  "preco" => 250.0, "ativo" => true],
    ["nome" => "Mouse",    "preco" => 80.0,  "ativo" => false],
    ["nome" => "Monitor",  "preco" => 1200.0,"ativo" => true],
    ["nome" => "Headset",  "preco" => 350.0, "ativo" => true],
];

// Soma o preço dos produtos ativos com preço abaixo de R$500
$totalAtivosBaratos = array_reduce(
    array_filter(
        $produtos,
        fn(array $p): bool => $p["ativo"] && $p["preco"] < 500.0
    ),
    fn(float $carry, array $p): float => $carry + $p["preco"],
    0.0
);

echo $totalAtivosBaratos; // 600.0 (Teclado 250 + Headset 350)

Boa parte do trabalho diário em PHP é transformar array: o que vem do banco vira o que a tela precisa, o que chega do formulário vira o que a regra de negócio entende. Quem conhece bem esse punhado de funções escreve menos laço e erra menos. O cuidado que sobra é sempre o mesmo — saber se a chave foi preservada ou descartada —, porque é daí que vêm os defeitos que não dão erro: a lista que virou objeto no JSON, o vendedor que sumiu da ordenação, o índice que deixou de ser sequencial.

Fontes e leituras recomendadas

• Funções de array — Manual oficial do PHP https://www.php.net/manual/pt_BR/ref.array.php Referência completa das mais de 70 funções nativas para arrays do PHP, com exemplos para cada uma.

• array_map — php.net https://www.php.net/manual/pt_BR/function.array-map.php Documentação detalhada do array_map, incluindo o comportamento com múltiplos arrays e com null como callback.

• array_reduce — php.net https://www.php.net/manual/pt_BR/function.array-reduce.php Documentação do array_reduce com exemplos de acumuladores e a importância do valor inicial correto.

• PHP: The Right Way — Arrays https://phptherightway.com/#arrays Seção sobre boas práticas de arrays, quando usar funções funcionais e quando usar loops explícitos.

• SPL Data Structures — Manual oficial do PHP https://www.php.net/manual/pt_BR/spl.datastructures.php Estruturas de dados especializadas da SPL: SplStack, SplQueue, SplHeap. Para quando arrays simples não são suficientes.

• WENGROW, Jay. A Common-Sense Guide to Data Structures and Algorithms. 2ª ed. Pragmatic Bookshelf, 2020. https://pragprog.com/titles/jwdsal2/a-common-sense-guide-to-data-structures-and-algorithms-second-edition/ Introdução acessível a estruturas de dados e algoritmos, com foco em quando usar cada estrutura. Leitura recomendada após dominar os arrays do PHP.

Exercícios

Exercício 1

O front-end espera uma lista JSON e recebe um objeto, quebrando o .map() dele. O PHP não deu erro nenhum. O que aconteceu?

<?php
$notas = [8, 0, 7, 9];
$aprovadas = array_filter($notas, fn($n) => $n >= 7);

echo json_encode($aprovadas);   // {"0":8,"2":7,"3":9}

Exercício 2

Esta verificação de permissão liberava acesso indevido em PHP 7 e parou de liberar em PHP 8. O que mudou — e por que o código continua errado mesmo agora?

<?php
$permissoes = ['ler', 'escrever', 'publicar'];
$nivel = 0;

if (in_array($nivel, $permissoes)) {
    echo "acesso liberado";
}

Exercício 3

Dois arrays precisam ser combinados. Qual a diferença entre as duas linhas, e quando cada uma é a correta?

<?php
$a = ['config' => 'padrão', 10, 20];
$b = ['config' => 'do usuário', 30, 40, 50];

$x = array_merge($a, $b);
$y = $a + $b;

Exercício 4

Uma listagem precisa ser ordenada pelo nome do cliente. Diga o que cada função faz e qual delas serve para um array de arrays vindo do banco: sort, asort, ksort, usort.

Exercício 5

Desafio: você recebe uma lista plana de vendas e precisa do total por vendedor, ordenado do maior para o menor. Escreva a transformação e explique cada escolha.

<?php
$vendas = [
    ['vendedor' => 'ana',   'valor' => 1200],
    ['vendedor' => 'bruno', 'valor' =>  800],
    ['vendedor' => 'ana',   'valor' =>  300],
    ['vendedor' => 'carla', 'valor' => 1500],
];

<?php

$totais = [];
foreach ($vendas as $v) {
    // ??= cria a chave com 0 na primeira vez que o vendedor aparece,
    // e não faz nada nas seguintes — evita o isset() antes de somar
    $totais[$v['vendedor']] ??= 0;
    $totais[$v['vendedor']] += $v['valor'];
}

// arsort: ordena pelo VALOR, decrescente, PRESERVANDO a chave.
// sort() aqui jogaria fora o nome do vendedor, que é justamente o resultado.
arsort($totais);

print_r($totais);
// ['carla' => 1500, 'ana' => 1500, 'bruno' => 800]