Filippe Brito
Em Busca da “Zend PHP Yellow Pages”
Funções – Parte II – Retornando Valores
May 19th
Todas as funções em PHP retornam valores, mesmo se você não informar o retorno. O conceito de função “vazia” não se aplica no PHP. Você pode especificar o valor de retorno da sua função usando a palavra-chave return.
function ola()
{
return “Olá mundo”; // Retorna uma string “Olá mundo”
}
$txt = ola(); // Atribui o valor de retorno “Olá mundo” para a variável $txt
echo ola(); // exibe “Olá mundo”
A palavra-chave return, também permite que você interrompa a execução de uma função, mesmo se você não quiser devolver um valor:
function ola($quem)
{
echo “Olá $quem”;
if ($quem == “mundo”) {
return; // Nada mais na função será processado
}
echo “, como vai você”;
}
ola(“mundo”); // exibe “Olá mundo”
ola(“leitor”) // Displays “Olá leitor, como vai você?”
Note, no entanto, que mesmo se você não retornar um valor, PHP ainda irá retornar da sua função um valor NULL.
Funções também podem ser declaradas para que elas retornem por referência, o que permite a você o retorno de uma variável como o resultado da função, em vez de uma cópia (uma cópia está retornando o padrão para cada tipo de dados exceto objetos).
Normalmente, isto é usado para coisas como recursos (como conexões de dados) e quando se aplica o padrão de fábrica. No entanto, há uma ressalva: você deve retornar uma variável, você não pode retornar uma expressão por referência, ou utilizar uma declaração vazia para forçar um retorno de valor NULL:
function &query($sql)
{
$result = mysql_query($sql);
return $result;
}
// A função seguir é errada e vai o PHP irá emitir um aviso de erro quando chamado.
function &getHello()
{
return “Olá mundo”;
}
// Isto também irá fazer com que o alerta seja emitido quando chamado.
function &teste()
{
echo ‘Este é um teste’;
}
Funções – Parte I – Sintaxe Básica
Jan 17th
A sintaxe de uma função básica é muito simples. Para criar uma nova função, nós simplesmente usamos a palavra-chave function, seguido por um identificador ou nome de função, um par de parênteses e chavetas, vejam o exemplo abaixo:
function nome() { }
Nome de funções no PHP não são case-sensitive. Tal como acontece com todos os identificadores em PHP, o nome deve consistir de letras (a – z), números e o caractere sublinhado, e não pode iniciar por um número.
Para sua função fazer alguma coisa, basta colocar o código a ser executado entre as chaves, então chamá-lo.
function ola()
{
echo “Olá mundo!”;
}
ola(); // será impresso “Olá mundo!”
Funções
Jan 16th
Apartir de hoje estaremos falando de funções que é o coração da programação PHP. Tem a capacidade de sintetizar qualquer pedaço de código de uma forma que pode ser chamado novamente, e novamente é inestimável, que é a base da estrutura processual da programação orientada para objeto.
Iremos centrar nossa atenção sobre os diversos aspectos da criação e gestão das funções dentro de scripts PHP, portanto, falaremos sobre como escrever funções, em vez de usá-las.
Erros – parte III – Erros de manipulação
Jan 15th
Seus scripts devem sempre ser capazes de recuperar de um erro, mesmo que esse erro seja apenas para informar o usuário do ocorrido. Desta forma, o script não irá finalizar inesperadamente, resultando em melhor comunicação com os usuários e evitando possíveis problemas.
Felizmente é muito fácil o tratamento do erro. Seus scripts podem declarar uma função “pega tudo”, que será chamada a função set_error_handler() pelo PHP quando uma condição de erro ocorrer, veja o exemplo abaixo:
$oldErrorHandler = ’’;
function myErrorHandler ($errNo, $errStr, $errFile, $errLine, $errContext) {
logToFile(“Erro $errStr no arquivo $errFile na linha $errLine”);
// Chame o oldErrorHandler
if ($oldErrorHandler) {
$oldErrorHandler ($errNo, $errStr, $errFile, $errLine, $errContext);
}
}
$oldErrorHandler = set_error_handler ($oldErrorHandler);
Como você pode ver, o nome da função do antigo manipulador de erros (se houver) será retornado pela chamada para set_error_handler(), pois isso permite-lhe juntar diversos tratadores de erro uns em cima dos outros, tornando assim possível ter dierentes funções tratando diferentes tipos de erros.
É importante manter em mente que seu manipulador de erro será completamente derivado do PHP. Assim o mecanismo de erro que será responsável por lidar com todos os erros, e parar a execução do script, se necessário.
A partir do PHP5, set_error_handler () suporta um segundo parâmetro que permite que você especifique os tipos de erros que um manipulador especial é responsável pela captura. Este parâmetro tem os mesmos valores constantes como o error_reporting () function.
Erros – parte II – Reportando Erros
Jan 14th
Depois de uma longa temporada sem escrever, estou retornando aos estudos, pois no fim de ano sabe como é? Muito trabalho e muita cerveja.
Por padrão, o PHP reporta qualquer erro que encontra na saída do script. A menos que você esteja em ambiente de depuração, sendo essa uma característica que raramente você vai querer pois ao exibir os erros dos seus scripts para os usuários, poderia ser gerado um grande problema de segurança.
Felizmente, várias diretivas de configuração podem ser ajustadas no arquivo php.ini, informando como e quais os erros serão relatados. Os mais importantes são error_reporting, display_errors e log_errors.
A directiva Error_reporting determina quais os erros são reportados pelo PHP. Por exemplo, o seguinte permite a comunicação de todos erros, exceto avisos:
error_reporting=E_ALL & ~E_NOTICE
Comunicação de erro também pode ser alterado dinamicamente a partir de dentro de um script chamando a
função error_reporting().
As diretivas display_errors e log_errors podem ser usadas para determinar como erros são relatados. Se display_errors está ligada, os erros são reportados quando ocorrem nos scripts. De modo geral, isso não é desejável em um ambiente de produção, porque todos serão capazes de ver os erros dos seus scripts. Sob essas circunstâncias, você vai querer ligar o log_errors, irá gerar um log com os registros de erros do servidor.
Erros – parte I – Erros e gerenciamento de erros
Aug 25th
Erros é uma parte integrada de qualquer linguagem de programação, embora, na maioria das vezes os programadores não queiram lidar com isso. PHP tem excelentes formas de tratamentos de erros, que proporcionam um controle detalhado sobre como os erros serão lançados, manipulados e comunicados.
Para começar falaremos sobre os tipos de erros. Existem vários tipos de erros, distribuídos em níveis:
| Erros em tempo de compilação | Os erros detectados pelo parser enquanto ele estiver compilando um script. |
| Erros fatais | Erros que interromper a execução de um script |
| Erros recuperados | Erros que representam falhas significativas, mas podem ser tratados de forma segura. |
| Advertências (Warnings) | Comunica erros que em tempo de execução. Não interrompe a execução do script. |
| Avisos (Notices) | Notifica que um erro ocorreu, mas esse erro não é necessariamente significativo. Não interrompe a execução do script. |
Como você pode ver, nem sempre é possível um script detectar e recuperar-se de uma falha. Com a exceção de analisar erros e erros fatais, no entanto, seu script pode ao menos ser avisados de que tenha ocorrido uma falha, dando-lhe a possibilidade de manipular erros de forma mais elegante.
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