Este documento fornece um resumo sobre arrays no PHP. Ele discute arrays indexados versus associativos, como identificar e armazenar elementos em arrays, arrays multidimensionais, extrair múltiplos valores, percorrer e ordenar arrays.

1. Curso de PHP – Arrays Fábio M. Pereira
UNIVERSIDADE ESTADUAL DO SUDOESTE DA BAHIA – UESB
UNIDADE ORGANIZACIONAL DE INFORMÁTICA - UINFOR

2. Roteiro
•Indexados vs. Associativos
•Identificando Elementos
•Armazenando Dados
•Arrays Multidimensionais
•Extraindo Múltiplos Valores
•Conversão Entre Arrays e Variáveis
•Percorrendo Arrays
•Ordenação
•Operação em Arrays Completos
•Conjuntos

3. Arrays
•Um array é uma coleção de valores de dados organizados como uma coleção ordenada de pares chave-valor
•Um array não está limitado a apenas um tipos de dado
–Pode conter strings, inteiros, booleanos, etc.
–Pode também conter outros arrays

4. ARRAYS Indexados vs. Associativos

5. Arrays Indexados vs. Associativos
•Existem dois tipos de arrays em PHP: indexados e associativos
•As chaves de arrays indexados são inteiros, iniciando por zero
–Utilizados quando identificamos cada coisa por sua posição
•Arrays associativos possuem strings como chaves e se comportam mais como uma tabela com duas colunas
–A primeira coluna é a chave, que é usada para acessar o valor
•Em ambos os casos, as chaves são únicas, ou seja, não podemos ter dois elementos com a mesma chave, independente da mesma ser uma string ou um inteiro

6. ARRAYS Identificando Elementos

7. Identificando Elementos
•Podemos acessar valores específicos de um array já existente utilizando o nome da variável array, seguido pela chave do elemento, ou índice, entre colchetes:
$age['fred']
$shows[2]
•Valores string equivalentes a inteiros são tratados como inteiros
–$array[3] e $array[‘3’] se referem ao mesmo elemento, mas $array[‘03’] se refere a um elemento diferente
•Números negativos são chaves válidas, mas não especificam posições a partir do final do array como em Perl

8. Identificando Elementos
•Não precisamos colocar strings com uma única palavra entre aspas, por exemplo $age[‘fred’] é o mesmo que $age[fred]
–Embora seja um bom estilo de programação sempre utilizar as aspas, uma vez que podem confundir com constantes
define('index', 5);
echo $array[index];
// retorna $array[5], não $array['index'];
•Devemos usar aspas se estivermos usando interpolação:
$age["Clone{$number}"]

9. ARRAYS Armazenando Dados

10. Armazenando Dados
•Armazenar um valor em um array irá fazer com que o mesmo seja criado, caso já não exista
•Tentar extrais dados de um array que ainda não foi definido não irá criá-lo
// $addresses not defined before this point
echo $addresses[0]; // imprime nada
echo $addresses; // não imprime nada
$addresses[0] = "spam@cyberpromo.net";
echo $addresses; // imprime "Array"

11. Armazenando Dados
•Inicializando um array indexado:
$addresses[0] = "spam@cyberpromo.net";
$addresses[1] = "abuse@example.com";
$addresses[2] = "root@example.com";
•Inicializando um array associativo:
$price['gasket'] = 15.29;
$price['wheel'] = 75.25;
$price['tire'] = 50.00;

12. Armazenando Dados
•A maneira mais fácil de inicializar um array é utilizar o construtor array()
•Indexado:
$addresses = array("spam@cyberpromo.net",
"abuse@example.com", "root@example.com");
•Associativo:
$price = array(
'gasket' => 15.29,
'wheel' => 75.25,
'tire' => 50.00
);
–Equivalente a:
$price = array('gasket' => 15.29, 'wheel' => 75.25,
'tire' => 50.00);

13. Armazenando Dados
•Sintaxe alternativa, mais curta:
$days = ['gasket' => 15.29, 'wheel' => 75.25,
'tire' => 50.0];
•Construindo um array vazio:
$addresses = array();
•Especificando o índice inicial:
$days = array(1 => "Mon", "Tue", "Wed", "Thu", "Fri",
"Sat", "Sun");
// 2 é Tue, 3 é Wed, etc.
•Se utilizarmos um índice inicial não numérico:
$whoops = array('Fri' => "Black", "Brown", "Green");
// o mesmo que
$whoops = array('Fri' => "Black", 0 => "Brown",
1 => "Green");

14. Adicionando Valores no Final do Array
•Para adicionar valores no final de um array existente, utilize a sintaxe []:
$family = array("Fred", "Wilma");
$family[] = "Pebbles"; // $family[2] é "Pebbles"
•Esquecendo de incluir a chave:
$person = array('name' => "Fred");
$person[] = "Wilma"; // $person[0] é "Wilma"

15. Atribuindo uma Faixa de Valores
•A função range() cria um array de valores inteiros ou caracteres consecutivos, entre e incluindo os dois valores passados como seus argumentos
•Exemplo:
$numbers = range(2, 5);
// $numbers = array(2, 3, 4, 5);
$letters = range('a', 'z');
// $letters contém as letras do alfabeto
$reversedNumbers = range(5, 2);
// $reversedNumbers = array(5, 4, 3, 2);
•Apenas a primeira letra de um argumento string é usado para construir a faixa:
range("aaa", "zzz"); // o mesmo que range('a','z')

16. Descobrindo o Tamanho de um Array
•As funções count() e sizeof() são idênticas em uso e efeito
•Elas retornam o número de elementos de um array
$family = array("Fred", "Wilma", "Pebbles");
$size = count($family); // $size é 3
•Estas funções contam apenas os valores atribuídos:
$confusion = array( 10 => "ten", 11 => "eleven",
12 => "twelve");
$size = count($confusion); // $size é 3

17. Preenchendo um Array
•Para criar um array com valores inicializados com o mesmo conteúdo, utilizamos array_pad()
–O primeiro argumento é o array
–O segundo, o número mínimo de elementos que o array deve ter
–E o terceiro, o valor atribuído a qualquer dos elementos criados
•A função retornará um novo array preenchido, não afetando o seu argumento
$scores = array(5, 10);
$padded = array_pad($scores, 5, 0);
// $padded é array(5, 10, 0, 0, 0)
•Se quisermos os novos elementos no início do array:
$padded = array_pad($scores, −5, 0);
// $padded é array(0, 0, 0, 5, 10);

18. ARRAYS Arrays Multidimensionais

19. Arrays Multidimensionais
•Os valores de um array podem ser arrays, permitindo facilmente a criação de arrays multidimensionais:
$row0 = array(1, 2, 3);
$row1 = array(4, 5, 6);
$row2 = array(7, 8, 9);
$multi = array($row0, $row1, $row2);
•Podemos nos referir a elementos de arrays multidimensionais adicionando mais []s:
$value = $multi[2][0];
// row 2, column 0. $value = 7
•Interpolando:
echo("The value at row 2, column 0 is " .
"{$multi[2][0]}n");

20. ARRAYS Extraindo Múltiplos Valores

21. Extraindo Múltiplos Valores
•Utilize o construtor list() para copiar todos os valores de um array em variáveis:
list ($variable, ...) = $array;
•Exemplo:
$person = array("Fred", 35, "Betty");
list($name, $age, $wife) = $person;
// $name é "Fred", $age é 35, $wife é "Betty"
•Se possuirmos mais valores que variáveis, os valores extras serão ignorados:
$person = array("Fred", 35, "Betty");
list($name, $age) = $person;
// $name é "Fred", $age é 35

22. Extraindo Múltiplos Valores
•Se possuirmos mais variáveis que valores, as variáveis extras receberão o valor NULL
$values = array("hello", "world");
list($a, $b, $c) = $values;
// $a é "hello", $b é "world", $c é NULL
•Utilize vírgulas para “saltar” valores na lista:
$values = range('a', 'e');
// use range para preencher o array
list($m, , $n, , $o) = $values;
// $m é "a", $n é "c", $o é "e"

23. Dividindo um Array
•Para extrair apenas um subconjunto do array, utilize a função array_slice():
$subset = array_slice(array, offset, length);
•Retorna um novo array consistindo de uma série consecutiva de valores do array original:
–O parâmetro offset indica o elemento inicial
–E o parâmetro length indica a quantidade de valores a copiar
•Exemplo:
$people = array("Tom", "Dick", "Harriet", "Brenda",
"Jo");
$middle = array_slice($people, 2, 2);
// $middle é array("Harriet", "Brenda")

24. Dividindo um Array
•Em arrays associativos:
// este uso de array_slice() não faz sentido
$person = array('name' => "Fred", 'age' => 35,
'wife' => "Betty");
$subset = array_slice($person, 1, 2);
// $subset é array(0 => 35, 1 => "Betty")
•Extraindo apenas alguns valores para variáveis:
$order = array("Tom", "Dick", "Harriet", "Brenda",
"Jo");
list($second, $third) = array_slice($order, 1, 2);
// $second é "Dick", $third é "Harriet"

25. Dividindo um Array em Partes
•Para dividir um array em partes menores, do mesmo tamanho, utilize a função array_chunk():
$chunks = array_chunk(array, size
[, preserve_keys]);
•A função retorna um array de arrays menores
•O terceiro argumento, preserve_keys, é um booleano que determina se os elementos dos novos arrays devem possuir as mesmas chaves do original (útil para arrays associativos) ou em novas chaves numéricas a partir de 0 (útil para arrays indexados)
–O padrão é atribuir novas chaves

26. Dividindo um Array em Partes
•Para dividir um array em partes menores, do mesmo tamanho, utilize a função array_chunk():
$chunks = array_chunk(array, size
[, preserve_keys]);
•A função retorna um array de arrays menores
•O terceiro argumento, preserve_keys, é um booleano que determina se os elementos dos novos arrays devem possuir as mesmas chaves do original (útil para arrays associativos) ou em novas chaves numéricas a partir de 0 (útil para arrays indexados)
–O padrão é atribuir novas chaves
$nums = range(1, 7);
$rows = array_chunk($nums, 3);
print_r($rows);
Array (
[0] => Array (
[0] => 1
[1] => 2
[2] => 3
)
[1] => Array (
[0] => 4
[1] => 5
[2] => 6
)
[2] => Array (
[0] => 7
)
)

27. Chaves e Valores
•A função array_keys() retorna um array consistindo apenas das chaves do array na ordem interna:
$arrayOfKeys = array_keys(array);
•Exemplo:
$person = array('name' => "Fred", 'age' => 35,
'wife' => "Wilma");
$keys = array_keys($person);
// $keys é array("name", "age", "wife")
•A função array_values() retorna um array apenas com os valores do array:
$arrayOfValues = array_values(array);
•Exemplo:
$values = array_values($person);
// $values é array("Fred", 35, "Wilma");

28. Verificando a Existência de um Elemento
•Para verificar a existência de um elemento no array, utilize a função array_key_exists():
if (array_key_exists(key, array)) { ... }
•A função retorna um booleano indicando se o primeiro argumento é uma chave válida no array dado como segundo argumento
$person['age'] = 0;
if ($person['age']) {
echo "true!n";
}
if (array_key_exists('age', $person)) {
echo "exists!n";
}
exists!

29. Verificando a Existência de um Elemento
•Mesmo que exista um elemento no array com o nome de chave dado, o seu valor correspondente pode ser falso (0, NULL, ou uma string vazia)
•Por isso, muitos preferem utilizar isset() em vez de array_key_exists():
$a = array(0, NULL, '');
function tf($v)
{
return $v ? 'T' : 'F';
}
for ($i=0; $i < 4; $i++) {
printf("%d: %s %sn", $i, tf(isset($a[$i])),
tf(array_key_exists($i, $a)));
}
0: T T
1: F T
2: T T
3: F F

30. Removendo e Inserindo Elementos em um Array
•A função array_splice() pode remover ou inserir elementos em um array e opcionalmente criar um outro array a partir dos elementos removidos:
$removed = array_splice(array, start
[, length [, replacement ] ]);
•Considerando o array:
$subjects = array("physics", "chem", "math", "bio",
"cs", "drama", "classics");
•Podemos remover os elementos “math”, “bio” e “cs”:
$removed = array_splice($subjects, 2, 3);
// $removed é array("math", "bio", "cs")
// $subjects é array("physics", "chem", "drama",
// "classics")

31. Removendo e Inserindo Elementos em um Array
•Se omitirmos o tamanho, array_splice() remove até o final do array:
$removed = array_splice($subjects, 2);
// $removed é array("math", "bio", "cs",
// "drama", "classics")
// $subjects é array("physics", "chem")
•Para inserir elementos onde outros foram removidos, utilizamos o quarto argumento
–A quantidade de elementos inseridos não tem que ser a mesma que a de elementos removidos
$new = array("law", "business", "IS");
array_splice($subjects, 3, 4, $new);
// $subjects é array("physics", "chem",
// "math", "law", "business", "IS")

32. Removendo e Inserindo Elementos em um Array
•Para inserir elementos no array, “empurrando” elementos existentes para a direita, não remova nenhum elemento:
$subjects = array("physics", "chem", "math");
$new = array("law", "business");
array_splice($subjects, 2, 0, $new);
// $subjects é array("physics", "chem", "law",
// "business", "math")
•array_splice() também funciona em arrays associativos:

33. Removendo e Inserindo Elementos em um Array
•Para inserir elementos no array, “empurrando” elementos existentes para a direita, não remova nenhum elemento:
$subjects = array("physics", "chem", "math");
$new = array("law", "business");
array_splice($subjects, 2, 0, $new);
// $subjects é array("physics", "chem", "law",
// "business", "math")
•array_splice() também funciona em arrays associativos:
$capitals = array(
'USA' => "Washington",
'Great Britain' => "London",
'New Zealand' => "Wellington",
'Australia' => "Canberra",
'Italy' => "Rome",
'Canada' => "Ottawa"
);
$downUnder = array_splice($capitals, 2, 2);
// remove New Zealand e Australia
$france = array('France' => "Paris");
array_splice($capitals, 1, 0, $france);
// insere France entre USA and GB

34. ARRAYS Conversão entre Arrays e Variáveis

35. Conversão entre Arrays e Variáveis
•As funções extract() e compact() realizam a conversão entre arrays e variáveis
•Os nomes das variáveis correspondem às chaves do array e os valores das variáveis correspondem aos valores no array
•Por exemplo, este array:
$person = array('name' => "Fred", 'age' => 35,
'wife' => "Betty");
•Pode ser convertido em e a partir destas variáveis:
$name = "Fred";
$age = 35;
$wife = "Betty";

36. Criando Variáveis a Partir de um Array
•Utilize a função extract():
extract($person);
// $name, $age, and $wife are now set
•Podemos modificar a função extract() passando um segundo argumento
•O mais útil é EXTR_PREFIX_ALL:
$shape = "round";
$array = array('cover' => "bird",
'shape' => "rectangular");
extract($array, EXTR_PREFIX_ALL, "book");
echo "Cover: {$book_cover}, " .
"Book Shape: {$book_shape}, Shape: {$shape}";
Cover: bird, Book Shape: rectangular, Shape: round

37. Criando um Array a Partir de Variáveis
•A função compact() é o inverso de extract() – passamos nomes de variáveis como parâmetros separados ou em um array e a função cria um array associativo cujas chaves são os nomes das variáveis e os valores os conteúdos das mesmas
–Qualquer nome que não corresponda a uma variável existente é ignorado
•Exemplo:
$color = "indigo";
$shape = "curvy";
$floppy = "none";
$a = compact("color", "shape", "floppy");
// ou
$names = array("color", "shape", "floppy");
$a = compact($names);

38. ARRAYS Percorrendo Arrays

39. Percorrendo Arrays
•A tarefa mais comum com arrays é fazer alguma coisa com todos os seus elementos
–Por exemplo, enviar um e-mail para cada um dos elementos de um array de endereços, atualizar arquivos em um array de nomes de arquivos ou modificar valores em um array de preços

40. Contrutor foreach
•A forma mais comum de se criar um laço sobre elementos de um array:
$addresses = array("spam@cyberpromo.net",
"abuse@example.com");
foreach ($addresses as $value) {
echo "Processing {$value}n";
}
Processing spam@cyberpromo.net
Processing abuse@example.com
•Os elementos são processados em sua ordem interna
•foreach faz uma cópia do array para processá-lo

41. Contrutor foreach
•Uma forma alternativa de foreach dá acesso a arrays associativos:
$person = array('name' => "Fred", 'age' => 35,
'wife' => "Wilma");
foreach ($person as $key => $value) {
echo "Fred's {$key} is {$value}n";
}
Fred's name is Fred
Fred's age is 35
Fred's wife is Wilma

42. Funções do Apontador
•Todo array PHP mantém a indicação para elemento que estamos trabalhando atualmente
•PHP possui funções para atribuir, mover e reiniciar este apontador:
–current() – retorna o elemento atualmente apontado
–reset() – move o apontador para o primeiro elemento do array e o retorna
–next() – move o apontador para o próximo elemento do array e o retorna
–prev() – move o apontador para o elemento anterior do array e o retorna
–end() – move o apontador para o último elemento do array e o retorna
–key() – retorna a chave do elemento atual

43. Funções do Apontador
•A função each() é usada para percorrer os elementos de um array
–Ela processa os elementos de acordo com a sua ordem interna
–Esta abordagem não faz uma cópia do array como em foreach
–É útil para arrays muito grandes quando quisermos conservar a memória
reset($addresses);
while (list($key, $value) = each($addresses)) {
echo "{$key} is {$value}<br />n";
}
0 is spam@cyberpromo.net
1 is abuse@example.com

44. Funções do Apontador
$ages = array( 'Person' => "Age", 'Fred' => 35, 'Barney' => 30, 'Tigger' => 8, 'Pooh' => 40 ); // inicia tabela e imprime cabeçalho reset($ages); list($c1, $c2) = each($ages); echo("<table>n<tr><th>{$c1}</th><th>{$c2}</th></tr>n"); // imprime o restante dos valores while (list($c1, $c2) = each($ages)) { echo("<tr><td>{$c1}</td><td>{$c2}</td></tr>n"); } // fim da tabela echo("</table>");

45. Utilizando for
•Se estivermos trabalhando com arrays indexados, onde as chaves são inteiros consecutivos, iniciando por zero, podemos utilizar um laço for para contar através dos índices
$addresses = array("spam@cyberpromo.net",
"abuse@example.com");
$addressCount = count($addresses);
for ($i = 0; $i < $addressCount; $i++) {
$value = $addresses[$i];
echo "{$value}n";
}
spam@cyberpromo.net
abuse@example.com

46. Chamando uma Função para Cada Elemento do Array
•A função array_walk() chama uma função definida pelo usuário uma vez para cada elemento do array:
array_walk(array, callable);
•A função deverá possuir dois ou três argumentos:
–O primeiro é o valor do elemento
–O segundo é a chave do elemento
–E o terceiro (opcional) é um valor fornecido para array_walk() quando ela é chamada
$callback = function printRow($value, $key){
print("<tr><td>{$value}</td><td>" .
"{$key}</td></tr>n");
};
$person = array('name' => "Fred", 'age' => 35,
'wife' => "Wilma");
array_walk($person, $callback);

47. Chamando uma Função para Cada Elemento do Array
•Uma variação do exemplo anterior especifica a cor de fundo usando o terceiro argumento opcional:
function printRow($value, $key, $color) {
echo "<tr>n<td bgcolor="{$color}">" . "{$value}</td>";
echo "<td bgcolor="{$color}">" . "{$key}</td>n</tr>n");
}
$person = array('name' => "Fred", 'age' => 35,
'wife' => "Wilma");
echo "<table border="1">";
array_walk($person, "printRow", "lightblue");
echo "</table>";

48. Chamando uma Função para Cada Elemento do Array
•Se tivermos múltiplos valores para passar à função chamada, utilize um array como terceiro parâmetro:
$extraData = array('border' => 2, 'color' => "red");
$baseArray = array("Ford", "Chrysler", "Volkswagen",
"Honda", "Toyota");
array_walk($baseArray, "walkFunction", $extraData);
function walkFunction($item, $index, $data) {
echo "{$item} <- item, then border: " .
"{$data['border']}";
echo " color->{$data['color']}<br />" ;
}
Ford <- item, then border: 2 color->red
Crysler <- item, then border: 2 color->red
VW <- item, then border: 2 color->red
Honda <- item, then border: 2 color->red
Toyota <- item, then border: 2 color->red

49. Computando um Array
•Um “primo” de array_walk() é a função array_reduce(), que aplica uma função a cada um dos elementos de um array, de modo a retornar um único valor:
$result = array_reduce(array, callable
[, default ]);
•A função deve receber dois argumentos: o total da execução e o valor atual sendo processado, devendo retornar um novo total
•Por exemplo, somar os quadrados dos valores de um array:

50. Computando um Array
•Um “primo” de array_walk() é a função array_reduce(), que aplica uma função a cada um dos elementos de um array, de modo a retornar um único valor:
$result = array_reduce(array, callable
[, default ]);
•A função deve receber dois argumentos: o total da execução e o valor atual sendo processado, devendo retornar um novo total
•Por exemplo, somar os quadrados dos valores de um array:
$callback = function addItUp($runningTotal, $currentValue)
{
$runningTotal += $currentValue * $currentValue;
return $runningTotal;
};
$numbers = array(2, 3, 5, 7);
$total = array_reduce($numbers, $callback);
echo $total;
87

51. Computando um Array
•A linha do array_reduce() faz as seguintes chamadas de função:
addItUp(0, 2);
addItUp(4, 3);
addItUp(13, 5);
addItUp(38, 7);
•O argumento default, opcional, se fornecido, é um valor inicial
•Por exemplo, se fizermos uma mudança na chamada do exemplo anterior:
$total = array_reduce($numbers, "addItUp", 11);
•As chamadas de função resultantes seriam:
addItUp(11, 2);
addItUp(15, 3);
addItUp(24, 5);
addItUp(49, 7);

52. Buscando Valores
•A função in_array() retorna true ou false, dependendo do seu primeiro argumento ser um elementos do array dado como segundo argumento:
if (in_array(to_find, array [, strict])) { ... }
•Se o valor do terceiro argumento opcional é true, os tipos de to_find e o valor no array devem combinar
–O padrão é não checar tipos de dados
•Exemplo:
$addresses = array("spam@cyberpromo.net",
"abuse@example.com", "root@example.com");
$gotSpam = in_array("spam@cyberpromo.net",
$addresses);
// $gotSpam é true
$gotMilk = in_array("milk@tucows.com", $addresses);
// $gotMilk é false

53. Buscando Valores
•PHP automaticamente indexa valores em arrays, portanto in_array() é geralmente muito mais rápida do que percorrer o array com um laço
•Verificando se o usuário entrou com a informação em todos os campos obrigatórios em um formulário:

54. Buscando Valores
<?php
function hasRequired($array, $requiredFields) {
$keys = array_keys($array);
foreach ($requiredFields as $fieldName) {
if (!in_array($fieldName, $keys)) {
return false; }
if(!$array[$fieldName]) {
return false; }
}
return true;
}
if ($_POST['submitted']) {
echo "<p>You ";
echo hasRequired($_POST,
array('name', 'email_address')) ? "did" : "did not";
echo " have all the required fields.</p>";
} ?>
<form action="<?php echo $_SERVER['PHP_SELF']; ?>" method="POST">
<p>Name: <input type="text" name="name" /><br />
Email address: <input type="text" name="email_address" /><br />
Age (optional): <input type="text" name="age" /></p>
<p align="center"><input type="submit" value="submit"
name="submitted" /></p>
</form>

55. Buscando Valores
•Uma variação de in_array() é a função array_search(), que retorna a chave do elemento, se encontrado
–Também recebe o terceiro argumento opcional strict
•Exemplo:
$person = array('name' => "Fred", 'age' => 35,
'wife' => "Wilma");
$k = array_search("Wilma", $person);
echo("Fred's {$k} is Wilman");
Fred's wife is Wilma

56. ARRAYS Ordenação

57. Ordenação de Arrays
•Modifica a ordem interna dos elementos de um array e opcionalmente reescreve as chaves para refletir a nova ordem
•PHP fornece três maneiras de ordenar um array
–Ordenação pelas chaves
–Ordenação pelos valores, sem mudar as chaves
–Ordenação por valores, modificando as chaves
•Todas as três formas podem ser feitas em ordem ascendente, descendente, ou na ordem determinada por uma função definida pelo usuário

58. Ordenação de Arrays
•Funções fornecidas por PHP para ordenação de arrays:
•As funções sort(), rsort() e usort() são projetadas para trabalhar com arrays indexados
•Exemplo:
$names = array("Cath", "Angela", "Brad", "Mira");
sort($names);
// $names é "Angela", "Brad", "Cath", "Mira"
Efeito
Ascendente
Descendente
Odem definida pelo usuário
Ordena arrays pelos valores, reatribuindo índices, iniciando com 0
sort
rsort()
usort()
Ordena arrays pelos valores
asort()
arsort()
uasort()
Ordena arrays pelas chaves
ksort()
krsort()
uksort()

59. Exemplo
•Mapeando usuários e tempo de login, mostrando os três primeiros:

60. Exemplo
$logins = array(
'njt' => 415,
'kt' => 492,
'rl' => 652,
'jht' => 441,
'jj' => 441,
'wt' => 402,
'hut' => 309,
);
arsort($logins);
$numPrinted = 0;
echo "<table>n";
foreach ($logins as $user => $time) {
echo("<tr><td>{$user}</td><td>{$time}</td></tr>n");
if (++$numPrinted == 3) {
break; // pára após três
}
}
echo "</table>";

61. Ordenação de Arrays
•Ordenação definida pelo usuário requer que forneçamos uma função que recebe dois valores e retorna um valor que especifica a ordem dos dois valores no array a ser ordenado:
–1, se o primeiro valor é maior que o segundo
–-1, se o primeiro valor é menor que o segundo
–0, se os valores são iguais

62. Ordem Natural
•As funções internas de PHP ordenam corretamente strings e números, mas não strings que contenham números
–Por exemplo, ex10.php, ex5.php, e ex1.php, em funções de ordenação normal ficariam ex1.php, ex10.php, ex5.php
•Para ordenar corretamente strings que contenham números, utilize as funções natsort() e natcasesort()

63. Ordenando Múltiplos Arrays
•A função array_multisort() ordena múltiplos arrays indexados de uma só vez:
array_multisort(array1 [, array2, ... ]);
•A função preservará a relação dos elementos dos arrays, mantendo os registros
•No exemplo a seguir os elementos serão ordenados inicialmente pela idade (ascendente), então pelo código de área (descendente):

64. Ordenando Múltiplos Arrays
•A função array_multisort() ordena múltiplos arrays indexados de uma só vez:
array_multisort(array1 [, array2, ... ]);
•A função preservará a relação dos elementos dos arrays, mantendo os registros
•No exemplo a seguir os elementos serão ordenados inicialmente pela idade (ascendente), então pelo código de área (descendente):
$names = array("Tom", "Dick", "Harriet", "Brenda", "Joe");
$ages = array(25, 35, 29, 35, 35);
$zips = array(80522, '02140', 90210, 64141, 80522);
array_multisort($ages, SORT_ASC, $zips, SORT_DESC,
$names, SORT_ASC);
for ($i = 0; $i < count($names); $i++) {
echo "{$names[$i]}, {$ages[$i]}, {$zips[$i]}n";
}
Tom, 25, 80522
Harriet, 29, 90210
Joe, 35, 80522
Brenda, 35, 64141
Dick, 35, 02140

65. Invertendo Arrays
•A função array_reverse() inverte a ordem interna dos elementos de um array
$reversed = array_reverse(array);
•Chaves numéricas são renumeradas iniciando por 0, strings não são afetadas
•A função array_flip() retorna um array que inverte a ordem dos pares chave-valor:
$flipped = array_flip(array);
•Por exemplo, se você tem um array mapeando nomes de usuários para pastas, podemos usar array_flip() para criar um array mapeando pastas para nomes de usuários:

66. Invertendo Arrays
•A função array_reverse() inverte a ordem interna dos elementos de um array
$reversed = array_reverse(array);
•Chaves numéricas são renumeradas iniciando por 0, strings não são afetadas
•A função array_flip() retorna um array que inverte a ordem dos pares chave-valor:
$flipped = array_flip(array);
•Por exemplo, se você tem um array mapeando nomes de usuários para pastas, podemos usar array_flip() para criar um array mapeando pastas para nomes de usuários:
$u2h = array( 'gnat' => "/home/staff/nathan", 'frank' => "/home/action/frank", 'petermac' => "/home/staff/petermac", 'ktatroe' => "/home/staff/kevin" ); $h2u = array_flip($u2h); $user = $h2u["/home/staff/kevin"]; // $user é 'ktatroe'

67. Ordenação Aleatória
•Para colocar os elementos de um array em ordem aleatória, utilizamos a função shuffle()
•Ela substituirá todas as chaves existentes, string ou numérica, por inteiros consecutivos iniciando por 0
•Exemplo:
$weekdays = array("Monday", "Tuesday", "Wednesday",
"Thursday", "Friday");
shuffle($weekdays);
print_r($weekdays);
Array(
[0] => Tuesday
[1] => Thursday
[2] => Monday
[3] => Friday
[4] => Wednesday
)

68. ARRAYS Operação em Arrays Completos

69. Operação em Arrays Completos
•PHP possui várias funções para modificação ou para aplicar uma operação em todos os elementos de um array
•Podemos unir arrays, encontrar diferença, calcular total, etc.

70. Calculando a Soma de um Array
•A função array_sum() adiciona os valores em um array indexado ou associativo:
$sum = array_sum(array);
•Exemplo:
$scores = array(98, 76, 56, 80);
$total = array_sum($scores); // $total = 310

71. Unindo Dois Arrays
•A função array_merge() inteligentemente une dois arrays:
$merged = array_merge(array1, array2 [, array ... ])
•Exemplo:
$first = array("hello", "world");
// 0 => "hello", 1 => "world"
$second = array("exit", "here");
// 0 => "exit", 1 => "here"
$merged = array_merge($first, $second);
// $merged = array("hello", "world", "exit", "here")
•Se uma chave de um array anterior é repetida, o seu valor é substituído pelo valor no último array:
$first = array('bill' => "clinton",
'tony' => "danza");
$second = array('bill' => "gates",
'adam' => "west");
$merged = array_merge($first, $second);
// $merged = array('bill' => "gates",
// 'tony' => "danza", 'adam' => "west")

72. Diferença Entre Arrays
•A função array_diff() calcula a diferença entre dois arrays, isto é, os valores do primeiro array que não estão presentes no segundo
–Identifica elementos de um array que não estão em outros
$diff = array_diff(array1, array2 [, array ... ]);
•Exemplo:
$a1 = array("bill", "claire", "ella", "simon", "judy");
$a2 = array("jack", "claire", "toni");
$a3 = array("ella", "simon", "garfunkel");
// encontrar valores de $a1 que não estão em $a2 ou $a3
$difference = array_diff($a1, $a2, $a3);
print_r($difference);
Array(
[0] => "bill",
[4] => "judy"
);

73. Diferença Entre Arrays
•Valores são comparados utilizando-se o comparador de comparação estrita ===, assim os valores 1 e “1” são considerados diferentes
•As chaves do primeiro array são preservadas

74. Filtrando Elementos
•Para identificar um subconjunto de um array baseado em seus valores, utilizamos a função array_filter():
$filtered = array_filter(array, callback);
•Para cada valor do array é passada a função chamada de callback
–O array retornado contém aqueles elementos do array original cuja função retorna um valor true
–As chaves são preservadas
•Exemplo:
$callback = function isOdd ($element)
{
return $element % 2;
};
$numbers = array(9, 23, 24, 27);
$odds = array_filter($numbers, $callback);
// $odds é array(0 => 9, 1 => 23, 3 => 27)

75. ARRAYS Conjuntos

76. Conjuntos
•Arrays permitem a implementação das operações básicas da teoria dos conjuntos: união, interseção e diferença
•A união de dois arrays pode ser calculada pelas funções array_merge() e array_unique():

77. Conjuntos
•Arrays permitem a implementação das operações básicas da teoria dos conjuntos: união, interseção e diferença
•A união de dois arrays pode ser calculada pelas funções array_merge() e array_unique():
function arrayUnion($a, $b) { $union = array_merge($a, $b); // duplicatas ainda podem existir $union = array_unique($union); return $union; } $first = array(1, "two", 3); $second = array("two", "three", "four"); $union = arrayUnion($first, $second); print_r($union); Array( [0] => 1 [1] => two [2] => 3 [4] => three [5] => four )

78. Conjuntos
•Interseção é o conjunto de elementos que os arrays possuem em comum
•A função array_intersect() recebe qualquer número de arrays como argumentos e retorna um array com os elementos comuns a todos
•Se várias chaves possuírem o mesmo valor, a primeira chave com o valor será preservada

79. Curso de PHP – Arrays Fábio M. Pereira
UNIVERSIDADE ESTADUAL DO SUDOESTE DA BAHIA – UESB
UNIDADE ORGANIZACIONAL DE INFORMÁTICA - UINFOR

80. Baseado em...