Upload
fabio-moura-pereira
View
294
Download
2
Embed Size (px)
DESCRIPTION
Curso da Linguagem de Programação PHP da disciplina Desenvolvimento de Sistemas Web da Universidade Estadual do Sudoeste da Bahia - UESB.
Citation preview
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]";
$addresses[1] = "[email protected]";
$addresses[2] = "[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")
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")
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:
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
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]",
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:
$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
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]",
$addressCount = count($addresses);
for ($i = 0; $i < $addressCount; $i++) {
$value = $addresses[$i];
echo "{$value}\n";
}
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);
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>";
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
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
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()
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 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
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...