Em Busca da “Zend PHP Yellow Pages”
Filippe
This user hasn't shared any biographical information
Posts by Filippe
Estruturas de controle – parte III – Parando e continuando
Aug 18th
A palavra-chave break, pode ser usada para sair de um loop, levando um parâmetro opcional, que permite a saída de vários loops:
$i = 0;
while (true) {
if ($i == 10) {
break;
}
echo $i . PHP_EOL;
$i++;
}
for ($i = 0; $i < 10; $i++) {
for ($j = 0; $j < 3; $j++) {
if (($j + $i) % 5 == 0) {
break 2; // Sairá dos dois loops.
}
}
}
OBS: Lembre-se sempre para encerrar uma declaração break usando ponto e vírgula (;) mesmo se não tiver nenhum parâmetro. Se você não fizer e por acaso ele for seguido de uma expressão que retorna um valor inteiro, você pode acabar causando uma saída aleatória do loop, causando todo o tipo de situações difíceis de solucionar.
Há casos em que, em ver de encerrar um ciclo, você quer simplesmente que ignore o restante de uma iteração e pule imediatamente para a próxima. Isto é feito com a palavra-chave continue. Por exemplo o código abaixo só irá imprimir os numero entre 0 e 3 e 6 e 9. Omitindo os números 4 e 5.
for ($i = 0; $i < 10; $i++) {
if ($i > 3 && $i < 6) {
continue;
}
echo $i . PHP_EOL;
}
Estruturas de controle – parte II – controle iterativo
Aug 10th
Com o controlador iterativo pode-se executar o mesmo trecho de código múltiplas vezes. PHP tem quatro destes, apesar de apenas dois deles são necessários para o funcionamento
de uma língua.
Os mais simples controladores iterativos são o while e o do … while eles permitem repetir uma série de operações até que avalia a condição verdadeira (TRUE):
$i = 0;
while ($i < 10) {
echo $i . PHP_EOL;
$i++;
}
$i = 0;
do {
echo $i . PHP_EOL;
$i++;
} while ($i < 10);
Como você pode ver, existem dois tipos de loops que são muito similares, a única diferença significante está em quando a condição é verificada para determinar se o código dentro do
controle deverá ser executado ou não. No while, a verificação é realizada a cada tempo de execução isto significa que, se a condição nunca for verdadeira, o código dentro do laço nunca será executado. Já no do … while, o controle é realizado no final de cada iteração significado que, mesmo que a condição de nunca for verdadeira (true), o conteúdo do loop será executado pelo menos uma vez.
O for e o foreach são mecanismos de looping especiais, eles podem ser usados essencialmente para encapsula um while por um período de tempo:
for ($i = 0; $i < 10;$i++) {
echo $i . PHP_EOL;
}
Como você pode ver, a declaração for contém três partes, separadas por ponto e virgula (;).
O primeiro contém uma instrução (de uma série de instruções separadas por um ponto e vírgula) que será executada uma vez antes do ciclo já começado. A segunda contém uma condição que é verificada no início de cada iteração do ciclo, e uma terceira instrução (ou, mais uma vez, um conjunto de instruções separados por vírgula) que é executado ao final de cada iteração. Portanto, o código acima seria equivalente a escrever o seguinte:
$i = 0;
while ($i < 10) {
echo $i . PHP_EOL;
$i++;
}
OBS: A constante PHP_EOL representa o marcador de fim de uma linha para o seu sistema em funcionamento atual.
Com os contrutores for e foreach, poderíamos percorrer um loop através de um array.
Veremos isso mais adiante.
Estruturas de controle – parte I – Estruturas Condicionais
Aug 9th
Estrutura condicional é usada para alterar o fluxo de uma execução baseado em uma ou mais condições. A maior parte destas estruturas básicas é o se-então-senão (if-then-else)que executa uma das duas declarações (ou conjuntos de declarações fechados em um bloco de código), dependendo se avalia a uma condição verdadeira ou falsa:
if (expressao1) {
} elseif (expressao 2) {
// Note que o espaço entre o else e o if é opicional
} else {}
Neste caso, se a expressao1 avaliar verdadeiro (true), o bloco de código imediatamente após será executado. Caso contrário, o interpretador tentara executar o conteúdo da outra opção da delaração. Note que você poderá encadeia vários se-então-senão (if-then-else) apartir do elseif para contruir outro bloco de ocorrência.
Naturalmente, estruturas se-então-senão (if-then-else)também poderão ser aninhadas.
if (expression1) {
if (expression2) {
// código
} else {
// Mais código
}
} else {
if (expression3) {
// Mais código.
}
}
Um operador ternário e especial permite embutir uma estrutura se-então-senão (if-then-else)dentro de uma expressão de declaração:
echo 10 == $x ? ’sim’ : ’não’;
O código acima seria equivalente ao seguinte:
if (10 == $x) {
echo ’sim’;
} else {
echo ’não’;
}
Como você pode ver, a antiga expressão é muito menor, mais deve se alertar sobre o seu uso. Se usada em excesso, pode tornar seu código de difícil compreensão e comprometer sua funcionalidade, principalmente se você começar a aninhar varias dessas operações entre si.
O problema com os se-então-senão (if-then-else) é que eles tendem a ser bastante complicado quando você precisa verificar uma expressão simples com vários possíveis
resultados. Imagine, por exemplo, a não tão incomum situação em que você tem relacionadas uma série de se-então-senão (if-then-else)como a seguinte:
$a = 0;
if ($a) {
// Avalia se falso (false)
} elseif ($a == 0) {
// Avalia se verdadeiro (true)
} else {
// sera executado se não for encontrado em nenhuma das outras opções.
}
Há vários problemas aqui. Primeiro você tem que escrever um monte de código, que é difícil para manter e compreender. Em segundo lugar, o valor de $a será avaliado todas as vezes até encontra uma condição que o satisfaça, neste caso, não é um grande problema, mas se fosse necessário avaliar uma expressão complexa? Para diminuir este problema, PHP pode construir um interruptor:
$a = 0;
switch ($a) { // nesse caso $a sera uma expressão
case false: // Compara com falso (false)
break;
case true: // Compara com verdadeiro (true)
break;
case 0: // Compara com 0
break;
default:
// sera executado se não for encontrado em nenhuma das outras opções.
break;
}
Uma declaração switch avalia a primeira expressão ($a neste caso) apenas uma vez, e depois compará-lo contra os valores caso individual; se uma correspondência é encontrada, ela continuará executando o código até que se depara com uma declaração de pausa. Note que o uso de pausa (break) é necessário ou o intérprete vai continuar executando o código mesmo que este esteja em outro bloco de código. Finalmente, se nenhum dos casos de teste for encontrado, o intérprete executa o código em um bloco padrão (default).
Estruturas de controle
Aug 8th
Estrutura de controle permite que você controle o fluxo do script. Afinal, se todos os scripts fossem percorridos do inicio ao fim sem o controle de que parte seria executada e quantas vezes, escrever um programa seria impossível.
PHP disponibiliza um grande número de diferentes estruturas de controle, incluindo algumas que, apesar de ser redundante, simplifica significativamente o seu desenvolvimento. Você deve ser muito familiarizado com todos eles, pois são um dos elementos fundamentais de diversas da linguagem estruturada.
Estaremos dividindo estrutura de controle em outros 3 posts, que são:
- Estruturas condicionais
- Controle iterativo
- Parando e continuando
Final da parte sobre operadores do php básico
Aug 8th
Terminamos a sessão de 10 posts sobre operadores, abaixo estaremos listando todos eles:
- Operadores – Parte I
- Operadores – Parte II – Operadores Aritméticos
- Operadores – Parte III – Operador de concatenação de String
- Operadores – Parte IV – Operadores de Bits
- Operadores – Parte V – Operadores de atribuição
- Operadores – Parte VI – Referenciado variáveis
- Operadores – parte VII – Operadores de comparação
- Operadores – parte VIII – Operadores Lógicos
- Operadores – parte IX – Outros operadores
- Operadores – parte X – Operadores de precedência e associatividade
Operadores – parte X – Operadores de precedência e associatividade
Aug 7th
Nem todas as regras obedecem à mesma ordem de precedência. Podendo, algumas vezes, uma operação ser realizada fora de ordem. Este problema pode ser resolvido de duas maneiras: usando parênteses para indicar quais operações deve ser realizada em primeiro lugar, ou usando um conjunto de regras pré-definidas de precedência.
Mesmo estabelecendo a prioridade de uma determinada operação, ainda faltaria uma coisa importante: como vamos decidir a ordem que as operações serão executadas quando possuírem a mesma precedência? Isto será determinado por uma operação da associatividade, que podem ser esquerda (onde as operações serão realizadas da esquerda pra direita), direita (onde as operações serão executadas da direita pra esquerda) ou nenhum (para as operações que não podem se associar). A tabela a seguir mostra a precedência e a associatividade de cada operação:
| Esquerda | [ |
| Não associada | ++ - |
| Não associada | ! ˜ – (int) (float) (string) (array) (object) @ |
| Esquerda | * / % |
| Esquerda | + – . |
| Esquerda | << >> |
| Não associada | < <= > >= |
| Não associada | == != === !== |
| Esquerda | & |
| Esquerda | ^ |
| Esquerda | | |
| Esquerda | && |
| Esquerda | || |
| Esquerda | ? : |
| Direita | = += -= *= /= .= %= &= |= ˆ= <<= >>= |
| Esquerda | and |
| Esquerda | xor |
| Esquerda | or |
| Esquerda | , |
Operadores – parte IX – Outros operadores
Aug 6th
Alem de todos os operadores que vimos até aqui, também existem alguns especializados para simplificar determinadas tarefas. Um deles é o operador de suprimir erros “@” quando precedida a uma expressão, esse operador ignora quase todas as mensagens de erro enquanto a expressão estiver sendo executada:
$x = @mysql_connect();
O código acima irá impedir a chamada a função mysql_connect() caso exista algum erro encontrado.
Outro operador torna possível executar um comando da Shell e recuperar sua saída. O exemplo a seguir fará com que a saída do comando ls do UNIX seja armazenada no interior da variavel $a:
$a = ‘ls -l‘;
Operadores – parte VIII – Operadores Lógicos
Aug 5th
Operadores lógicos são usados para ligar valores booleanos em conjunto e obter um terceiro valor booleano em função das duas primeiras. Existem quatro operadores lógicos em PHP das quais três são binárias. O único operador unário é o NÃO Lógico, identificado por uma exclamação antes do operando:
$a = false;
echo !$a; // será impresso 1 (true)
É importante compreender que todos os operadores lógicos trabalham apenas com valores booleanos. por isso, o PHP irá converter primeiro para valor Booleano e, em seguida, executar a operação.
Os três operadores binários são:
| && / AND | Retornará true caso os operandos da direita E esquerta do operador retornem true. |
| || / OR | Retornará true caso um dos operandos o da direita OU o da esquerda retornar true. Podendo ser ambos. |
| XOR | O ou exclusivo retornará true se o um dos operandos o da direita OU o da esquerda retornar true, mais não ambos. |
É importante saber que o PHP tem uma simples estratégia para avaliar os resultados. Por exemplo, se a esquerda do operando && (AND) a operação for avaliada como false. Automaticamente será retornado false, já que qualquer outro resultado não mudará essa condição.
Operadores – parte VII – Operadores de comparação
Jul 31st
São operadores que estabelecem uma relação de equivalência entre dois valores. Eles tanto podem determinar se dois valores são iguais (ou não iguais) entre si, ou se um é maior (ou menor) do que o outro. O resultado de uma operação comparação é sempre um valor Booleano.
Existem quatro operadores de equivalência:
| == | Equivalentes. Verifica se os dois operandos são equivalentes, o que significa que eles podem ser convertidos para o tipo de dados comum que eles têm o mesmo valor, mais não necessariamente do mesmo tipo. |
| === | Identidade. Verifica se os operandos possuem o mesmo Tipo e têm o mesmo valor. |
| != | Não Equivalentes. Verifica se os dois operandos são não equivalentes, sem verificar o seu tipo. |
| !== | Operador não-idênticos. Verifica se os dois operandos não possuem o mesmo tipo de dados ou não têm o mesmo valor. |
É muito fácil confundir o operador de atribuição (=) pelo operador de comparação (==) e este é, na verdade, um dos erros mais comuns na programação. Uma solução parcial para este problema é utilizar um padrão de projetos em que o programador inverte a ordem de seus operandos quando se compara uma variável com valor. Por exemplo, em vez de:
echo $a == 10;
Você poderia escrever:
echo 10 == $a;
Estas duas operações são totalmente idênticas, mas, devido à esquerda operador ser um valor, se tivesse esquecido de um dos sinais iguais, o parser teria jogado um erro, assim, alertando-o para o seu erro.
Outros conjuntos de diferentes operadores estabelecem uma relação de desigualdade entre os dois operandos, ou seja, se um dos dois é maior do que o outro:
| < | Retorna true se o operando da esquerda for menor que o da direita. |
| <= | Retorna true se o operando da esquerda for menos ou igual ao da direita. |
| > | Retorna true se o operando da esquerda for maior que o da direita. |
| >= | Retorna true se o operando da esquerda for maior ou igual ao da direita. |
Embora o processo seja claro para os números, as coisas mudar um pouco para outros tipos de dados, por exemplo, strings são comparadas através da análise do valor binário de cada byte na seqüência até dois valores diferentes são encontrados, o resultado é então determinado pelo valor numérico desses dois bytes. Por exemplo:
$esquerda = “ABC”;
$direita = “ABD”;
echo (int) ($esquerda > $direita);
O código acima imprime 0 (ou seja, falso), porque a letra D é mais elevado na variável da direita, do que na letra C da variável da esquerda. Enquanto você pode poderia pensar que esta comparação ocorre por causa da ordem alfabética. Considere, os seguintes exemplos:
$esquerda = ’maça’;
$direita = ’Maça’;
echo (int) $esquerda > $direita;
Neste exemplo será impresso 1 (verdadeiro), pois o valor ASCII do caractere “a” é 97 que por sua ver é mais elevado que o caractere “A” que é 65.
OBS: A utilização de operadores comparação com arrays também introduz um conjunto de regras diferentes. Veremos mais adiante.
Operadores – Parte VI – Referenciado variáveis
Jul 21st
Por padrão, os operadores trabalham pela atribuição de valor, ou seja, eles copiar o valor de uma expressão para outra. Se do lado direito do operando for uma variável, somente seu valor será copiado, de modo que qualquer alteração subseqüente ao da esquerda do operador não será refletindo no operador da direita. Por exemplo:
$a = 10;
$b = $a;
$b = 20;
echo $a; // será impresso 10
Normalmente, você espera que esse seja o resultado obtido, mais a casos em que você queira uma tarefa que o resultado seja obtido por referência, de modo que a expressão da esquerda do operando torna-se “ligado” com a expressão da direita. Por exemplo:
$a = 10;
$b = &$a; // por referência
$b = 20;
echo $a; // será impresso 20
OBS: O operador trabalha pela atribuição de valor para todos os tipos de dados, exceto objetos, os quais sempre são passados por referência, independentemente do operador “&” ser usado ou não.
A utilização de variáveis por referência usada algumas vezes pode ser até útil, mas sempre será uma técnica PHP bastante arriscada, porque variáveis PHP tendem a permanecer ativas por um longo período de tempo, até mesmo dentro de uma função. Além disso, contrariamente ao que acontece em muitas outras línguas, essa tecnica muitas vezes é mais lenta do que a atribuição de valor, porque o PHP usa uma inteligente “deferred-copy” mecanismo que otimiza a realidade de valor atribuições.