Funções de Array do PHP

Os arrays são uma das estruturas de dados mais poderosas e utilizadas em PHP, permitindo armazenar e manipular coleções de dados de maneira eficiente. O PHP oferece uma ampla gama de funções build-in para trabalhar com arrays, tornando as tarefas do dia a dia mais fáceis e produtivas. Neste artigo, vamos explorar algumas das funções mais relevantes de arrays em PHP.

array_push

A função array_push em PHP adiciona um ou mais elementos ao final de um array. O primeiro argumento é o array de destino, ao qual os elementos subsequentes serão anexados.

$pessoas = ["Rodrigo", "Anderson", "Julia"];
array_push($pessoas, "Carla", "Mariana");
print_r($pessoas);
// Saída: 
// Array
// (
//     [0] => Rodrigo
//     [1] => Anderson
//     [2] => Julia
//     [3] => Carla
//     [4] => Mariana
// )

A função array_push em PHP oferece funcionalidade semelhante à atribuição direta usando $array[] = "valor", ambas adicionando elementos ao final de um array.

array_unshift

A função array_unshift insere um ou mais elementos no início de um array. O primeiro argumento é o array de destino, seguido pelos elementos a serem inseridos.

$pessoas = ["Fabio", "Aline", "Vanessa"];
array_unshift($pessoas, "Bibiana", "Diego");
print_r($pessoas);
// Saída: 
// Array
// (
//     [0] => Bibiana
//     [1] => Diego
//     [2] => Fabio
//     [3] => Aline
//     [4] => Vanessa
// )

array_pop

A função array_pop remove e retorna o último elemento de um array, recebendo este array como argumento.

$pessoas = ["João", "Cláudia", "Amanda"];
$ultimaPessoa = array_pop($pessoas);
echo $ultimaPessoa; // Saída: Amanda
print_r($pessoas);
// Saída: 
// Array
// (
//     [0] => João
//     [1] => Cláudia
// )

array_shift

A função array_shift remove e retorna o primeiro elemento de um array, recebendo este array como argumento.

$pessoas = ["Marcos", "Mariana", "Lucia"];
$primeiraPessoa = array_shift($pessoas);
echo $primeiraPessoa; // Saída: Marcos
print_r($pessoas);
// Saída: 
// Array
// (
//     [0] => Mariana
//     [1] => Lucia
// )

array_merge

A função array_merge combina dois ou mais arrays em um único array, recebendo os arrays a serem combinados como argumentos e retornando um novo array resultante.

$arr1 = [10, 15, 20];
$arr2 = [30, 40];
$arr3 = [41, 42, 43];

$newArr = array_merge($arr1, $arr2, $arr3);

print_r($newArr);
// Saída:
// Array
// (
//     [0] => 10
//     [1] => 15
//     [2] => 20
//     [3] => 30
//     [4] => 40
//     [5] => 41
//     [6] => 42
//     [7] => 43
// )

array_replace

A função array_replace substitui os valores do primeiro array pelos valores dos arrays fornecidos posteriormente.

Ela recebe dois ou mais arrays como parâmetros. O primeiro é o array base, cujos valores serão substituídos. Os arrays subsequentes fornecem os valores de substituição, correspondentes às chaves existentes no array base. Se uma chave do array de substituição não estiver presente no array base, o valor será adicionado com a chave correspondente.

$arr = ['nome' => "Produto 1", 'preco' => 20, 'qt' => 2];
$arrReplace = ['preco' => 30, 'qt' => 3];

$newArr = array_replace($arr, $arrReplace);
print_r($newArr);
// Saída:
// Array
// (
//     [nome] => Produto 1
//     [preco] => 30
//     [qt] => 3
// )

implode

A função implode une os elementos de um array usando um separador definido. Ela recebe, como primeiro parâmetro, a string do separador, e como segundo, o array a ser concatenado. A função retorna uma string resultante da junção dos elementos.

$caracteristicas = [
    'Notebook',
    'Intel Core i7',
    '16GB RAM',
    'SSD 512GB',
    'Windows 11',
    'Tela 15.6"'
 ];
 
 $metaKeywords = implode(', ', $caracteristicas);
  echo "<meta name='keywords' content='{$metaKeywords}'>\n";
 // Saída:
 // <meta name='keywords' content='Notebook, Intel Core i7, 16GB RAM, SSD 512GB, Windows 11, Tela 15.6"'>

count

A função count retorna a quantidade de elementos que um array possui.

$nomes = ["Rodrigo","Mauricio", "Gabriela", "Angela"];

echo count($nomes);
// Saída: 4

sort

A função sort ordena os elemento de um array em ordem ascendente.

$nomes = ["Rodrigo","Mauricio", "Gabriela", "Angela"];

sort($nomes);
print_r($nomes);
// Saída:
// Array
// (
//     [0] => Angela
//     [1] => Gabriela
//     [2] => Mauricio
//     [3] => Rodrigo
// )

rsort

A função rsort ordena os elementos de um array em ordem descrescente

$nomes = ["Rodrigo","Mauricio", "Gabriela", "Angela"];

rsort($nomes);
print_r($nomes);
// Saída:
// Array
// (
//     [0] => Rodrigo
//     [1] => Mauricio
//     [2] => Gabriela
//     [3] => Angela
// )

ksort

A função ksort ordena um array pelas chaves em ordem crescente. Para ordenar em ordem descrescente utilize a função krsort.

$pedidos = [
    '2024-01-08' => ['cliente' => 'João', 'valor' => 150.00],
    '2023-12-25' => ['cliente' => 'Maria', 'valor' => 299.90],
    '2024-01-01' => ['cliente' => 'Pedro', 'valor' => 89.90],
    '2023-12-31' => ['cliente' => 'Ana', 'valor' => 199.90]
 ];
 
 // Ordenando por data (chave)
 ksort($pedidos);
print_r($pedidos);
// Saída:
// Array
// (
//     [2023-12-25] => Array
//         (
//             [cliente] => Maria
//             [valor] => 299.9
//         )

//     [2023-12-31] => Array
//         (
//             [cliente] => Ana
//             [valor] => 199.9
//         )

//     [2024-01-01] => Array
//         (
//             [cliente] => Pedro
//             [valor] => 89.9
//         )

//     [2024-01-08] => Array
//         (
//             [cliente] => João
//             [valor] => 150
//         )

// )

array_slice

A função array_slice é usada para extrair uma porção específica de um array, dada por um intervalo. Os elementos presentes no intervalo serão retornados como um novo array.

Ela aceita como parâmetros:

  • 1º: O array de origem, o qual será extraída uma porção.
  • 2º: O offset, que indica a posição inicial da fatia.
  • 3º: Um parâmetro opcional que define o tamanho da fatia (a partir do índice de offset). Caso este parâmetro seja omitido, a fatia incluirá todos os elementos até o final do array.
  • Um parâmetro booleano opcional que determina se as chaves do array original devem ser preservadas ou se novas chaves devem ser criadas para o array resultante.
$arr = [10, 20, 30, 40, 50];

$newArr = array_slice($arr, 2, 2);
print_r($newArr);
// Saída:
// Array
// (
//     [0] => 30
//     [1] => 40
// )

print_r($arr);
// Array
// (
//     [0] => 10
//     [1] => 20
//     [2] => 30
//     [3] => 40
//     [4] => 50
// )

array_splice

A função array_splice permite modificar um array por meio da remoção e/ou substituição de uma porção específica. Você define um intervalo no array e, opcionalmente, fornece um array de substituição. Se um array de substituição for especificado, os elementos do intervalo selecionado serão substituídos pelos elementos do novo array, independentemente do tamanho relativo dos dois. Caso contrário, o intervalo selecionado é apenas removido do array original.

Ela aceita como parâmetros:

  • 1º: O array de origem, o qual será remove e/ou substitui uma porção.
  • 2º: O offset, que indica a posição inicial da remoção/substituição.
  • 3º: O lenght, um parâmetro opcional que define o tamanho do intervalo(a partir do índice de offset). Caso este parâmetro seja omitido, o intervalo incluirá todos os elementos até o final do array.
  • 4º: Um array com os elemento para serem substituídos no intervalo de offset e length. Este parâmetro é opcional
//removendo elementos
$pessoas = ["João", "Cláudia", "Matheus", "Amanda"];
array_splice($pessoas, 1, 2);
print_r($pessoas);
// Saída: 
// Array
// (
//     [0] => João
//     [1] => Amanda
// )

No exemplo acima, temos o array $pessoas. Usamos a função array_splice para selecionar o intervalo a partir do elemento de índice 1(offset), que é “Cláudia”, e o intervalo terá dois elementos contando com elemento do offset, então ficamos com “Cláudia” e “Matheus”. Como não especificamos um array de substituição no quarto parâmetro, os elementos selecionados são apenas removidos.

// substituindo elementos
$pessoas = ["João", "Cláudia", "Matheus", "Amanda", "Antonio", "Fernanda"];
array_splice($pessoas, 2, 3, "Rodrigo");
print_r($pessoas);
// Saída: 
// Array
// (
//     [0] => João
//     [1] => Cláudia
//     [2] => Rodrigo
//     [3] => Fernanda
// )

No exemplo acima, vamos substituir elementos em um array $pessoas que agora contém 6 elementos. Selecionamos o intervalo a partir do índice 2, ou seja, do elemento “Matheus”, e o intervalo terá três elementos, ficando então com “Matheus”, “Amanda” e “Antonio”. Passamos um array de substituição como quarto parâmetro, contendo um único elemento, que substituirá os três selecionados, resultando em um array atualizado agora com somente 4 elementos.

array_keys

A função array_keys retorna todas as chaves de um array. O primeiro parâmetro é o array de onde as chaves serão extraídas. Opcionalmente, podemos passar um segundo parâmetro de pesquisa, que fará com que sejam retornadas apenas as chaves cujos valores correspondem ao critério de pesquisa.

$valores = ["a" => 10, "b"=> 20, "c" => 30];
$keys = array_keys($valores);
print_r($keys);
//Saída: 
// Array
// (
//     [0] => a
//     [1] => b
//     [2] => c
// )


$valores = ["a" => "Rodrigo", "b"=> "Carlos", "c" => "Rodrigo"];
$keys = array_keys($valores, "Rodrigo");
print_r($keys);
// Saída: 
// Array
// (
//     [0] => a
//     [1] => c
// )
//
// Retorna somente as chaves a e c porque são as unicas que possuem como valor Rodrigo

array_values

A função array_values retorna todos os valores de um array em um novo array. Ela é útil quando uma operação ou função modifica o array, mas não altera suas chaves, pois ela retorna um array com chaves numéricas, começando do índice 0.

$array = ["a" => 1, "b" => 2, "c" => 3];
$valores = array_values($array);
print_r($valores);
// Saída: 
// Array
// (
//     [0] => 1
//     [1] => 2
//     [2] => 3
// )

$pessoas = ["Rodrigo","Ana", "João", "Juliano", "Caio"];
unset($pessoas[1]);
unset($pessoas[3]);
print_r($pessoas);
// Saída:
// Array
// (
//     [0] => Rodrigo
//     [2] => João
//     [4] => Caio
// )

//agora "resetando" os indices com array_values
$pessoas = array_values($pessoas);
print_r($pessoas);
// Saída:
// Array
// (
//     [0] => Rodrigo
//     [1] => João
//     [2] => Caio
// )

array_unique

A função array_unique remove os valores duplicados de um array e retorna o array resultante, sem repetições.

$array = ["Rodrigo", "Ana", "Rodrigo", "Carlos", "Rodrigo"];
$unico = array_unique($array);
print_r($unico);
// Saída: 
// Array
// (
//     [0] => Rodrigo
//     [1] => Ana
//     [3] => Carlos
// )

in_array

A função in_array verifica se um valor existe em um array, retornando um valor booleano. O primeiro parâmetro é o valor a ser buscado, e o segundo parâmetro é o array onde a busca será realizada.

Esta função é muito útil quando precisamos verificar se um valor é igual a qualquer item em uma lista de valores, evitando o uso de uma sequência de operadores “||” (OU).

$mime = "image/png";
$tiposImagem = ["image/jpeg","image/png","image/webp"];
if( in_array($mime, $tiposImagem)){
    echo "é imagem";
}else{
    echo "não é imagem";
}

array_reverse

A função array_reverse inverte a ordem dos elementos em um array retornando um novo array.

$array = ["a", "b", "c"];
$reverso = array_reverse($array);
print_r($reverso);
// Saída:
// Array
// (
//     [0] => c
//     [1] => b
//     [2] => a
// )

array_filter

A função array_filter filtra os elementos de um array com base em uma função de callback. Ela percorre cada elemento do array, passando-o para a função de callback. Se a função retornar true, o elemento é incluído no array resultante. As chaves são preservadas no array resultante.

$files = ['a1.txt', 'a2.png', 'a3.docx', 'a4.png','a5.jpg', 'a6.png'];

$pngs = array_filter($files, function($item) {
    return str_ends_with($item, ".png");
});

print_r($pngs);
// Saída: 
// Array
// (
//     [1] => a2.png
//     [3] => a4.png
//     [5] => a6.png
// )

array_map

A função array_map aplica uma função de callback a cada elemento de um array e retorna um novo array. Ela percorre todos os elementos do array, passando cada um para a função de callback e adicionando o valor retornado no array resultante.

$precos = [29.90, 99.00, 199.90, 1499.99];

$precosFormatados = array_map(function($preco){
    return "R$ " . number_format($preco, 2, ',', '.');
}, $precos);

print_r($precosFormatados);
// Saída:
Array
// (
//     [0] => R$ 29,90
//     [1] => R$ 99,00
//     [2] => R$ 199,90
//     [3] => R$ 1.499,99
// )

array_reduce

A função array_reduce reduz um array a um único valor utilizando uma função de callback. Ela percorre cada elemento do array, chamando a função de callback para cada um deles. A cada chamada, são passados dois parâmetros: $carry, e o elemento corrente da iteração. O parâmetro $carry é o acumulador, quando a função de callback for chamada para o primeiro elemento do array, o valor de $carry será o valor inicial passado como terceiro parâmetro da função array_reduce. Nas chamadas subsequentes o valor $carry será o valor retornado pela função de callback na iteração anterior. Quando todos os elementos forem percorridos o valor de $carry será retornado pela função array_reduce.

  • 1º parâmetro: o array a ser reduzido
  • 2º parâmetro: a função de callback
  • 3º parâmetro: o valor inicial do acumulador $carry.
$valores = [10, 20, 30, 40, 50];

$total = array_reduce($valores, function($carry, $item){
    return $carry + $item;
}, 0);

echo $total;
//Saída: 150

array_walk

A função array_walk aplica uma função de callback a cada elemento de um array. A função percorre todos os elemento do array chamando a função de callback e passando o elemento da iteração para ela. Na função de callback podemos declarar o primeiro parâmetro como sendo recebido por referência, o que nos permite alterar valores do elemento dentro da função de callback caso ele seja um array ou um objeto.

$pedidos = [
    123 => ['status' => 'pendente', 'cliente' => 'João'],
    124 => ['status' => 'pendente', 'cliente' => 'Maria'],
    125 => ['status' => 'pendente', 'cliente' => 'Pedro']
 ];
 
 $atualizarStatus = function(&$pedido, $id) {
    $pedido['status'] = 'aprovado';
    echo "Pedido #{$id} do cliente {$pedido['cliente']} atualizado para: {$pedido['status']}\n";
 };
 
array_walk($pedidos, $atualizarStatus);
//Saída: 
// Pedido #123 do cliente João atualizado para: aprovado
// Pedido #124 do cliente Maria atualizado para: aprovado
// Pedido #125 do cliente Pedro atualizado para: aprovado

print_r($pedidos);
// Saída:
// Array
// (
//     [123] => Array
//         (
//             [status] => aprovado
//             [cliente] => João
//         )

//     [124] => Array
//         (
//             [status] => aprovado
//             [cliente] => Maria
//         )

//     [125] => Array
//         (
//             [status] => aprovado
//             [cliente] => Pedro
//         )

// )

range

A função range cria um array com uma sequência de elementos. Ela recebe três parâmetros: o início da faixa, o final e o passo. O passo define o valor de incremento do início até o valor final.

$numeros = range(1,5);
print_r($numeros);
// Saída:
// Array
// (
//     [0] => 1
//     [1] => 2
//     [2] => 3
//     [3] => 4
//     [4] => 5
// )

$numeros = range(1.5, 3.0, 0.5);
print_r($numeros);
// Saída:
// Array
// (
//     [0] => 1.5
//     [1] => 2
//     [2] => 2.5
//     [3] => 3
// )

array_column

A função array_column retorna os valores de uma coluna específica de um array multidimensional.

$array = [
    ["id" => 1, "nome" => "João"],
    ["id" => 2, "nome" => "Maria"],
];
$nomes = array_column($array, "nome");
print_r($nomes);
// Saída: 
// Array
// (
//     [0] => João
//     [1] => Maria
// )

array_search

A função array_search procura um valor em um array e retorna sua chave correspondente.

$funcionarios = [
    ['id' => 101, 'nome' => 'João', 'cargo' => 'Dev Senior'],
    ['id' => 102, 'nome' => 'Maria', 'cargo' => 'Dev Pleno'],
    ['id' => 201, 'nome' => 'Pedro', 'cargo' => 'SysAdmin'],
    ['id' => 202, 'nome' => 'Ana', 'cargo' => 'DevOps']
];
// primeiro transforma a coluna do array multidimensional em um array depois realiza 
// uma busca dentro deste array para obter a linha onde um elemento tinha o id
// buscado
$index = array_search(201, array_column($funcionarios, 'id'));

print_r( $funcionarios[$index]);
// Saída: 
// Array
// (
//     [id] => 201
//     [nome] => Pedro
//     [cargo] => SysAdmin
// )

array_diff

A função array_diff calcula a diferença entre arrays. Ela retorna um array contendo todos os elementos presentes no primeiro array, mas ausentes nos arrays passados como parâmetros subsequentes.

$turmaCompleta = ['Ana', 'Bruno', 'Carlos', 'Diana', 'Eduardo', 'Fernanda'];
$alunosPresentes = ['Ana', 'Carlos', 'Eduardo', 'Fernanda'];

$alunosFaltantes = array_diff($turmaCompleta, $alunosPresentes);

print_r($alunosFaltantes);
// Saída:
// Array
// (
//     [1] => Bruno
//     [3] => Diana
// )

array_fill

A função array_fill cria um array preenchido com um valor especificado. Ela recebe três parâmetros: o primeiro é o índice inicial do array, o segundo é o índice final, e o terceiro é o valor a ser atribuído a todos os elementos do array. A função retorna um novo array, com elementos do índice inicial até o final, preenchidos com o valor fornecido.

$assentosVazios = array_fill(1, 10, 'LIVRE');

print_r($assentosVazios);
// Saída:
Array
// (
//     [1] => LIVRE
//     [2] => LIVRE
//     [3] => LIVRE
//     [4] => LIVRE
//     [5] => LIVRE
//     [6] => LIVRE
//     [7] => LIVRE
//     [8] => LIVRE
//     [9] => LIVRE
//     [10] => LIVRE
// )

array_rand

A função array_rand seleciona uma ou mais chaves aleatórias de um array. Ela recebe o array do qual as chaves serão sorteadas e, opcionalmente, um inteiro que define o número de chaves a serem sorteadas. Se o número de chaves não for especificado, apenas uma chave será sorteada.

$participantes = [
    1 => 'João',
    2 => 'Maria',
    3 => 'Pedro',
    4 => 'Ana',
    5 => 'Carlos',
    6 => 'Julia',
    7 => 'Lucas',
    8 => 'Mariana'
 ];
 
 // Sorteando 3 ganhadores
 $ganhadores = array_rand($participantes, 3);
 print_r($ganhadores);
 // Saída:
//  Array
// (
//     [0] => 1
//     [1] => 5
//     [2] => 7
// )

echo "Os ganhadores da promoção são:\n\n";
foreach ($ganhadores as $indice) {
   echo "- {$participantes[$indice]}\n";
}
// Saída:
// Os ganhadores da promoção são:

// - Maria
// - Carlos
// - Mariana

array_chunk

A função array_chunk divide um array em partes menores. Ela recebe, como primeiro parâmetro, o array a ser dividido e, como segundo, o número de elementos em cada parte. A função retorna um novo array, onde cada elemento é uma parte do array original. O último elemento pode conter menos itens do que o especificado, caso o número total de elementos não seja divisível igualmente.


$produtos = [
    'Mouse Gamer',
    'Teclado Mecânico',
    'Headset',
    'Monitor 24"',
    'Webcam HD',
    'MousePad',
    'Cadeira Gamer',
    'Microfone USB'
 ];
 
 // Dividindo em grupos de 3 itens por página
 $produtosPorPagina = array_chunk($produtos, 3);
 print_r($produtos);
// Saída:
// Array
// (
//     [0] => Mouse Gamer
//     [1] => Teclado Mecânico
//     [2] => Headset
//     [3] => Monitor 24"
//     [4] => Webcam HD
//     [5] => MousePad
//     [6] => Cadeira Gamer
//     [7] => Microfone USB
// )

 
 // Exibindo produtos por página
 foreach ($produtosPorPagina as $pagina => $itens) {
    echo "Página " . ($pagina + 1) . ":\n";
    foreach ($itens as $produto) {
        echo "- {$produto}\n";
    }
    echo "\n";
 }

// Saída:
//  Página 1:
// - Mouse Gamer
// - Teclado Mecânico
// - Headset

// Página 2:
// - Monitor 24"
// - Webcam HD
// - MousePad

// Página 3:
// - Cadeira Gamer
// - Microfone USB

array_flip

A função array_flip troca todas as chaves e seus valores associados em um array.


$codigosRastreio = [
    'PROD001' => 'BR98765432',
    'PROD002' => 'BR12345678',
    'PROD003' => 'BR45678912'
 ];
 
 $flip = array_flip($codigosRastreio);
 print_r($flip);
 // Saída:
//  Array
// (
//     [BR98765432] => PROD001
//     [BR12345678] => PROD002
//     [BR45678912] => PROD003
// )

array_combine

A função array_combine cria um array utilizando os valores do array keys como chaves e os valores do array values como valores correspondentes.

$cods = ["B2","C3","D4","E9"];
$nomes = ["Fernanda", "Luciana", "Mauricio", "Ana"];

$newArr = array_combine($cods, $nomes);
print_r($newArr);
// Saída:
// Array
// (
//     [B2] => Fernanda
//     [C3] => Luciana
//     [D4] => Mauricio
//     [E9] => Ana
// )

O PHP oferece muitas funções para manipulação de arrays, e estas são as que considero mais relevantes. No entanto, não deixe de conferir a documentação oficial do PHP para descobrir outras opções. T++