PHP - Entendendo o array

Publicado em
10 min de leitura

O assunto de hoje é o sobre array. Se já mexeu com alguma linguagem de programação, já deve ter visto ou trabalhado com um array. Se é leigo no assunto, vamos estar vendo sobre o mesmo no PHP.

Os arrays também podem ser identificados como tipos de dados compostos. Os elementos e os dados de um array, são conhecimos como os pares de chave e valor. Vamos supor que temos um array com 3 elementos, onde cada um contém uma letra do alfabeto. Exemplo:

1
2
// Chave :  0 1 2
// Valor :  a b c

Na prática temos duas formas de criar um array e representar esse exemplo:

1
2
3
4
5
6
7
8
9
10
11
12
// função array
$array = array(0 => 'a', 1 => 'b', 2 => 'c');
// ou
// com colchetes
$array2 = array();
$array2 = ['a', 'b', 'c'];

// variação com colchetes
$array3 = array();
$array3[0] = 'a';
$array3[1] = 'b';
$array3[2] = 'c';

Não se preocupe com os exemplos práticos. Logo abaixo vamos estar vendo os tipos, funções de arrays e as regras para entender melhor como eles funcionam.

Tipos de arrays

Uma coisa muito importante, é não esquecer que a chave numérica de um elemento de um array, sempre começa em 0. E você pode acessar um elemento do array, acessando com a chave entre colchetes. Exemplo:

1
2
3
$array = array(0 => 'a', 1 => 'b', 2 => 'c');
echo $array[2];
// c

Indexado / Associativo

Um array indexado é conhecido como tal, qual suas chaves são do tipo numérico. Um array de chaves nomeadas com strings, é conhecido como array associativo.

1
2
3
4
// Array com chaves númericas(indexadas)
// Chave :  0 1 2
// Valor :  a b c
$array = array(0 => 'a', 1 => 'b', 2 => 'c');
1
2
3
4
// Array com chaves nomeadas(associativas)
// Chave :  name age status
// Valor :  Ana  20  1
$array = array('name' => 'Ana', 'age' => 20, 'status' => 1);

Bidimensional / Multidimensional

Os arrays podem ser de duas ou mais dimensões. Isso quer dizer, que podemos ter um array, dentro de um array. Não se tem um limite de dimensões para os arrays, mas dependendo da quantidade, fica difícil manter o código de fácil entendimento. Exemplo:

1
2
3
4
// Array tridimensional
$array = array(0 => 'a', 1 => array(0 => 'a', 1 => 'b', 2 => array(0 => 'entrou', 1 => 'saiu')), 2 => 'c');
echo $array[1][2][0];
// entrou

Dinâmicos

Já vimos que os arrays podem ser indexados, associativos, bidimensionais e até multidimensionais. No PHP, eles também podem ser dinâmicos. Com isso, podemos adicionar, deletar e alterar os elementos com comandos e funções para esse uso.

1
2
3
$array = array('name' => 'Ana', 'country' => 'Brasil');
// Comando que adicionará ao final do array
$array['age'] = 29;

Acima, temos um array associativo com 3 elementos. O que acontece se adicionarmos um valor, sem informar a chave? Podemos conferir no exemplo abaixo.

1
2
3
4
$array = array('name' => 'Ana', 'country' => 'Brasil', 'age' => 29);
$array[] = 'ihhhh';
var_dump($array);
// 'name' => 'Ana', 'country' => 'Brasil', 'age' => 29, 0 => 'ihhhh'

É, quando não informamos a chave, automaticamente a chave recebe o próximo índice numérico. Como é apenas um array associativo e não tinha nenhuma chave numérica, o próximo índice é o 0. Vamos ver como fica no próximo exemplo.

1
2
3
4
$array = array(0 => 'Ana', 1 => 'Brasil', 'age' => 29);
$array[] = 'ihhhh';
var_dump($array);
// 0 => 'Ana', 1 => 'Brasil', 'age' => 29, 2 => 'ihhhh'

Para alterar o valor, é bem intuitivo. Basta informar a chave e lhe dar o novo valor.

1
2
3
4
$array = array(0 => 'Ana', 1 => 'Brasil', 'age' => 29);
$array['age'] = 31;
var_dump($array);
// 0 => 'Ana', 1 => 'Brasil', 'age' => 31

Agora vamos brincar um pouco ao remover elementos com a função array_splice. Na função, você informa 3 parâmetros, sendo o terceiro opcional.

1
2
3
4
5
6
7
$array = array(0 => 'Ana', 1 => 'Brasil', 'age' => 29);
// Parâmetros
// 1º = array, 2º = remover a partir de qual posição , 3º = quantos elementos remover
// Quando não informamos o 3º, ele remove da posição informada no 2º parâmetro até o último elemento do array
array_splice($array, 1);
var_dump($array);
// 0 => 'Ana'
1
2
3
4
$array = array(0 => 'Ana', 1 => 'Brasil', 'age' => 29);
array_splice($array, 0, 1);
var_dump($array);
// 1 => 'Brasil', 'age' => 29

Também podemos criar um novo array, apenas com o resultado da função array_splice, em uma variavel. Exemplo:

1
2
3
4
5
6
7
$array = array(0 => 'Ana', 1 => 'São Paulo', 2 => 'Rio de Janeiro');
$arrayTemp = $array;
$arrayStates = array_splice($arrayTemp, 1, 2);
var_dump($array);
// 0 => 'Ana', 1 => 'São Paulo', 2 => 'Rio de Janeiro'
var_dump($arrayStates);
// 0 => 'São Paulo', 1 => 'Rio de Janeiro'

Uma outra função para remover elementos de um array, é a função unset. Exemplo:

1
2
3
4
$array = array(0 => 'Ana', 1 => 'São Paulo', 2 => 'Rio de Janeiro');
unset($array[1]);
var_dump($array);
// 0 => 'Ana', 2 => 'Rio de Janeiro'

Foreach

Funciona apenas com arrays. Retorna um erro se for utilizado em uma variável de qualquer tipo diferente ou em variáveis não inicializadas. Pode ser usada de duas formas:

1
2
3
4
5
6
7
foreach (array as $valor) {
	// instrução
}

foreach (array as $chave => $valor) {
	// instrução
}
1
2
3
4
5
$arr = array(1, 2, 3, 4);
foreach ($arr as $value) {
    $value = $value * 2;
}
// $arr = array(2, 4, 6, 8)

Algumas funções de Array

O array é muito usado no PHP. Por esse motivo, tem muitas funções nativas da linguagem, que podemos utilizar.

sort

Essa função ordena um array. Os elementos serão ordenados do menor para o maior ao final da execução dessa função.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// bool sort ( array &$array [, int $sort_flags ] )

<?php
$items = array("item1", "item2", "item3", "item4");
sort($items);
foreach ($items as $key => $val) {
    echo "items[" . $key . "] = " . $val . "\n";
}
?>

// items[0] = item4
// items[1] = item3
// items[2] = item1
// items[3] = item2

rsort

Essa função ordena um array em ordem descrescente (do maior para o menor).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// bool rsort ( array &$array [, int $sort_flags ] )

<?php
$items = array("item1", "item2", "item3", "item4");
rsort($items);
foreach ($items as $key => $val) {
    echo "$key = $val\n";
}
?>

// 0 = item2
// 1 = item1
// 2 = item3
// 3 = item4

asort

Essa função ordena um array de forma que a correlação entre índices e valores é mantida. É usada principalmente para ordenar arrays associativos onde a ordem dos elementos é um fator importante.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// bool asort ( array &$array [, int $sort_flags ] )

<?php
$items = array("d" => "item1", "a" => "item2", "b" => "item3", "c" => "item4");
asort($items);
foreach ($items as $key => $val) {
    echo "$key = $val\n";
}
?>

// c = item4
// b = item3
// d = item1
// a = item2

arsort

Esta função ordena um array de forma que a correlação entre índices e valores é mantida. É usada principalmente para ordenar arrays associativos onde a ordem dos elementos é um fator importante.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// bool arsort ( array &$array [, int $sort_flags ] )

<?php
$items = array("d" => "item1", "a" => "item2", "b" => "item3", "c" => "item4");
arsort($items);
foreach ($items as $key => $val) {
    echo "$key = $val\n";
}
?>

// a = item2
// d = item1
// b = item3
// c = item4

ksort

Ordena um array pelas chaves, mantendo a correlação entre as chaves e os valores. Essa função é bastante útil principalmente para arrays associativos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// int ksort ( array &$array [, int $sort_flags ] )

<?php
$items = array("d"=>"item1", "a"=>"item2", "b"=>"item3", "c"=>"item4");
ksort($items);
foreach ($items as $key => $val) {
    echo "$key = $val\n";
}
?>

// a = item2
// b = item3
// c = item4
// d = item1

krsort

Ordena um array pelas chaves em ordem descrescente, mantendo a correlação entre entre as chaves e os valores. Essa função é bastante útil em arrays associativos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// bool krsort ( array &$array [, int $sort_flags ] )

<?php
$items = array("d"=>"item1", "a"=>"item2", "b"=>"item3", "c"=>"item4");
krsort($items);
foreach ($items as $key => $val) {
    echo "$key = $val\n";
}
?>

// d = item1
// c = item4
// b = item3
// a = item2

usort

Essa função irá ordenar um array pelos valores usando uma função de classificação definida pelo usuário. Se o array precisar ser ordenado utilizando um critério não trivial, você deve usar essa função.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// bool usort ( array &$array , string $cmp_function )

<?php
function cmp($a, $b) {
	if ($a == $b) {
		return 0;
	}
	return ($a < $b) ? -1 : 1;
}

$a = array(3, 2, 5, 6, 1);

usort($a, "cmp");

foreach ($a as $key => $value) {
	echo "$key: $value\n";
}
?>

// 0: 1
// 1: 2
// 2: 3
// 3: 5
// 4: 6

array_sum

array_sum() retorna a soma dos valores de um array.

1
2
3
4
5
6
7
8
9
10
11
12
// number array_sum ( array $array )

<?php
$a = array(2, 4, 6, 8);
echo "sum(a) = " . array_sum($a) . "\n";

$b = array("a" => 1.2, "b" => 2.3, "c" => 3.4);
echo "sum(b) = " . array_sum($b) . "\n";
?>

// sum(a) = 20
// sum(b) = 6.9

array_unique

Recebe o argumento array e retorna um novo array sem valores duplicados.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// array array_unique ( array $array )

<?php
$input = array("a" => "green", "red", "b" => "green", "blue", "red");
$result = array_unique($input);
print_r($result);
?>

// Array
// (
//     [a] => green
//     [0] => red
//     [1] => blue
// )

in_array

Procura no array, pelo valor informado.

1
2
3
4
5
6
7
8
9
10
11
12
13
// bool in_array ( mixed $needle , array $haystack [, bool $strict ] )

<?php
$os = array("Mac", "NT", "Irix", "Linux");
if (in_array("Irix", $os)) {
    echo "Got Irix";
}
if (in_array("mac", $os)) {
    echo "Got mac";
}
?>

// Got Irix

Procura no array, pelo valor informado.

1
2
3
4
5
6
7
8
// mixed array_search ( mixed $needle , array $haystack [, bool $strict ] )

<?php
$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');

$key = array_search('green', $array); // $key = 2;
$key = array_search('red', $array);   // $key = 1;
?>

array_rand

array_rand() é bastante útil quando se quer conseguir aleatoriamente um ou mais elementos de um array.

1
2
3
4
5
6
7
8
// mixed array_rand ( array $input [, int $num_req ] )

<?php
$input = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
$rand_keys = array_rand($input, 2);
echo $input[$rand_keys[0]] . "\n";
echo $input[$rand_keys[1]] . "\n";
?>

array_merge

Funde os elementos de dois ou mais arrays de forma que os elementos de um são colocados no final do array anterior. Retorna o array resultante da fusão.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// array array_merge ( array $array1 [, array $array2 [, array $... ]] )

<?php
$array1 = array("color" => "red", 2, 4);
$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);
$result = array_merge($array1, $array2);
print_r($result);
?>

// Array
// (
//     [color] => green
//     [0] => 2
//     [1] => 4
//     [2] => a
//     [3] => b
//     [shape] => trapezoid
//     [4] => 4
// )

array_walk

Aplica uma função definida pelo usuário nomeada pelo argumento funcname em cada elemento de array.

1
2
3
4
5
6
7
8
9
10
11
12
13
// bool array_walk ( array &$arrary , string $funcname [, mixed $userdata ] )

<?php
function myfunction($value,$key){
echo "The key $key has the value $value<br>";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction");
?>

// The key a has the value red
// The key b has the value green
// The key c has the value blue

count

Conta os elementos de um array.

1
2
3
4
5
6
7
8
9
// int count ( mixed $var [, int $mode ] )

<?php
$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
$result = count($a);
// $result == 3
?>

shuffle

Essa função mistura de forma aleatória os elementos de um array.

1
2
3
4
5
6
7
8
9
10
11
// bool shuffle ( array &$array )

<?php
$numbers = range(1, 20);
shuffle($numbers);
foreach ($numbers as $number) {
	echo "$number ";
}
?>

// 15 9 18 19 12 16 4 17 20 1 5 13 8 6 7 3 11 2 14 10

extract

Importar variáveis a partir de um array para a tabela de símbolos corrente. extract() verifica cada chave e vê se ela tem um válido nome de variável. Também verifica por colisões com já existente variáveis na tabela de símbolo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// int extract ( array $var_array [, int $extract_type [, string $prefix ]] )

<?php

$size = "large";
$var_array = array("color" => "blue",
                   "size"  => "medium",
                   "shape" => "sphere");
extract($var_array, EXTR_PREFIX_SAME, "wddx");

echo "$color, $size, $shape, $wddx_size\n";

// blue, large, sphere, medium
?>

compact

Cria um array contendo variáveis e seus valores.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// array compact ( mixed $varname [, mixed $... ] )

<?php
$city  = "San Francisco";
$state = "CA";
$event = "SIGGRAPH";

$location_vars = array("city", "state");

$result = compact("event", "nothing_here", $location_vars);
print_r($result);
?>

// Array
// (
//     [event] => SIGGRAPH
//     [city] => San Francisco
//     [state] => CA
// )

Referências

Conclusão

Se pode brincar bastante com arrays em PHP. Nas linguagens de programação, com certeza irá se deparar com um array. Sempre busque a melhor maneira de trabalhar com eles, pois ele pode ser usado da forma mais básica, até a mais complexa com multidimensões.

Autor

Hemerson Vianna

github: ui2code

twitter: ui2code

Relacionados

Ao fechar este aviso ou continuar navegando no site Nerd Calistênico, você aceita o uso de cookies.

Este site usa cookies para assegurar a melhor experiência para os nossos usuários. Consulte nossa política de privacidade.

Uma nova versão está disponível. Clique aqui para atualizar.