Curso de PHP - Arrays

Curso de PHP – Arrays Fábio M. Pereira

UNIVERSIDADE ESTADUAL DO SUDOESTE DA BAHIA – UESB

UNIDADE ORGANIZACIONAL DE INFORMÁTICA - UINFOR

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

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

ARRAYS Indexados vs. Associativos

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

ARRAYS Identificando Elementos

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

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}"]

ARRAYS Armazenando Dados

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] = "[email protected]";

echo $addresses; // imprime "Array"

Armazenando Dados

• Inicializando um array indexado: $addresses[0] = "[email protected]";



• Inicializando um array associativo: $price['gasket'] = 15.29;

$price['wheel'] = 75.25;

$price['tire'] = 50.00;

Armazenando Dados

• A maneira mais fácil de inicializar um array é utilizar o construtor array()

• Indexado: $addresses = array("[email protected]",

"[email protected]", "[email protected]");

• 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);

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");

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"

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')

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

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);

ARRAYS Arrays Multidimensionais

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");

ARRAYS Extraindo Múltiplos Valores

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

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"

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")

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"

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

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

)

)

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");

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!

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 %s\n", $i, tf(isset($a[$i])),

tf(array_key_exists($i, $a)));

}

0: T T

1: F T

2: T T

3: F F

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")


• 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")


• 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");


// $subjects é array("physics", "chem", "law",

// "business", "math")

• array_splice() também funciona em arrays associativos:


• 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");


// $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

ARRAYS Conversão entre Arrays e Variáveis

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";

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

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);

ARRAYS Percorrendo Arrays

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

Contrutor foreach

• A forma mais comum de se criar um laço sobre elementos de um array:

$addresses = array("[email protected]",

"[email protected]");

foreach ($addresses as $value) {

echo "Processing {$value}\n";

}

Processing [email protected]

Processing [email protected]

• Os elementos são processados em sua ordem interna

• foreach faz uma cópia do array para processá-lo

Contrutor foreach

• Uma forma alternativa de foreach dá acesso a arrays associativos:


'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

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

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 [email protected]

1 is [email protected]

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>");

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("[email protected]",

"[email protected]");

$addressCount = count($addresses);

for ($i = 0; $i < $addressCount; $i++) {

$value = $addresses[$i];

echo "{$value}\n";

}

[email protected]

[email protected]

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");

};


'wife' => "Wilma");

array_walk($person, $callback);


• 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");

}


'wife' => "Wilma");

echo "<table border=\"1\">";

array_walk($person, "printRow", "lightblue");

echo "</table>";


• 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

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:

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

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);

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("[email protected]",

"[email protected]", "[email protected]");

$gotSpam = in_array("[email protected]",

$addresses);

// $gotSpam é true

$gotMilk = in_array("[email protected]", $addresses);

// $gotMilk é false

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:

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>

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 Wilma\n");

Fred's wife is Wilma

ARRAYS Ordenação

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


• 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()

Exemplo

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

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>";


• 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

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()

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):

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

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:

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'

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

)

ARRAYS Operação em Arrays Completos

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.

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

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")

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"

);

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

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)

ARRAYS Conjuntos

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():

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

)

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

Curso de PHP – Arrays Fábio M. Pereira

UNIVERSIDADE ESTADUAL DO SUDOESTE DA BAHIA – UESB

UNIDADE ORGANIZACIONAL DE INFORMÁTICA - UINFOR

Baseado em...

Curso de PHP - Arrays

Education

Transcript of Curso de PHP - Arrays