Em Busca da “Zend PHP Yellow Pages”
Posts tagged php
Imprimindo Arrays
Jul 17th
Quando estudamos o básico do PHP, mostramos como o comando echo() pode ser usado para a saída de valores de uma expressão, incluindo a de uma única variável. Embora o echo() seja extremamente útil, ele apresenta algumas limitações que restringem sua utilidade em determinadas situações. Por exemplo, quando debugamos um script, muitas vezes precisamos ver não apenas o valor de uma expressão, mas também seu tipo. Outro problema com o echo() está no fato de que é incapaz de lidar com tipos de dados compostos, como matrizes e objetos.
Para evitar esse problema, o PHP fornece duas funções que podem ser usadas para imprimir o valor de uma variável recursivamente: print_r() e var_dump(). Eles diferem entre si em alguns poucos pontos:
- Embora ambas as funções imprimem recursivamente o conteúdo de valor composto, apenas var_dump() envia os tipos de dados de cada valor.
- Apenas var_dump() é capaz de reproduzir o valor de mais de uma variável ao mesmo tempo
- print_r() Só pode retornar a sua saída como uma string, em vez de escrevê-lo no padrão de saída do script.
Seja o echo(), var_dump() ou print_r(). Pode ser utilizado em qualquer dado o cenário, claramente, depende do que você esteja tentando alcançar. De um modo geral, o ECHO() abrange a maioria das suas bases, enquanto var_dump() e print_r() oferecem uma forma mais especializada de funcionalidades que funciona bem como um auxílio na depuração.
Básico sobre arrays
Jul 7th
Todos os Arrays são coleções ordenadas de itens com elementos chamados. Cada elemento tem um valor de identificador, e esse identificados é exclusivo para o array a que pertence. Como nos mencionamos no post anterior, as chaves ou identificadores podem ter números inteiros ou uma seqüência de tamanho indefinido.
Arrays podem ser criados de duas formas. A primeira seria chamando explicitamente o contrutor array(), que pode ser passada uma série de valores e, opcionalmente, as teclas:
$a = array (10, 20, 30);
$a = array (’a’ => 10, ’b’ => 20, ’cee’ => 30);
$a = array (5 => 1, 3 => 2, 1 => 3,);
$a = array();
A primeira linha do código acima, cria um array especificando apenas os valores dos seus três elementos. Como cada elemento de uma matriz também deve ter uma chave, PHP atribui automaticamente uma chave numérica para cada elemento, começando do zero.
No segundo exemplo, as chaves de matriz são especificados na chamada do construtor de array(), neste caso, três teclas alfabéticas (Note que o tamanho das teclas é arbitrária).
No terceiro exemplo, as chaves são atribuídas “Fora de ordem”, então o primeiro elemento do array tem, de fato, a chave com o valor 5. Aqui Você pode notar o uso de uma vírgula após o último elemento, que é perfeitamente legal de uma perspectiva sintática e não tem efeito sobre a matriz final.
Finalmente, no quarto exemplo, podemos criar uma matriz vazia.
Um segundo método de acesso a arrays é através do operador de array ([]):
$x[] = 10;
$x[’aa’] = 11;
echo $x[0]; // Será impresso 10
Como você pode ver, este operador oferece um grau muito maior de controle do array():
no primeiro exemplo, vamos adicionar um novo valor para a matriz armazenada na variável $x. Como não especificamos a chave, o PHP irá automaticamente escolher a chave numérica mais próxima disponível para os nós.
No segundo exemplo, por outro lado, especificamos a chave ‘aa’ no mesmo array. Note que, em ambos os casos, nós não inicializamos explicitamente $x como um array, o que significa que o PHP automaticamente irá convertê-lo para um nó de array, e se $x for vazio, ele simplesmente será inicializado com um array vazio.
Arrays
Jul 5th
Olá pessoal, mais um grande tempo sem postar aqui no blog, sempre com esperança de que um dia eu consiga postar semanalmente. hehehe…
Bom falaremos nos próximos dias sobre arrays, eles são os Reis incontestáveis das estruturas de dados avançados em PHP. matrizes são PHP extremamente flexíveis, que permitem numérico, teclas auto-incrementadas, teclas alfa numéricas ou uma mistura de ambos, e são capazes de armazenar praticamente qualquer valor, incluindo outras matrizes. Com mais de setenta funções para manipulá-las, matrizes podem fazer praticamente qualquer coisa que você possa imaginar.
Funções – Parte VI – Passar argumentos por referência
Feb 10th
Argumentos da função também podem ser passados por referência, prefixando com o operador de referência &. Isto permite sua função visualizar e alterar variáveis externas:
<?
function contarTodos(&$count)
{
if (func_num_args() == 0) {
die(“Você precisa especificar pelo menos um argumento.”);
} else {
$args = func_get_args(); // Retorna um array de argumentos
array_shift($args); // Remove o argumento definido no inicio.
$count = strlen ($arg1);
foreach ($args as $arg) {
$count += strlen($arg);
}
}
}
$count = 0;
contarTodos($count, “um”, “dois”, “três”);
echo $count; // será impresso 10
?>
Observação:
Isso é muito importante para você ficar sabendo, que as funções só aceitam variáveis para serem passadas por referência, você não pode passar uma expressão.
Ao contrário do PHP 4, PHP 5 permite que o valor padrão possa ser especificado, mesmo para os parâmetros quando forem declarados por referência:
function cmdExiste($cmd, &$saida = null) {
$saida = ‘onde $cmd’;
if (strpos($saida, DIRECTORY_SEPARATOR) !== false) {
return true;
} else {
return false;
}
}
No exemplo acima, o parâmetro $saída é totalmente opcional, se uma variável não for passada, uma nova será criada no âmbito do cmdExiste() e destruída quando a função retornar.
Funções – Parte V – Comprimento variável da lista de argumentos
Feb 9th
Um erro comum quando declarar uma função é a de escrever o seguinte:
function f ($opcional = “null”, $requerido)
{}
Isto não vai provocar alerta de erros, mas também não faz qualquer sentido, porque você nunca será capaz de omitir o primeiro parâmetro ($opcional) se você deseja especificar o segundo, e você não pode omitir o segundo, porque o PHP irá emitir um aviso.
Neste caso, o que você realmente quer é comprimento variável da lista de argumentos, ou seja, a capacidade de criar uma função que aceita um número variável de argumentos, dependendo sobre a circunstância. Um exemplo típico deste comportamento é exibido pela família de funções printf().
PHP fornece três funções internas para lidar com comprimento variável da lista de argumentos:
func_num_args(), func_get_arg() e func_get_args(). Aqui está um exemplo de como elas são utilizadas:
function ola()
{
if (func_num_args() > 0) {
$arg = func_get_arg(0); // O primeiro argumento é a posição 0
echo “Olá $arg”;
} else {
echo “Olá Mundo”;
}
}
ola(“Leitor”); // Exibe “Olá Leitor”
ola(); // Exibe “Olá Mundo”
Você pode usar o comprimento variável da lista de argumentos mesmo se você especificar argumentos no cabeçalho da função. No entanto, isso não irá afetar a forma como o comprimento variável da lista de argumentos irá se comportar, por exemplo, func_num_args() ainda retornará o número total de argumentos passados para a função, ambos declarados e anônimos.
function contarTodos($arg1)
{
if (func_num_args() == 0) {
die(“Você precisa especificar pelo menos um argumento.”);
} else {
$args = func_get_args(); // Retorna um array de argumentos
array_shift($args); // Remove o argumento definido no inicio.
$count = strlen ($arg1);
foreach ($args as $arg) {
$count += strlen($arg);
}
}
return $count;
}
echo contarTodos(“um”, “dois”, “três”); // Exibe ’10’
Observação importante:
É muito importante ter em mente que o comprimento variável da lista de argumentos estão cheios de potenciais armadilhas, enquanto eles são muito poderosos, eles tendem a tornar o código confuso, porque é quase impossível de se prever casos de teste global se uma função que aceita um número variável de parâmetros não é construído adequadamente.
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’;
}
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 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