Bitly-PHP – Lançada a versão 1.2

Olá pessoal!


$easter = 'Páscoa';
echo sprinf("Feliz %s ! astrasado =(" , $Easter);

Semana passada falei um pouco sobre o meu novo projeto open-source, o Bitly-PHP. Para quem ainda não sabe, o Bitly-PHP é uma nova forma de você interagir com a API RESTful do Bitly. A library permite que você encurte, descubra a url longa, receba informações e estatísticas completas sobre um link encurtado.

Sobre a versão 1.2

Depois do dia em que lancei a primeira versão do Bitly-PHP. Comecei a ouvir a comunidade PHP. Abri tópicos em listas e pedindo por sugestões. O feedback da comunidade foi muito bom. As pessoas realmente gostaram do que viram e o resultado foi isso que estamos vendo agora. A versão 1.2 do Bitly-PHP.

O que mudou?

Para os que estão utilizando desde primeira versão, não se preocupe. Se você baixar a nova versão o seu código continuará funcionando. Todas as alterações foram levando em conta as pessoas que já estavam utilizando.

Na versão 1.0 para você encurtar uma url você podia fazer da seguinte forma:

<?php
$bitlyphp = new Bitly();
$bitlyphp->login = '<your_login>';
$bitlyphp->api_key = '<your_api_key>';
$bitlyphp->url = 'http://blog.igorescobar.com';
$bitlyphp->shorten();
echo $bitlyphp->getData()->shortUrl; // Imprime a url encurtada.
?>

Na versão 1.2 você pode reduzir estas linhas para duas.

<?php
$bitlyphp = new Bitly( '<your_login>', '<your_api_key>');
echo $bitlyphp->shorten('http://blog.igorescobar.com'); // Imprime a url encurtada.
?>

Mais prático, não?

As parâmetros mais básicos e obvios foram encapsulados dentro do próprio método reduzindo o tempo gasto para o usuário que queria fazer algo que não fuga do simples “encurtar urls”.

Mas o método:

print_r( $bitlyphp->getData() );

Continua valendo caso você queira acessar um dado mais específico.

O que mais mudou?

  • Agora Bitly-PHP está também, disponível no PHP Classes.
  • Todos os comentários dentro da library do Bitly-PHP foram re-escritos em inglês.
  • Todos os exemplos dados na Wiki do Bitly-PHP foram re-escritos e simplificados para as alterações que vieram com a versão 1.2.
  • 2 bugs foram corrigidos.

Posts Relacionados:

Encurtando URLs com o Bitly-PHP

Sobre o Bitly-PHP

Nos últimos dias tenho trabalhado em uma library em PHP (claro) para abstrair as funcionalidades da API RESTful do Bit.ly . Se chama Bitly-PHP. Toda a library foi desenvolvida utilizando PHP5, Orientação a Objetos, Naming Convention e cURL (se não tiver ele usa uma função alternativa).

Download e Documentação

Você pode fazer o download da library direto na pagina do Bitly-PHP no GitHub. Todos os outros exemplos de uso da library você encontra direto no Wiki do Bitly-PHP.

Se você tem o git na sua máquina você pode executar o comando:

git clone git://github.com/igorescobar/Bitly-PHP.git

Encurtando URLs

O primeiro que você deve fazer é incluir a arquivo que contém a library do Bitly-PHP:

include_once("Bitly-PHP/bitly.php");

Depois é muito simples. Você só precisa instanciar o objeto do Bitly PHP, informar a URL que quer encurtar, invocar o método responsável por encurtar as URLs, o shorten.

include_once("Bitly-PHP/bitly.php");
$bitly  = new Bitly();
$bitly->url = 'http://www.google.com/';
$bitly->shorten();

O Bitly-PHP possuí um método responsável por acessar os dados que a API do Bit.ly retorna chamado getData().

include_once("Bitly-PHP/bitly.php");
$bitly  = new Bitly();
$bitly->url = 'http://www.google.com/';
$bitly->shorten();
$bitly->getData()->shortUrl; // Saída: http://bit.ly/b6R4Uf

Se você não sabe qual o nome do parametro que você quer chamar, chame o metodo debug():

include_once("Bitly-PHP/bitly.php");
$bitly  = new Bitly();
$bitly->url = 'http://www.google.com/';
$bitly->shorten();
$bitly->debug();

O debug vai mostrar:

{
    "errorCode": 0, 
    "errorMessage": "", 
    "results": {
        "http://www.google.com/": {
            "hash": "2V6CFi", 
            "shortCNAMEUrl": "http://bit.ly/b6R4Uf", 
            "shortKeywordUrl": "", 
            "shortUrl": "http://bit.ly/b6R4Uf", 
            "userHash": "b6R4Uf"
        }
    }, 
    "statusCode": "OK"
}

É isso!

[]‘s

Posts Relacionados:

Inscreva o seu grupo na Zend

A Zend anúnciou ontem no seu perfil do facebook que irá criar uma área no portal zend.com com o intuito de divulgar os grupos de usuários PHP. Não importa de que país e localidade seja o seu grupo de usuários php. Se você quiser divulgar o seu grupo no site oficial da Zend. Envie um e-mail para localphp[arroba]zend.com com as seguintes informações:

Nome do Grupo
Localização do Grupo (Pais e Estado)
Informações para contato
Site
Uma Logo
Curta descrição do grupo.

É uma boa notícia. Ter o seu grupo reconhecido pela empresa responsável pelo desenvolvimento da linguagem PHP é um ótimo empurrãozinho para o seu grupo crescer. Boa Sorte!

[]‘s
Igor.

Posts Relacionados:

Benchmarking de desempenho de código no PHP

Antes de mais nada, Benchmarking é o nome pomposo dado às práticas adotadas na indústria (não importa qual) que visam alcançar um desempenho/qualidade superior. Ou seja, Benchmarking é todo tipo de prática cujo objetivo é melhorar/maximizar/amplificar os resultados.

No artigo de hoje vamos abordar benchmarking focado em código, desempenho especificamente. Não é meu objetivo neste artigo aprofundar sobre profiling etc. Existem muitas práticas de benchmarking que podem ser utilizadas para poder alcançar algum tipo de amplificação na sua área, porém não daria para falarmos detalhadamente de todas em um único artigo.

Quando desenvolvemos aplicações para Internet e o stress da aplicação será muito grande (como um todo), temos que ter cuidado, muito cuidado. Conhecer mais de uma forma de se implementar uma única solução pode ser o que vai salvar o seu pescoço.

Benchmarking de código – na prática

Muitas vezes, quando estamos meditando para solucionar um problema, precisamos saber se aquela implementação é rápida. Mas, como assim, rápida? Como eu vou saber se uma determinada implementação de código/função é rápida o suficiente de forma que supra as necessidades sem comprometer a qualidade de modo geral do sistema?

Vale lembrar que o método que vou mostrar aqui faz com que os resultados variem de máquina para máquina, pois é tudo uma questão de processamento. Os resultados aqui apresentados são apenas para ILUSTRAR e SIMULAR para atingirmos resultados significantes.

Este é o seu momento “MythBusters”.

Descobrir qual é a forma mais rápida de se resolver um problema é uma tarefa simples (nem sempre), em determinados casos, não temos um parâmetro para saber se devemos seguir pelo caminho A ou B, tudo o que nos resta é saber várias formas de se codificar/implementar uma determinada solução e medir o desempenho de todas elas, cada trecho, para assim, resolver o problema.

Vou dar um exemplo de como se medir o desempenho de uma implementação de código, levando em conta um problema que tivemos aqui no trabalho.

Tivemos que desenvolver um framework adhoc (free style) onde nós conseguíssemos obter resultados semelhantes a alguns frameworks bem comuns na Internet como Code Igniter, Cake PHP etc. MVC, Inflector, ActiveRecord, Rotas de Urls etc.

Agora vem a pergunta na cabeça de vocês:
- Por que re-inventar a roda?

A empresa que pediu para que a gente re-inventasse a roda, alegou que estes são frameworks não “oficiais”, e são feitos/mantidos por pessoas em que eles não confiam (untrusted or non certified application).

Resumindo? Eles queriam ver como a “coisa” era implementada, para poder, assim, atingir o melhor desempenho e retirando tudo o que eles não precisam da aplicação, tornando-a mais leve.

A grande questão?

O aquivo ActiveRecord.class.php está demorando muito para terminar o seu serviço, quando você instanciava uma nova classe, a dita cuja tinha um modelo, que, por sua vez, também possuía um controle onde possuía todas as regras do negócio.

Sempre que executássemos uma método da classe por ex ->find, findFirst ou findAll ele retornava um array de objetos, ou seja, era um array e todas as suas posições eram compostas por objetos e suas respectivas propriedades (atributos).

Exemplo

Array
(
    [0] => Usuarios Object
        (
            [nome] => Igor Escobar 1
            [email] => blog@igorescobar.com
        )

    [1] => Usuarios Object
        (
            [nome] => Igor Escobar 2
            [email] => blog@igorescobar.com
        )

    [2] => Usuarios Object
        (
            [nome] => Igor Escobar 3
            [email] => blog@igorescobar.com
        )

)

Era mais ou menos assim que ele retornava os usuários de uma determinada tabela. Este é um array de objetos com apenas 3 elementos, mas para você ter um resultado para que possamos simular um resultado no benchmarking mais expressivo, você precisa de um array de objetos com mais elementos, pois iria exigir mais do processador, etc. No nosso experimento vou aumentar este array de objetos para 10.000 elementos e veremos quanto tempo ele demora para fazer o trabalho.

Medindo o desempenho (do trecho)

Criei uma class de exemplo, apenas para conseguirmos a estrutura vista acima:

<?php
public class Usuarios {
	var $nome;
	var $email;
}
?>

Agora, eu crio a implementação para atingir o resultado esperado:

$arraUsuarios = array();
for($i = 1 ; $i <= 10000; $i++):
	$obUsuarios = new Usuarios();
	$obUsuarios->nome = "Igor Escobar {$i}";
	$obUsuarios->email = "blog@igorescobar.com";
	$arraUsuarios[] = $obUsuarios;
endfor;

Para medir o desempenho exatamente no trecho que queremos, eu utilizo a função microtime() do php.

$time_start = microtime(true);
$arraUsuarios = array();
for($i = 1 ; $i <= 10000; $i++):
	$obUsuarios = new Usuarios();
	$obUsuarios->nome = "Igor Escobar {$i}";
	$obUsuarios->email = "blog@igorescobar.com";
	$arraUsuarios[] = $obUsuarios;
endfor;
$time_end = microtime(true);
$Benchmarking1 = ($time_end - $time_start);
echo "Array de Objetos levou: " . $Benchmarking1 . " microsecondos<br />\n";
//Output: Array de Objetos levou: 0.04233980178833 microsecondos

Agora vamos criar uma outra implantação, ao invés de retornarmos uma array de objetos, vamos retornar um array de arrays, ou seja, seria uma array com n posições e todas as suas propriedades seriam INDICES do array e não mais atributos do objeto.

Exemplo

Array
(
    [0] => Array
        (
            [nome] => Igor Escobar 1
            [email] => blog@igorescobar.com
        )

    [1] => Array
        (
            [nome] => Igor Escobar 2
            [email] => blog@igorescobar.com
        )

    [2] => Array
        (
            [nome] => Igor Escobar 3
            [email] => blog@igorescobar.com
        )

)

O mesmo script, apenas montando de maneira diferente (array de arrays), ficou assim:

$time_start = microtime(true);
$arraUsuarios = array();
for($i = 1 ; $i <= 10000; $i++):
	$arraUsuarios[] = array (
			'nome' => "Igor Escobar {$i}",
			'email' => 'blog@igorescobar.com'
		);
endfor;
$time_end = microtime(true);
$Benchmarking2 = ($time_end - $time_start);
echo "Array de Arrays levou: " . ($Benchmarking2) . " microsecondos<br />\n";
//Output: Array de Arrays levou: 0.036391973495483 microsecondos

Qual método é mais rápido?

// Se resultado for negativo: Método 1 é mais rápido
// Se resultado for positivo: Método 2 é mais rápido
echo "Resultado: " . ($Benchmarking1 - $Benchmarking2);
//Output: Resultado: 0.007580041885376

Viram? Duas formas de fazer a mesma coisa e a segunda forma é 0.007580041885376 microsegundos mais rápida.

Conclusão

Neste simples teste, podemos tirar a seguinte conclusão: neste caso, utilizar a minha estrutura de retorno como um array de objetos é mais lento do que trabalhar com um array de arrays. Este é um teste fora da realidade, quanto mais próximo da realidade a complexidade do dia-a-dia, este número aumenta, tende a ser cada vez maior.

Veja que este exemplo não envolve conexão com banco de dados, acrescente todo o stress que envolve validação de regras de negócio, segurança, consistência e etc., e veja este número crescer MUITO mais.

Vale lembrar que eu não estou dizendo para vocês não, nunca mais, utilizarem objetos, porque não é isso, estou apenas ilustrando que NESTE CASO, foi mais rápido, e mais interessante para o projeto que o retorno desta função fosse um array de arrays, é tudo uma questão de escolher entre mysql_fetch_assoc, mysql_fetch_array, mysql_fetch_object ou mysql_fetch_row, cada uma tem suas características e são válidas dependendo da sua necessidade em questão.

Você pode aplicar isso em “tudo” na sua aplicação, até para saber quanto tempo uma determinada função demora para terminar seu trabalho basta utilizar o microtime() no começo e no final da função e subtrair os valores do maior para o menor.

$time_start = microtime(true);
//nome da função
$time_end = microtime(true);

E é isso, pessoal, espero que tenham gostado. Certamente, se vocês utilizarem este recurso para o seu crescimento profissional, será de muita valia para vocês.

Fonte Completo

<?php
class Usuarios {
	var $nome;
	var $email;
}

$time_start = microtime(true);
$arraUsuarios = array();
for($i = 1 ; $i <= 10000; $i++):
	$obUsuarios = new Usuarios();
	$obUsuarios->nome = "Igor Escobar {$i}";
	$obUsuarios->email = "blog@igorescobar.com";
	$arraUsuarios[] = $obUsuarios;
endfor;
$time_end = microtime(true);
$Benchmarking1 = ($time_end - $time_start);
echo "Array de Objetos levou: " . $Benchmarking1 . " microsecondos<br />\n";

$time_start = microtime(true);
$arraUsuarios = array();
for($i = 1 ; $i <= 10000; $i++):
	$arraUsuarios[] = array (
			'nome' => "Igor Escobar {$i}",
			'email' => 'blog@igorescobar.com'
		);
endfor;
$time_end = microtime(true);
$Benchmarking2 = ($time_end - $time_start);
echo "Array de Arrays levou: " . ($Benchmarking2) . " microsecondos<br />\n";

// Se resultado for negativo: Método 1 é mais rápido
// Se resultado for positivo: Método 2 é mais rápido
echo "Resultado: " . ($Benchmarking1 - $Benchmarking2);

?>

[]‘s
Igor.

UPDADE: Este artigo foi reformulado devido a muitas dúvidas e questionamentos referentes a este meu método. Obrigado a todos que ajudaram no amadurecimento do conteúdo.

Posts Relacionados:

PHPSecInfo – PHP Security Consortium

PHPSecInfo

O PHPSecInfo é um projeto da própria PHP Security Consortium cujo objetivo é próoor uma melhor configuração do ambiênte visando sempre a segurança e estabilidade do mesmo.

O PHPSecInfo funciona muito parecido com a função php_info() do php. Ela lê, analiza e oferece algumas sugestões caso alguma diretiva esteja configurada fora do padrão de segurança que se deve ter em um ambiênte de produção.

Instalação

Não precisa instalar nenhuma extensão nem nada do tipo, basta jogar a pasta do projeto no local de sua preferência e acessa-la via browser.

[]‘s
Igor.

Posts Relacionados:

Proteção contra o SQL Injection

Olá a todos, desculpem pela ausência, por algum motivo (algo relacionado com o Speedy) eu não estava conseguindo acessar o meu blog o que me impossibilitava de escrever, i’m sorry.

Hoje vou falar um pouco sobre como funciona o SQL Injection e como podemos proceder para que nós não sejamos pegos por este tipo de vulnerabilidade.

O que é SQL Injection?

SQL Injection é uma técnica de injeção de código que explora uma vulnerabilidade de segurança localizada na camada de banco de dados (database layer) do servidor. Na prática é utilizada por hackers (ou não) para ter acesso ao banco de dados do servidor da vítima sem que ele precise de um login ou uma senha efetivamente para fazê-lo.

Como funciona o SQL Injection?

Para entendermos melhor como funciona os ataques via injeção de códigos SQL (SQL Injection), vou utilizar um caso bem comum entre os programadores para que vocês se familharizem com mais facilidade.

Pense em um formulário para login no sistema e uma consulta na base de dados para verificar se determinado usuário e senha existe em na base de dados.
Exemplo
SELECT usuario,senha FROM usuarios WHERE usuario = 'igorescobar' AND senha='123456'

O ataque acontece justamente no ponto, aonde o usuário preenche o usuário e a senha no formulário de login do site. Se você não filtra todos os dados que vem de FORA para DENTRO da sua aplicação, você corre o risco de ser atacado.

Na prática o código fica algo parecido com isso:
SELECT usuario,senha FROM usuarios WHERE usuario = '$usuario' AND senha='$senha';

Estas variáveis ($usuario e $senha) estão vindo do $_POST do seu formulário e o servidor iria interpretar assim:
SELECT usuario,senha FROM usuarios WHERE usuario = 'igorescobar' AND senha='123456';

Agora imagine que eu sou um usuário mal intencionado e desejo logar no servidor de vocês sem ser autorizado.

No campo senha vou inserir o seguinte conteúdo:
123456' OR 'a'='a

Vamos ver como fica?
SELECT usuario,senha FROM usuarios WHERE usuario = 'igorescobar' AND senha='123456' OR 'a'='a';

Hun… como diria eu mesmo (há!): F-U-D-E-U!

Quer outro exemplo? … um mais bacana?

Agora no campo senha eu vou inserir o seguinte conteúdo:
123456'; DROP TABLE usuarios; --

Vamos ver como fica?
SELECT usuario,senha FROM usuarios WHERE usuario = 'igorescobar' AND senha='123456'; DROP TABLE usuarios; --';

Ok, agora você já esta pronto para passar no RH :)

Oh my god :O como eu me protejo dos ataques SQL Injection ?

Primeiro: Separe sempre a exibição de erros em 2 ambientes, o ambiente de desenvolvimento e o ambiente de produção. O ambiênte de desenvolvimento pode ter qualquer tipode erro emitido na tela, afinal, você precisa ver os erros para tratá-los, no ambiênte de produção omita qualquer tipo de erro, qualquer erro pode ser uma pista para o hacker descobrir detalhes sobre o seu ambiênte.

Ambiente de Desenvolvimento

<?php error_reporting(E_ALL ^ E_NOTICE);  ?>

Ambiente de Produção

<?php error_reporting(0);  ?>

Segundo: Filtre todo o tipo de variável dados que veem de urls ou inputs de formulário $_GET ou $_POST para que nenhum dos dados inputados pelo usuário possa ser interpretado como parte da instrução SQL.

Vale lembrar que o certo seria utilizarmos PDO que já tem uma proteção definitiva contra isso, pois ele tem o acesso ao modelo do seu banco de dados e pode fazer muito melhor do que uma simples filtrarem generica nos campos, ele pode filtrar cada campo dependendo do tipo de cada campo o que é muito melhor.

Caso você não use PDO, você pode utilizar também uma função chamada mysql_real_escape_string que também cumpre o que promete.

Solução definitiva para o SQL Injection
Está solução é válida apenas para as pessoas que não utiliza nenhuma das 2 (duas) soluções citadas acima.

<?php

/**
 * Protege o banco de dados contra ataques de SQL Injection
 *
 * Remove palavras que podem ser ofensivas à integridade do banco
 * Adiciona barras invertidas a uma string
 *
 * @uses $_REQUEST= _antiSqlInjection($_REQUEST);
 * @uses $_POST = _antiSqlInjection($_POST);
 * @uses $_GET = _antiSqlInjection($_GET);
 *
 * @author Igor Escobar
 * @email blog [at] igorescobar [dot] com
 *
 */

function _antiSqlInjection($Target){
	$sanitizeRules = array('OR','FROM','SELECT','INSERT','DELETE','WHERE','DROP TABLE','SHOW TABLES','*','--','=');
	foreach($Target as $key => $value):
		if(is_array($value)): $arraSanitized[$key] = _antiSqlInjection($value);
		else:
			$arraSanitized[$key] = (!get_magic_quotes_gpc()) ? addslashes(str_ireplace($sanitizeRules,"",$value)) : str_ireplace($sanitizeRules,"",$value);
		endif;
	endforeach;
	return $arraSanitized;
}

?>

Terceiro: Não tem, só estes 2 passos está bom ;)

ps: Desculpem as piadas, estou de bom humor hoje :)

UPDATE(1): Acrescentei algumas palavras na blacklist da função
UPDATE(2): Troquei o str_replace para o str_ireplace e acrescentei a verificação de magic_quotes.
UPDATE(3): Retirei a função trim por não fazer diferença alguma rs.

[]’s
Igor.

Posts Relacionados:

Convertendo HTML para PDF em PHP

Hoje vamos entender como efetuar a conversão de um documento (X)HTML padrão para um documento PDF válido utilizando a biblioteca DOMPDF.

Instalando o DOMPDF

1. Faça o download do DOMPDF no site oficial da biblioteca. A versão que vou utilizar neste tutorial é a versão 0.5.1

2. Descompacte os arquivos do DOMPDF em um local acessível pelo seu servidor web.

3. Abra e edite o arquivo dompdf_config.inc.php.

  • Se você deixar o DOMPDF_PDF_BACKEND com o valor `auto`, o dompdf vai utilizar a extensão PDFLib se ela estiver instalada no seu servidor, caso contrário o dompdf vai utilizar a R&OS CPDF class (é uma biblioteca para criação de documentos PDF sem a necessidade da instalação de uma extensão adicional).
  • Dê permissão de escrita no caminho que aponta a variável DOMPDF_FONT_DIR (lib/fonts é o padrão).

4. Pronto!

Utilizando o DOMPDF

Vou dar um exemplo simples de utilização da biblioteca. Seguindo este exemplo, você consegue fazer tudo o que precisa para geração de arquivos PDF.

<?php
      $html = '
      <html>
      <head></head>
      <style>
      h1 {color:#333; size:20px; margin-bottom:5px;}
      h3 {color:#222;}
      </style>
      <body>
     
     <h1>IgorEscobar.com</h1>
     <h3>Desenvolvimento, Tecnologia e Informação, na ponta do lápis.</h3>
     
     </body>
     </html>';

     require_once("dompdf/dompdf_config.inc.php");
      
     $dompdf = new DOMPDF();
     $dompdf->load_html($html);
     $dompdf->set_paper('letter', 'landscape');
     $dompdf->render();
     $dompdf->stream("exemplo-01.pdf");
?>
  • O objeto load_html é responsável por receber o conteúdo HTML e fazer a conversão.
  • O objeto set_paper é responsável pela configuração do papel (formato) do arquivo pdf. No primeiro argumento, você escolhe o tamanho de cada folha; no segundo argumento, você escolhe se quer cada folha em paisagem ou fotografia.
  • No Parâmetro 1 você pode preencher com:4a0, 2a0, a0…a10, b0…b10, c0…c10, ra0…ra4, sra0…sra4, letter, legal, ledger, tabloid, executive, folio, commerical #10 envelope, catalog #10 1/2 envelope, 8.5×11, 8.5×14 e11x17.
  • No Parâmetro 2 você pode preencher com: portrait ou landscape.
  • O objeto render é responsável por imprimir, no documento, o código correspondente ao PDF e exibi-lo no browser.
  • O objeto stream é opcional. Se ele for setado, vai forçar o download do documento com o nome que você passar, caso contrário o documento será exibido na tela.

Resultado Final

DOMPDF 01DOMPDF 01

Dicas

  • Caso você precise gerar um documento PDF muito grande, é provável que o apache reclame do limite de memória. Para contornar este problema, basta aumentar a capacidade de memória alocada. Para isso é preciso alterar o memory_limit com a função ini_set do php. (ex: ini_set(“memory_limit”, “16M”); ).
  • O DOMPDF não funciona com todas as fontes. As fontes que são suportadas por ele podem ser encontradas em lib/fonts. Caso necessite instalar novas fontes, no site do oficial da biblioteca você pode encontrar maiores informações.
  • Caso você não consiga que as suas folhas de estilo sejam carregadas no corpo do pdf, coloque as regras diretamente no corpo do documento. Se mesmo assim não funcionar, coloque as regras utilizando a propriedade style em cada tag do html setando as mesmas, diretamente.

É isso, pessoal!

Posts Relacionados:

16 técnicas smarty scripting para deixar seus templates ainda mais inteligentes

Uma compilação de dicas e técnicas muito úteis para se programar em Smarty Template Engine e construir dinâmicos e inteligentes templates para programadores PHP e designers de templates. Uma ótima fonte para quem está começando a codificar Smarty Templates. Tenho certeza que economizará muito tempo de procura.

1. Re-utilização de código HTML

Utilize a tag {caption} para gravar dentro de uma variável qualquer saída de html que estiver entre o {caption} e o {/caption}. É muito útil quando queremos re-utilizar o mesmo código em vários pontos do nosso template.

No exemplo abaixo estamos atribuindo toda a saída HTML para a variável $nav:

{capture name='nav'}
<ul>
{section name=item loop=$nav}
  <li><a href="{$nav[item].url}" title="{$nav[item].title}">{$nav[item].label}</a></li>
{/section}
</ul>
{/capture}

Mostra o conteúdo da caption $nav:

{$smarty.capture.nav}

Você pode também setar a saída da caption para uma variável de template:

{capture name='nav' assign='navmenu'}

Para exibir:

{$navmenu}

Quando o “name” não é especificado, o nome da caption automaticamente é setado como “default”:

{$smarty.capture.default}

2. Passando variáveis para sub-templates

Usando $GLOBALS via {php}, para nós, programadores, resolve o problema, certo? Mas é recomendado pelos designers de template que vocês utilizem o {capture}. Os designers de templates não querem colocar as suas mãos em código PHP, então, vamos falar em uma linguagem que eles também entendam.

Arquivo header.tpl

{capture name='columns'}3{/capture}

Então, arquivo index.tpl

{include file='header.tpl'}
{if $smarty.capture.columns == '3'}
. . .
{/if}
{include file='footer.tpl'}

Pode até mesmo acessar a variável dentro do footer.tpl

{if $smarty.capture.columns == '3'}
. . .
{/if}

3. Incluindo sub-templates utilizando delimitadores padrão

Aqui temos um problema comum quando queremos inserir variáveis de template dentro de arquivos javascript ou CSS. o Delimitador { e } é utilizado por ambas linguagens, então, vamos ter conflitos.

main.tpl

$smarty = new Smarty;
$smarty->left_delimiter = '<!--{';
$smarty->right_delimiter = '}-->';
$smarty->assign('size', '36px');
$smarty->assign('pre', 'Great');
$smarty->assign('post', 'Templates');
$smarty->display(message.tpl');

message.tpl

<style type="text/css">
<!--
h2 {font-size: <!--{$size}-->}
-->
</style>
<h2>Welcome to the World of <!--{$pre|capitalize}--> Smarty  <!--{$post|capitalize}--></h2>
<script language="javascript" type="text/javascript" >
<!--
function welcome(){
  alert('Welcome to the World of <!--{$pre|capitalize}--> Smarty  <!--{$post|capitalize}-->');
}
welcome();
-->
</script>

O código acima mostra o texto “Welcome to the World of Great Smarty Templates” com uma fonte de tamanho 26px e alerts com o mesmo texto.

4. Debugando Smarty Templates

O Smarty tem um console para debug que permite que você facilmente examine variáveis de template, templates incluídos, e variáveis de configuração para o template atual.

Para ativar o console de debug, defina a propriedade $debugging do smarty como true:

<?php
$smarty = new Smarty;
$smarty->debugging = true;
...
?>

Se a janela do debug console não abrir quando a página for carregada, sete a propriedade $debug_tpl para o seu caminho path. Por padrão, Smarty vai olhar para o “debug.tpl” no SMARTY_DIR. Este arquivo é incluído nas distribuições do Smarty e pode ser achado na pasta “libs/”.

O jeito mais fácil e mais rápido para habilitar o debugging console é colocando a tag {debug} nos seus templates. Funciona da mesma forma. No entanto, Isso só permite visualizar todas as variáveis disponíveis dentro do escopo do template atual.

Exemplo:

<h1>{$title}</h1>
{debug}
<p>{$description}</p>

5. Acessando Request Variables via Smarty Templates

Request Variables do PHP podem ser acessadas via templates Smarty, utilizando a variável reservada {$smarty}. Request Variables, incluindo $_GET, $_POST, $_COOKIE, $_SERVER, $_ENV, e $_SESSION.

Exemplos:
Valor de saída da variável $_GET['page'] da URL

{$smarty.get.page}

Valor de saída da variável $_POST['page'] do formulário

{$smarty.post.page}

Saída de uma variável de cookie, $_COOKIE['status']

{$smarty.cookie.status}

Saída de uma variável de servidor, $_SERVER['SERVER_NAME']

{$smarty.server.SERVER_NAME}

Saída de uma variável do ambiente do seu sistema, $_ENV['PATH']

{$smarty.env.PATH}

Saída de uma variável de sessão, $_SESSION['id']

{$smarty.session.id}

Saída da variável “username” de todos os arrays juntos (get/post/cookies/server/env)

{$smarty.request.username}

6. Acessando variáveis de templates via script PHP

Você consegue acessar variáveis do smarty utilizando o método get_template_vars() no seus scripts PHP. No entanto, as variáveis de template só estão disponíveis depois do tempo de execução e interpretação dos seus templates. Depois deste trabalho, as variáveis são diretamente incorporadas para serem acessadas via PHP utilizando a tag {php} ou incluindo um arquivo php utilizando uma tag de função built-in {include_php}.

Considere o seguinte template:

{assign var='title' value='Smarty Templates'}

Acessando as variáveis depois da execução do template:

// Executa o template e retorna o resultado para uma variável
$page = $smarty->fetch('index.tpl');

// Vai mostrar "Smarty Templates"
echo $smarty->get_template_vars('title');

// Assina um valor para a variável title
$smarty->assign('title', 'The Great Smarty Templates');

// Vai mostrar "The Great Smarty Templates"
echo $smarty->get_template_vars('title');

// Vai exibir todas as variáveis assinadas dentro do template
var_dump($smarty->get_template_vars());

Existem dois jeitos de acessar variáveis de tamplate durante a execução do template utilizando a tag {php}:

{php}
// using $this->_tpl_vars
echo $this->_tpl_vars['title'];

// using $this->get_template_vars() method
// the variable $this, is a smarty object
echo $this->get_template_vars('title');
{/php}

7. Substituição de variaveis em strings com aspas duplas

Funciona muito parecido com o jeito que você faz em PHP quando existem variáveis dentro de aspas duplas e exibir os seus respectivos valores dentro dentro destas aspas.

Substituição simples

Com o $filename tendo o valor “footer”, o atributo file vai apresentar o valor “templates/footer.tpl”.

{include file="templates/$filename.tpl"}

O código acima não funciona com aspas simples:

{include file='templates/$filename.tpl'}

Array Indexes

Assumindo que $module[1] contém “user_menu”:

O $module[1] acima vai ser substituído por “user_menu” e será traduzido dentro de “user_menu.tpl”.

{include file="$module[1].tpl"}

Com o valor de $index igual a 1, o código abaixo vai fazer algo parecido com o código de acima. Neste caso anexo a backticks.

{include file="`$module[$index]`.tpl"}

Associative Arrays

Assumindo que $item['name'] seja igual a “Computer”:

A variável $item.name abaixo vai ser substituido de “Computer” para “Computer unit”.

{assign var='label' value="`$item.name` unit"}

Com o valor de $prop igual a “name”, o que temos a seguir é equivalente ao código anterior.

{assign var='label' value="`$item.$prop` unit"}

Objects

Temos uma propriedade dentro de um objeto chamada $book->title que contém “Smarty Templates”.

O $book->title acima vai assumir o valor de “Smarty Templates” mas $msg tem o valor “My Smarty Templates book”.

{assign var='msg' value="My `$book->title` book"}

Com a $property igual a “title”, $msg vai apresentar o mesmo valor.

{assign var='name' value="`$book->$property`"}

Nota: Sempre anexe nomes de variáveis com (`) quando elas conterem pontos (.), objetos por referência (->), ou quando usarem index variables para arrays.

8. Manuseando variáveis de template em branco

Variáveis em branco podem quebrar o layout da sua tabela. Variáveis com valores em branco podem ser um problema em muitos casos, por exemplo, se alguma imagem do seu layout vier de uma variável de template, imagine esta imagem recebendo o src em branco toda vez que alguém acessa sua página? Muitas requisições perdidas, sem motivo?

Use a tag {if} para gerar uma saída padrão sempre que uma variável estiver em branco. Ou use o atalho, A variável modificadora “default”.

Considerando o código a seguir, exibirá dentro da célula de uma tabela:

<table><tr><td>
{if $user eq ''}
   
{else}
  {$user}
{/if}
</td></tr></table>

O shortcut:

<table><tr><td>{$user|default:' '}</td></tr></table>

Esse é o código que maniputa a propriedade src do img:

<img src="{if $image_url eq ''}/images/default.png{else}{$image_url}{/if}" />

Ou simplesmente:

<img src="{$image_url|default:'/images/default.png'}" />

O shortcut pode ser bem limpo olhando assim, somente neste tutorial, mas se você tiver o hábito de usar SEMPRE nos seus templates, ao longo do tempo isso pode ser meio “feio” de ser ver.

Por exemplo, considerando o código abaixo:

<a href="{$image_url|default:'/images/default.png'}">
<img src="{$image_url|default:'/images/default.png'}" />
</a>
<p>Path: {$image_url|default:'/images/default.png'}</p>

E, finalmente, aqui está um método bem mais limpo utilizando a tag {assign} com default.

{assign var='image_url' value=$image_url|default:'/images/default.png'}
<a href="{$image_url}">
<img src="{$image_url}" />
</a>
<p>Path: {$image_url}</p>

9. Passando variáveis para sub-templates

É muito comum para os web developers e web designers colocarem conteúdos repetitivos em templates separados e {include} (incluir) eles como necessários. Um exemplo típico é o header.tpl que inclui a tag html title etc. Suponhamos que precisaremos dele para exibir diferentes títulos em diferentes paginas dependendo da página que é incluída. Você consegue fazer isso, utilizando o atributo “title” da tag {include}, e é assim que passamos variáveis para sub-templates no Smarty.

Exemplo de tamplate que inclui o header.tpl com o parâmetro “title”.

{include file='header.tpl' title='Welcome!'}
{include file='footer.tpl'}

No header.tpl

<html>
<head>
<title>{$title|default:'Smarty World'}</title>
</head>
<body>

No footer.tpl

</body>
</html>

10. Formatando saídas numéricas

Você não precisa assinar várias variáveis com os mesmos valores em diferentes formatos, porque o smarty possui um modificador de variáveis que possibilita você formatar a saída de uma variável sem modificar seu conteúdo. “string_format” usa a mesma formatting syntax do sprintf() function do PHP.

Exemplo:

{$number}
{$number|string_format:'%.2f'}
{$number|string_format:'%d'}

Com o $number igual a 23.5787446, o código acima vai mostrar:

23.5787446
23.58
24

11. Manipulação de Datas

A regra da tumba é PHP coders sempre vão passar datas para o Smarty como timestamps. Isso permite que os designers de template utilizar o “date_format” modifier para o controle total sobre a formatação da data. Você pode também facilmente compará-las se quiser.

date format Padrão:

{$createDate|date_format}

Saída:
Feb 28, 2009

date format Customizado:

{$createDate|date_format:'%Y/%m/%d'}

Mostra:
2009/02/28

Comparando datas:

{if $startDate < $endDate}
  . . . faça alguma coisa . .
{/if}

Para converter a saída do {html_select_date} para o formato timestamp do PHP, use a função a seguir:

<?php
function makeTimeStamp($year='', $month='', $day='')
{
   if(empty($year)) {
       $year = strftime('%Y');
   }
   if(empty($month)) {
       $month = strftime('%m');
   }
   if(empty($day)) {
       $day = strftime('%d');
   }

   return mktime(0, 0, 0, $month, $day, $year);
}
?>

12. Obfuscando endereços de e-mail

Quando você exibe endereços de e-mail em suas páginas, tenha certeza de que estes estão obfuscados para os spam bots não fazerem a festa com eles. No Smarty, você pode usar a {mailto} tag para obfuscar qualquer endereço de e-mail. Functiona de forma que você incorpora o endereço de e-mail via javascript, logo, o mesmo não aparece via código HTML se você exibir o código fonte.

Exemplo

<div id="contact">Entre em contato pelo e-mail:
{mailto address=$emailAddress encode='javascript' subject='Hi Smarty'}
</div>

13. Alternando estilos CSS

É comum possuirmos em nosso sistema tabelas, onde cada linha aparece de cor diferente para facilitar a leitura e a localização da informação. No Smarty, utilizando o {cycle} tag você consegue alternar por exemplo o fundo de suas células a cada siclo de um laço de repetição.

Aqui vai um código que alterna entre as classes css “odd” or “even”.

<table>
{section name=item loop=$items}
  <tr class="{cycle values='odd,even'}">
    <td>{$items[item].title}</td>
    <td>{$items[item].description}</td>
  </tr>
{/section}
</table>

14. Buscando e Apresentando Conteúdo On Demand

Tradicionalmente, adicionamos componentes PHP dentro do próprio conteúdo para que esta tarefa seja possível, porém, isso requer um pouco de lógica e de mais afinidade com o PHP. Por outro lado, removendo componentes do seus templates requer um pouco de lógica de programação para que você consiga otimizar suas rotinas em busca de um melhor desempenho

Possívelmente a manutenção para estes tipos de templates pode ser um verdadeiro pesadelo para projetos mais longos e mais complexos, especialmente quando o programador PHP e o template designer são duas pessoas diferentes.

A solução é escrever componentes (functions) que são executadas on demand (quando requisitadas) pelo template.

Existem dois caminhos para se escrever on demand scripts:

  • Use a tag {insert}

Funciona como se estivessemos chamando uma função pré definida pelo programador. Essas funções começam sempre com “insert_” e insere o retorno das funções dentro do template onde a tag {insert} é colocada. A tag é útil para exibir conteúdos dinâmicos porque o conteúdo nunca é cachgeado regularmente.

O código PHP:


require 'Smarty.class.php';
$smarty = new Smarty;
$smarty->display('index.tpl');

function insert_getNews($params)
{
  if ($params['type'] == 'latest') {
    // recebe as notícias e processa
  }
  // retorna o resultado
  return $html;
}

O template, chamado “index.tpl”:

<div class="news">
<h3>Latest Smarty News</h3>
{insert name='getNews' type='latest'}
</div>
  • Escreva componentes como plugins

Plugin é um modulo que existe dentro do Smarty que contém scripts PHP para buscar e exibir dados necessários e assiná-los dentro de variáveis de template. É sempre carregado on demand, sendo assim, você não precisa se preocupar a respeito de adicionar ou remover linhas de lógica dos seus scripts para otimizá-los.

Como exemplo, aqui vai um simples plugin para notícias:

function.news.php observe o naming convention e coloque o arquivo dentro do diretório de plugins, geralmente “smarty/libs/plugins” de outra maneira set o $plugins_dir.

// function para receber as notícias
function fetch_news($symbol)
{
  // o news items pode ser recebido pelo banco de dados
  // mas para este exemplo, eu só criei um array para simular o retorno.
  $items = array(
  array('title'=>'Smarty News', 'description'=>'Great Smarty Templates'),
  array('title'=>'PHP News', 'description'=>'Smarty Templating Engine'),
  );
  return $items;
}

function smarty_function_news($params, &$smarty)
{
  // chamando nossa função personalizada
  $news = fetch_news($params['symbol']);

  // assinando como uma variavel de template
  $smarty->assign($params['assign'], $news);
}

Para usar o plugin Smarty News no seu index.tpl:

{news symbol='SMARTY' assign='items'}
<ul>
{section name=item loop=$items}
  <li><h3>{$items[item].title}</h3><p>{$items[item].description}</p></li>
{/section}
</ul>

15. Utilizando Códigos CSS e Javascript Dentro de Templates Smarty

Por padrão, Smarty divide tudo que esta dentro de { e } incluindo os utilizados pelas regras CSS e funções Javascript.

Existem quatro caminhos para escapar da divisão do Smarty:

1. Separe seus arquivos CSS e Javascript em arquivos separados de forma que você possa incluí-los dentro do seu template utilizando os métodos padrão do HTML.

Incluindo o estilo CSS:

<link rel="stylesheet" href="style.css" type="text/css />

Incluindo arquivos Javascript:

<script type="text/javascript" src="popup.js"></script>

2. Adicione a tag {literal} no início e no fim {/literal} de códigos CSS ou Javascript que estejam incorporados ao seu documento, assim, o Smarty vai deixar tudo o que estiver entre o {literal} e {/literal} em paz.

CSS Incorporado:

<style type="text/css">
<!--
{literal}
p {text-indent: 10pt}
body {margin:0; padding:0;}
{/literal}
-->
</style>

Javascript Incorporado:

<script language="javascript" type="text/javascript" >
<!--
      {literal}
      function hello_world(){
        alert('Hello Smarty World');
      }
      {/literal}
-->
</script>

3. Mude o Smarty $left_delimiter e $right_delimiter de forma que os delimitadores não se confundam com os delmitadores de outras linguagens. Além disso, isso possibilita que você insira variáveis de template dentro de arquivos CSS e Javascript dinâmicamente.

O Código PHP:

<?php
      require 'Smarty.class.php';

      $smarty = new Smarty;

      $smarty->left_delimiter = '<!--{';
      $smarty->right_delimiter = '}-->';

      $smarty->assign('title', 'The Smarty Template Engine');
      $smarty->assign('element', 'h1');
      $smarty->assign('size', '36px');
      $smarty->assign('popup', 'alert');
      $smarty->display('index.tpl');
?>
[/php]

<strong>O Smarty Template "index.tpl":</strong>
1
<head>
<style type="text/css">
<!--
<!--{$element}--> {font-size: <!--{$size}-->}
-->
</head>
<body>
<<!--{$element}-->><!--{$title}--></<!--{$element}-->>
<script language="javascript" type="text/javascript" >
<!--
        function show_popup()
        {
                <!--{$popup}-->('<!--{$title}-->');
        }
//-->
</script>
</body>

O código acima vai mostrar:

<head>
<style type="text/css">
<!--
h1 {font-size: 36px}
-->
</head>
<body>
<h1>The Smarty Template Engine</h1>
<script language="javascript" type="text/javascript" >
<!--
function show_popup()
{
        alert('The Smarty Template Engine');
}
//-->
</script>
</body>

4. Use {ldelim} e {rdelim} no lugar de { and } na definição das regras dos seus arquivos css e na hora de escrever funções javascript.

Exemplo, arquivos CSS:

<style type="text/css">
<!--
      p {ldelim}text-indent: 10pt;{rdelim}
      body {ldelim}margin:0; padding:0;{rdelim}
-->
</style>

Mostrará:

<style type="text/css">
<!--
      p {text-indent: 10pt;}
      body {margin:0; padding:0;}
-->
</style>

16. Caching Smarty Templates

Caching aumenta a velocidade em metodos do tipo display() e fetch() salvando a saída destes metodos em arquivos separados. Vale lembrar que o cache somente é utilizado se o conteúdo não mudou. Set $caching = 2 e utilize o $cache_lifetime para controlar quanto tempo o cache da informação deverá ser matido para depois então ser atualizado.

Ativando o cache:

<?php
      require 'Smarty.class.php';
      $smarty = new Smarty;

      // Quando $caching = 1,
      //   $cache_lifetime = 1 força o cache para nunca expirar
      //   $cache_lifetime = 0 vai sempre regenerar o cache
      // Quando $caching = 2,
      //   $cache_lifetime seta a vida do cache, mas o mesmo pode ser setado para templates individuais.
      $smarty->caching = 2; // lifetime é para cada cache

      // Regenera o conteúdo cacheado se nenhum template ou arquivo de configuração for parte do cache que estiver sendo modificado.
      $smarty->compile_check = true;

      // $smarty->force_compile = true; vai forçar o cache ser sempre regenerado

      // assume o cache_lifetime para o template index.tpl para 5 minutos
      $smarty->cache_lifetime = 300;
      $smarty->display('index.tpl');

      // assume o cache_lifetime para o template home.tpl para uma hora
      $smarty->cache_lifetime = 3600;
      $smarty->display('home.tpl');
?>

Duas coisas que devem ser consideradas quando implementamos caching:

  1. Não é recomendado colocar o diretório de cache abaixo da pasta raiz do servidor. Set $cache_dir para um diretório que não seja acessível via web.
  2. Tenha certeza de que o diretório do cache tem permissão de escrita no servidor.

Enfim, concluímos. 16 Técnicas Smarty Scripting para deixar seus templates ainda mais inteligentes para o seus projetos Web Smarty.

Para qualquer outra coisa, visite o site oficial do Smarty Template Engine para o PHP.

Se você tem alguma outra dica que não foi incluída aqui, sinta-se à vontade para incluí-la nos comentários.

Este artigo é uma tradução/adaptação do artigo 16 Very Useful Smarty Scripting Tips and Techniques to Make Templates Smarter.

Posts Relacionados:

Como debugar aplicações AJAX/PHP com FirePHP

Tradicionalmente, existem duas maneiras de se debugar uma aplicação server-side: você pode utilizar qualquer uma Integrated Development Environment (IDE) com algum build-in debugger ou registrar seus processos de depuração exibindo no próprio browser.

Neste artigo veremos uma forma elegante, simples e mais sustentável de se debuggar aplicações Ajax via browser (especificamente o Mozilla Firefox). Você vai aprender a turbinar o seu Firefox unindo o Firebug e o FirePHP, tornando-o uma elegante ferramenta de depuração.

Introdução

Quando técnicas como Ajax se tornam populares nos ambientes de desenvolvimento, é comum que junto surjam também novos desafios, por exemplo: como podemos debuggar requisições e respostas Ajax de forma eficiente para aplicações complexas?

Se utilizar um debugger foi difícil o suficiente com um modelo RESTful, interceptar uma requisição ajax específica é um saco e um pouco mais difícil. Geralmente o dumping de logs e informações destas transações devem ser feitas via JSON ou XML.

É aqui que o FirePHP ajuda, permitindo que você registre suas mensagens de debug dentro do console do Firebug. O FirePHP não faz uma bagunça no seu código (e não exige que você modifique nada para pegar erros). As mensagens que você imprime são enviadas para o browser através de HTTP response headers, ou seja, as suas mensagens de debug não vão “quebrar” as respostas das suas requisições com mensagens e erros de debug e fazendo parar de funcionar toda a sua aplicação. A resposta vem limpa e todo o processo de depuração vem catalogado no console do Firebug. Isso faz com que o FirePHP não seja só o aplicativo ideal para você debugar suas aplicações PHP, mas também o seu PHP codebase inteiro.

O que é o FirePHP?

O FirePHP é um add-on para um add-on (ahn?): ele estende o popular Firebug. O FirePHP é grátis e fácil de instalar através da seção Mozilla Add-Ons no site oficial da Mozilla. O site oficial do FirePHP pode ser encontrado neste endereço: www.firephp.org,e Christoph Dorn é a pessoa responsável pela criação do FirePHP.

O que eu preciso para iniciar?

Como você deve ter adivinhado, são necessáriastrês coisas para fazer com que o FirePHP funcione, são elas:

  1. Firefox
  2. Firebug
  3. FirePHP

Se você não tem um ou todas as aplicações listadas acima, você pode clicar no link respectivo de cada uma delas e receber instruções de como instalá-las de forma adequada.

Se você está começando agora a estudar um pouco mais sobre web development, o FirePHP pode ser um pouco “manhoso” no começo, mas o projeto é acompanhado por uma boa documentação e você pode aprender facilmente.

Instanciando a API OO

No seu script, você pode utilizar o bloco de código abaixo para instanciar o FirePHP ($firephp):

require_once('FirePHPCore/FirePHP.class.PHP');
$firephp = FirePHP::getInstance(true);
$firephp -> [classmethod];

Instanciando a API OO com os métodos estáticos

Esse é o formato como você deve chamar os métodos do FirePHP:

require_once('FirePHPCore/fb.PHP');
FB::[nameofmethod];

A API Procedural

E aqui está como se utiliza a API procedural do FirePHP:

require_once('FirePHPCore/fb.PHP');
fb($var);
fb($var, 'Label');
fb($var, FirePHP::[nameofmethod]);

Nós não vamos entrar em detalhes com relação aos benefícios em utilizar cada uma das APIs, cabe a você decidir a melhor forma para VOCÊ. Em outras palavras, eu não quero iniciar uma guerra para decidir qual é a melhor forma, procedural x orientada a objetos. It’s up to you.

Gravando mensagens no Firebug Console

Agora vamos detalhar as formas como você pode lidar com o Console do Firebug.

Exemplos básicos de log de mensagens

Se você está debugando um bug, o exemplo a seguir pode ser útil para você:

Fb::log("log message");

Isso vai imprimir a mensagem que você passou como parâmetro dentro do console do Firebug:

Fb::log($array, "dumping an array");

Passando um array (chega de print_r nos seus scripts) e mostrando o seu conteúdo. O exemplo acima vai mostrar a seguinte saída no seu console:

Dica: Quando você passar o mouse em cima das mensagens que foram logadas no seu console, uma janela aparece com todas as variáveis logadas, tudo tabulado de forma legível para desenvolvedor. Legal, né?

Registrando uma mensagem de Informação

Aqui vai uma forma de você exibir mensagens informativas no console:

Fb::info("information");

E o seu console exibirá assim:

Mensagens de Aviso

Segue aqui uma forma de você gravar mensagens de aviso:

Fb::warn("this is a warning");

Mensagens de Erro

Segue aqui uma forma de você gravar mensagens de Erro:

Fb::warn("error message");

Habilitando/Desabilitando o registro de logs no Console

Quando o seu site vai para o ar é muito importante que você desabilite o FirePHP para evitar que a pessoa errada veja a informação certa na hora errada (rs).

FB::setEnabled(false);

O bom de tudo isso é que você pode manter todo o código que você escreveu para debugar o seu código dentro do código, sem que você precise tirá-lo ou comentá-lo quando for para o ar. Se a sua aplicação possui um arquivo de configuração, é interessante criar uma variável dentro dele que através da qual você consiga habilitar e desabilitar o FirePHP.

Conclusão

Antes de tudo, aqui vai uma imagem com todas as mensagens possíveis de se utilizar no FirePHP:

Neste artigo, cobrimos coisas bem básicas de se fazer utilizando o FirePHP para ajudar você a debugar e ganhar informações sobre as suas requisições nas suas aplicações Ajax/PHP de forma fácil e sustentável no seu próprio browser. Eu espero que estes resultados tenham convencido você a explorar outras alternativas para debugar seu código fora da “old-school” techniques (echo’s print’s etc.). Usar o FirePHP é fácil e conveniente, dá a você muito mais opções e dados para propósitos de debug.

No futuro, pretendo cobrir recursos mais complexos do FirePHP para fazer desta simples ferramenta de debug uma ferramenta poderosa, completa e robusta.

[]‘s

Posts Relacionados:

Projeto BoletoPHP

Pequeno desabafo.

Eu sou uma cara bastante antenado, leio muito e estou frequentemente me atualizando, principalmente nas coisas que surgem por aí (não vou me aprofundar muito nesta questão). Não posso acreditar que até hoje, eu nunca tenha visto nenhum texto ou qualquer palavra de apoio para este projeto que se iniciou em 2006. Me senti na obrigação de divulgar para você este projeto Open-Source mantido e coordenado por Elizeu Alcantara. Uma iniciativa que achei muito bacana e vale o meu apoio. O Projeto se chama BoletoPHP.

Projeto código aberto de sistema de boletos bancários em PHP

Este projeto é mantido e coordenado por Elizeu Alcantara desde Maio/2006 e teve origem do Projeto BBBoletoFree, que teve colaborações de Daniel William Schultz e Leandro Maniezo, que por sua vez foi derivado do PHPBoleto de João Prado Maia e Pablo Martins F. Costa.

Qual o principal motivo deste projeto?

Criar um sistema de geração de Boletos que seja mais simples do que o PhpBoleto e que se estenda ao desenvolvimento de boletos dos bancos mais usados no mercado, além do Banco do Brasil do projeto BBBoletoFree. Este sistema é de Código Aberto e de Livre Distribuição conforme Licença GPL.
Ele visa atender exclusivamente aos profissionais e desenvolvedores na área técnica de programação PHP dos boletos, portanto se faz necessário conhecimento desejado e estudo do mesmo para a perfeita configuração do boleto a ser usado, sendo de inteira responsabilidade do profissional a instalação, o funcionamento, os testes e a compensação do mesmo em conta bancária, pois não damos suporte técnico, portanto mensagens enviadas a nós com dúvidas gerais, técnicas ou solicitações de Suporte não serão respondidas.

O projeto BoletoPhp não tem foco na questão administrativa, comercial ou jurídica, pois isto compete exclusivamente aos bancos devido as suas particularidades existentes de cada carteira de cada boleto. Maiores informações sobre o conceito de Boleto de Cobrança, você pode acessar aqui o site da Wikipédia.

Faça parte desta revolução e colabore com este projeto

Todos os voluntários terão seus nomes publicados na área de Créditos do site e do sistema, para valorizar os profissionais que sabem a importância de ter uma ferramenta com Código Aberto como esta em suas mãos e para os seus negócios e para os seus clientes, pois da mesma forma que você foi ajudado, você também pode estar retribuindo com 30 minutos do seu tempo e assim ajudando outros, e como num ciclo, sendo ajudado logo adiante com boleto de um outro banco que você pode precisar.

Parabéns pela iniciativa, Elizeu Alcantara e todos os outros que também ajudaram de alguma forma, projetos como este sempre terão o meu apoio e o meu reconhecimento.

[]‘s
Igor.

Posts Relacionados: