Arrays – Parte X – O ponteiro do array

Enviado por Filippe em 3 de fevereiro de 2011 nenhum comentário

Cada array tem um ponteiro que indica o elemento “atual” de uma matriz em uma iteração. O ponteiro é usado por um número de diferentes construções, mas só podem ser manipulados através de um conjunto de funções e não afeta a sua capacidade de acessar os elementos individuais da matriz, nem é afetada pela maioria dos “normais” as operações da matriz. O ponteiro é, na verdade, uma maneira prática de manipular uma matriz sem a necessidade de uma variável externa para fazer o trabalho.

A maneira mais direta de manipular o ponteiro de um array é através de uma série de funções projetadas especificamente para esta finalidade. Ao iniciar uma iteração sobre um array, o primeiro passo geralmente é resetar o ponteiro do array para redefinir sua possição inicial usando a função reset(), e depois disso, podemos seguir em frente ou para trás em uma posição usando prev() e next(), respectivamente . Em um determinado ponto, podemos acessar o valor do elemento atual usando current() e usando a sua key(). A seguir temos um exemplo:

$array = array(’foo’ => ’bar’, ’baz’, ’bat’ => 2);
function displayArray($array) {
reset($array);
while (key($array) !== null) {
echo key($array) .”: ” .current($array) . PHP_EOL;
next($array);
}
}
Aqui, nós criamos uma função que irá exibir todos os valores em um array. Primeiro, chamamos reset() para voltar o ponteiro interno do array. Em seguida, usando um loop while, exibimos a chave atual e o seu valor, usando as funções key() e current(). Por fim, avançamos o ponteiro do array, usando next(). O loop continuará até que não termos mais uma chave válida.

OBSERVAÇÃO: É importante compreender que não existe correlação entre o ponteiro do array e as chaves dos elementos do array. Passando à frente ou para trás por uma posição simplesmente lhe dá acesso aos elementos da array baseada em sua posição dentro dela, e não em suas chaves.
Caso você precise iterar pelo array de trás para frente usando ponteiros, você poderia na teoria iniciar a sua iteração do último elemento (usando o end() função para redefinir o ponteiro para a parte inferior do array) e em seguida fazendo o seu caminho para voltar ao início:


$a = array (1, 2, 3);
end($a);
while (key ($array) !== null) {
echo key($array) .”: ” .current($array) . PHP_EOL;
prev($array);
}
Observe como, nos dois últimos exemplos, checamos se a iteração deve continuar comparando o resultado da key() de um array com NULL. Isso só funciona porque nós estamos usando um operador sem identidade. utilizar o operador de desigualdade pode causar alguns problemas importantes, se um dos elementos do array tem uma chave que avalia inteiro zero.

Parceria com o site DonaBanca

Enviado por Filippe em 20 de janeiro de 2011 nenhum comentário
Olá pessoal, estamos reformulando o site e fechando algumas parcerias para continuar postando coisas de php por aqui, sempre estou com algum problema que me impede de criar novos posts então esperamos que agora isso ocorra mais freqüentemente. E nosso primeiro parceiro é o site de compras coletivas DonaBanca.
Nele as pessoas poderão efetuar suas compras coletivas voltado para o público feminino, mas isso não quer dizer que é apenas para as mulheres, pois vão existir ofertas unisex alem da possibilidade de você presentear sua amada.

O site também possui algumas promoções bem interessantes, como:

1 – Convidou ganhou – Promoção para os usuários do site que convidam amigos. A cada amigo convidado você receberá R$ 10,00 em créditos. Caso convide 100 amigos poderá ganhar R$1000,00 podendo assim participar de diversas ofertas a custo zero.

2 – Promoções exclusivas para seguidores do twitter, quando chegarmos aos 1000 (um mil) seguidores, vamos sortear um IPOD SHUFLLE. Então comece a seguir o @donabanca – http://www.twitter.com/donabanca

Veja o regulamento das promoções: http://www.donabanca.com.br/promocoes/
Ainda não é cadastrado no nosso site, cadastre-se agora: http://www.donabanca.com.br/adm/cadastro

Você também pode seguir agente nas seguintes redes sociais.

Orkut    - http://www.orkut.com.br/Main#Profile?uid=1840681113766916051
Twitter – @donabanca – http://www.twitter.com/donabanca
Facebook – http://www.facebook.com/profile.php?id=100001790772092
Facebook – Para curtir – http://www.facebook.com/pages/Donabanca/177813338895901
Matéria sobre o DonaBanca no Diário de Pernambuco – http://www.diariodepernambuco.com.br/2011/01/05/info3_0.asp

OFERTA DE HOJE

50% DE DESCONTO NA LIMPEZA DE PELE + DESIGN DE SOBRANCELHA EM DANILA ESTÉTICA (DE R$ 95,00 POR R$ 47,50)


Saiba mais
Danila Estética é um centro de Beleza com profissionais qualificados para melhor atender seu público. Venha conhecer todos os nossos serviços de Depilação, Tratamento Facial, Tratamento Corporal, Cabeleireiro e Manicure.
Faça conosco Banho Dourado, Drenagem linfática, Hidratação profunda, Depilação (com cera natural), Depilação Artística, Redução de medidas, Celulite, Estrias, Gorduras localizadas, entre outros.

Arrays – Parte X – Iteração de Arrays

Enviado por Filippe em 26 de novembro de 2010 nenhum comentário

Iteração provavelmente é uma das operações mais comuns que você vai realizar com arrays, além de criá-los, é claro. Ao contrário do que acontece em outras linguagens, onde os arrays são ordenados e contínous, arrays em PHP exige um conjunto de funcionalidades para torna-se flexivel, porque “normalmente” estruturas de loop não lidam com o fato de que as chaves do array não precisam ser ordenadas, ou, para esse assunto, contínua. Considere, por exemplo, essa matriz simples:

$A = array(‘a’ => 10, 10 => 20, ‘c’ => 30);

É claro que nenhuma das estruturas de loop que examinamos até agora lhe permitirá percorrer os elementos do array, a menos, que você já sabiba exatamente as suas chaves, o que é, na melhor das hipóteses, uma grave limitação em sua habilidade de manipular um array genérico.

Arrays – Parte IX – Invertendo valores

Enviado por Filippe em 25 de novembro de 2010 nenhum comentário

Existem duas funções que têm nomes um tanto confusa e que às vezes são usadas de forma incorreta: array_flip() e array_reverse(). A primeira dessas duas funções inverte o valor de cada elemento de um array com a sua chave:

$a = array(’a’, ’b’, ’c’);
var_dump(array_flip ($a));

Será impresso:

array(3) {
["a"]=>
int(0)
["b"]=>
int(1)
["c"]=>
int(2)
}

Por outro lado, array_reverse() na verdade, inverte a ordem dos elementos da matriz, de modo que a última aparece em primeiro lugar:

$a = array(’x’ => ’a’, 10 => ’b’, ’c’);
var_dump(array_reverse($a));

Note que a associação da chave só perdeu para os elementos cujas chaves são numéricas:

array(3) {
[0]=>
string(1) “c”
[1]=>
string(1) “b”
["x"]=>
string(1) “a”
}

Arrays – Parte VIII – Contando, Pesquisando e Excluindo Elementos

Enviado por Filippe em 24 de novembro de 2010 nenhum comentário

Podemos obter o tamanho de um array utilizando a função count():

$a = array(1, 2, 4);
$b = array();
$c = 10;
echo count($a); // Resultado 3
echo count($b); // Resultado 0
echo count($c); // Resultado 1

Como você pode ver, a função count() não pode ser usada para verificar se uma variável contém um array, se for executado em um valor numérico, irá retornar um. A maneira correta de se verificar se uma variável é um array, é a utilizando a função is_array().

$a = array(1, 2, 4);
$b = 10;
echo is_array($a); // Resultado true
echo is_array($b); // Resultado false

Um problema similar existe quando tentamos descobrir se uma determinada chave existe no array. Isso geralmente é feito chamando isset():

$a = array(’a’ => 1, ’b’ => 2);
echo isset($a[’a’]); // Resultado  True
echo isset($a[’c’]); // Resultado  False

No entanto, isset() tem a grande desvantagem de considerar um elemento cujo valor é NULL, que é perfeitamente válido como inexistente:

$a = array(’a’ => NULL, ’b’ => 2);
echo isset($a[’a’]); // Resultado False

A maneira correta de determinar se existe um elemento no array é a utilização da função array_key_exists():

$a = array (’a’ => NULL, ’b’ => 2);
echo array_key_exists ($a[’a’]); // Resultado True

Obviamente, estas funções não lhe permitirá determinar se um elemento com um dado valor existe em um array, isto é, ao invés, realizado pela função in_array():

$a = array (’a’ => NULL, ’b’ => 2);
echo in_array ($a, 2); // Resultado True

Finalmente, um elemento pode ser excluído de um array usando a função unset():

$a = array (’a’ => NULL, ’b’ => 2);
unset ($a[’b’]);
echo in_array ($a, 2); // Resultado False

Arrays – Parte VII – Comparando arrays

Enviado por Filippe em 4 de outubro de 2010 nenhum comentário

Comparação de arays é um procedimento que ocorre raramente, mas pode ser realizado usando outro conjunto de operadores. Tal como para outros tipos, a identidade e a equivalência dos operadores podem ser usados para essa finalidade:

$a = array (1, 2, 3);
$b = array (1 => 2, 2 => 3, 0 => 1);
$c = array (’a’ => 1, ’b’ => 2, ’c’ => 3);

var_dump ($a == $b); // True
var_dump ($a === $b); // False
var_dump ($a == $c); // True
var_dump ($a === $c); // False

Como você pode ver, o operador de equivalência == retorna true se ambos os arrays têm o mesmo número de elementos com os mesmos valores e chaves, independentemente da sua ordem. Já o operador de identidade === , por outro lado, retorna verdadeiro somente se o array contém os mesmos valores e chaves na mesma ordem. Da mesma forma, a desigualdade e a não identidade podem determinar se dois arrays são diferentes:

$a = array (1, 2, 3);
$b = array (1 => 2, 2 => 3, 0 => 1);

var_dump ($a != $b); // False
var_dump ($a !== $b); // True

Mais uma vez, o operador de desigualdade só assegura que ambos os arrays contêm os mesmos elementos com os mesmos digitos, enquanto o operador de não-identidade também verifica a sua posição.

Arrays – Parte VI – Operações com arrays

Enviado por Filippe em 14 de agosto de 2010 nenhum comentário

Uma série de operadores se comportam de diferentes formas quando seus operandos são arrays. Por exemplo, o operador de adição “+” pode ser usado para criar a união de dois operandos:

$a = array (1, 2, 3);
$b = array (’a’ => 1, ’b’ => 2, ’c’ => 3);
var_dump ($a + $b);

Isso irá imprimir o seguinte:

array(6) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
["a"]=>
int(1)
["b"]=>
int(2)
["c"]=>
int(3)
}

Note como o array resultante inclui todos os elementos dos dois arrays originais, mesmo que tenham os mesmos valores, isto ocorre pelo fato das chaves dos dois arrays serem diferentes, se os dois arrays tiverem elementos comuns que partilham a mesma sequência chaves ou que têm as teclas numéricas (mesmo que sejam diferentes), eles só apareceram uma vez no resultado final:

$a = array (1, 2, 3);
$b = array (’a’ => 1, 2, 3);
var_dump ($a + $b);

O resultado será:

array(4) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
["a"]=>
int(1)
}

Arrays – Parte V – Revelando Arrays

Enviado por Filippe em 13 de agosto de 2010 nenhum comentário

Algumas vezes é mais simples de trabalhar com os valores de um array, atribuindo-lhes variáveis individuais. Enquanto isto pode ser feito extraindo elementos individuais e a atribuição de cada um deles para uma variável diferente, PHP fornece um atalho rápido, o construtor list():

$sql = “SELECT user_first, user_last, lst_log FROM users”;
$result = mysql_query($sql);
while (list($first, $last, $last_login) = mysql_fetch_row($result)) {
echo “$last, $first – Last Login: $last_login”;
}

Por usar o construtor list(), passando-se três variáveis, que estão ocupando os primeiros três elementos do array que foi atribuído a essas variáveis em ordem, permitindo-nos em seguida, utilizar esses elementos dentro do nosso loop while.

Arrays – Parte IV – Arrays multi-dimensionais

Enviado por Filippe em 12 de agosto de 2010 nenhum comentário

Como cada elemento de um array pode conter qualquer tipo de dado, a criação de array multi-dimensional é muito simples. Para criar, simplesmente atribui-se um array, como o valor, para um elemento de outro array. Com PHP, podemos fazer isso para um ou mais elementos dentro de qualquer array permitindo assim vários níveis de assentamento.

$array = array();
$array[] = array(
’a’,
’b’
);
$array[] = array(
’c’,
’d’
);
echo $array[0][1] . $array[1][0];

Nossa saída deste exemplo é “bc”. Como você pode ver, o acesso multi-dimensional a elementos do array se dar de uma forma simples, para isso, basta passar a chave para a especificar elemento que deseja acessar em cada nível.

Arrays – Parte III – Arrays enumerativos e associativos

Enviado por Filippe em 11 de agosto de 2010 nenhum comentário

Arrays podem ser divididos em duas categorias: enumerativa e associativos.

Enumerativa: As matrizes são indexadas usando apenas os índices numéricos.

Associativos: Permitem a associação de uma chave arbitrária para cada elemento.

No PHP esta distinção pode ficar um pouco confusa, porque, você pode criar uma matriz enumerativa e depois adicionar elementos associativos para ele (mantendo em uma enumeração). Além do mais, as matrizes se comportam mais como mapas e podem usualmente ser usadas para simular um número de estruturas diferentes, incluindo filas e pilhas.

O PHP fornece uma grande quantidade de flexibilidade na forma como chaves numéricas podem ser atribuídas a matrizes: eles podem ser qualquer número inteiro (negativo e positivo), e não necessariamente ser sequencial, de modo que uma grande lacuna pode existir entre os índices de dois valores consecutivos sem a necessidade de criar valores intermédios para cobrir sempre que possível as chaves entre os dois. Além disso, as chaves de um array não determinam a ordem dos seus elementos, como vimos anteriormente, quando criamos uma array com as chaves enumerativa que foram fora da ordem natural.

Quando um elemento é adicionado a um array sem especificar uma chave, o PHP automaticamente atribui um numérico que é igual a maior chave numérica já existente na matriz, mais um:

$a = array (2 => 5);
$a[] = ‘a’; // Esse irá ter a chave com o valor 3

Observe que isso é verdadeiro mesmo se o array contém uma combinação de chaves em sequência numérica:

$a = array (’4’ => 5, ’a’ => ’b’);
$a[] = 44; // Esse irá ter a chave com o valor 5

OBSERVAÇÃO: Note que as chaves da matriz são case-sensitive, mas de tipo insensível. Assim, a chave ‘A’ é diferente da chave ‘a’, mas as chaves “1″ e 1 são os mesmos. No entanto, a conversão só se aplica se uma chave string contém a representação tradicional decimal de um número, assim, por exemplo, a chave ’01′não é a mesma que a chave 1.