goncin@wordpress.com:~$ _

Linux, programação e toda sorte de nerdices

Arquivos de tags: devFranca

jQuery: evitando conflitos com outros “frameworks” Javascript

Post publicado originalmente em http://devfranca.ning.com/group/jquery/forum/topics/jquery-evitando-conflitos-com-1 em 7 de outubro de 2009

Que o jQuery é ótimo, todo mundo já sabe (ou pelo menos deveria saber). Um dos seus mais poderosos recursos é o atalho $, que, entre tantos outros usos, substitui com vantagem o famigerado document.getElementById().

Nada obstante, os problemas com o $ começam quando se usa o jQuery com outros frameworks, que também usam o cifrão para alguma coisa. Experimentei esse problema ao combinar jQuery com Scriptaculous.

Mas nem tudo está perdido. Há algumas saídas:

  1. Utilizar o método noConflict() do jQuery, atribuindo o resultado a uma variável, que então substituirá o cifrão. Isso deixa o cifrão livre para uso por outros frameworks. Esse método, pelo menos para mim, não deu certo (o jQuery continuou funcionando, mas o Scriptaculous não):
    jq = jQuery.noConflict();
    jq("#elemento").hide(); // Ao invés de $("#elemento").hide();
    
  2. Utilizar o próprio objeto jQuery no lugar do cifrão. Esse método “eu agarântio”, mas precisei fazer um “Encontrar/Substituir” todos os "$" por "jQuery" também no código fonte dos plugins (que, invariavelmente, usam o cifrão):
    jQuery("#elemento").hide(); // Ao invés de $("#elemento").hide();
    

Fica a dica! 🙂

Anúncios

GExtenso: classe para geração de números por extenso em PHP

Post publicado originalmente em http://devfranca.ning.com/profiles/blogs/gextenso-classe-para-geracao em 2 de março de 2010.

GExtenso é uma classe que gera a representação por extenso de um número ou valor monetário.

Sua implementação foi feita como prova de conceito, utilizando:

  • Métodos estáticos, implementando o padrão de projeto (design pattern) SINGLETON;
  • Chamadas recursivas a métodos, minimizando repetições e mantendo o código enxuto;
  • Uso de pseudoconstantes (‘private static’) diante das limitações das constantes de classe;
  • Tratamento de erros por intermédio de exceções; e
  • Utilização do phpDocumentor para documentação do código fonte e geração automática de documentação externa.

EXEMPLOS DE USO

Para obter o extenso de um número, utilize GExtenso::numero.

echo GExtenso::numero(832); // oitocentos e trinta e dois
echo GExtenso::numero(832, GExtenso::GENERO_FEM); // oitocentas e trinta e duas

Para obter o extenso de um valor monetário, utilize GExtenso::moeda.

// IMPORTANTE: veja nota sobre o parâmetro 'valor' na documentação do método!
echo GExtenso::moeda(15402); // cento e cinquenta e quatro reais e dois centavos
echo GExtenso::moeda(47); // quarenta e sete centavos
echo GExtenso::moeda(357082, 2,
  array('peseta', 'pesetas', GExtenso::GENERO_FEM),
  array('cêntimo', 'cêntimos', GExtenso::GENERO_MASC)
); // três mil, quinhentas e setenta pesetas e oitenta e dois cêntimos

Download via github: http://github.com/goncin/GExtenso

ADOdb: camada de abstração de banco de dados para PHP – dicas e truques

Post publicado originalmente em http://devfranca.ning.com/profiles/blogs/adodb-camada-de-abstracao-de em 15 de fevereiro de 2010.

Olá, pessoal! Após um bom tempo “sumido”, volto para partilhar com vocês minha experiência com o ADOdb, que é uma camada de abstração de banco de dados para PHP. Muitos de vocês já devem utilizá-lo ou pelo menos ter ouvido falar dele. Nesse caso, espero não ser repetitivo e “chover no molhado”, mas vou tentar passar alguns truques úteis que não se acham facilmente por aí.

O ADOdb encontra-se em desenvolvimento desde o ano 2000, e, embora tenham surgido outras propostas semelhantes (como o PDO), ele continua sendo a mais popular e camada de abstração de banco de dados para o PHP, sendo utilizado em várias aplicações de renome (Mambo, Xaraya, Moodle, etc).

Opa! Camada de abstração de banco de dados? Esse bicho morde?

Não só não morde, como vem em auxílio do desenvolvedor PHP, especialmente nos casos em que:

  • o projeto foi iniciado em um SGBD (digamos, mySQL) e, a partir de um determinado ponto, foi necessário alterá-lo para outro (PostgreSQL ou MS SQL Server, por exemplo);
  • o mesmo projeto necessita acessar dados em SGBDs distintos – no meu caso específico, vivo tendo que fazer mySQL e MS SQL Server conversarem e trocarem dados entre si.

A vantagem mais óbvia de se utilizar uma camada de abstração de banco de dados é ter à mão um conjunto uniforme de classes e métodos para manipular os dados, sem se preocupar com o SGBD no qual os dados estão armazenados. Não seria ótimo utilizar algo como $conexao->Execute() ao invés de ter de lidar com mysql_query() para o mySQL, pg_query() para o PostgreSQL, etc.?

Animado com a ideia? Mãos na massa, portanto. Instalar o ADOdb é tão simples como baixar um arquivo comprimido e descompactá-lo no local de sua preferência, desde que ao alcance de seu servidor Web.

Pois bem. Suponhamos uma tabelinha bem simples, em um banco de dados qualquer, chamada tb_pessoa:

cod_pessoa nome_pessoa
1001 Fulano de Tal
1002 Beltrano da Silva
1003 Sicrano de Souza

Para utilizar o ADOdb e mostrar esses dados numa página, primeiramente precisamos criar uma conexão ao nosso SGBD. Isso é feito da seguinte forma:

include('/caminho/para/ADOdb.inc.php');

$conexao = NewADOConnection('<nome do driver do SGBD>');
$conexao->PConnect('<servidor>', '<usuário>', '<senha>', '<banco de dados>');
$conexao->SetFetchMode(ADODB_FETCH_ASSOC);

Nota-se que, qualquer que seja o SGBD, o esquema de conexão continua o mesmo (há outras formas de criar uma conexão, isso será abordado posteriormente). O que realmente muda é o nome do driver do SGBD. Veja aqui a lista completa dos SGBD suportados pelo ADOdb. Na primeira linha, criamos a conexão, passando como parâmetro o nome do driver que queremos utilizar. Na segunda linha, criamos uma conexão permanente (utilizando PConnect), passando os chamados “quatro parâmetros clássicos”. Ter uma conexão permanente significa dizer que o PHP reutilizará a mesma conexão (contanto que os “quatro parâmetros” mantenham-se os mesmos em diferentes requisições de página) para todos que acessarem sua aplicação, evitando o conhecido problema de estouro do limite do número de conexões. Por fim, na terceira linha instruímos o ADOdb a gerar, para os campos de uma consulta, uma matriz associativa em que as chaves são os nomes dos campos. De outra forma, somente poderíamos acessar o valor dos campos utilizando o índice numérico do campo. Não entendeu bem? Não se preocupe, isso ficará mais claro em breve.

A partir desse ponto, toda e qualquer operação com os dados poderá utilizar os mesmos métodos. O aspecto mais interessante do ADOdb, na minha opinião, é sua característica multiparadigmática,isto é, ele oferece múltiplas formas de se fazer a mesma tarefa. Assim, para gerar uma tabela HTML com os dados de tb_pessoa, é possível utilizar o seguinte trecho de código:

$registros  =  $conexao->GetAll('select * from tb_pessoa');

echo "<table>\n";
for($i = 0; $i < count($registros); ++$i) {
  echo "<tr>\n<td>{$registros[$i]['cod_pessoa']}</td>";
  echo "<td>{$registros[$i]['nome_pessoa']}</td></tr>\n";
}
echo "</table>\n";

O método GetAll retorna todos os registros da query em uma matriz multidimensional, em que a primeira dimensão corresponde ao número do registro (iniciado em 0) e segunda aos dados do registro correspondente.

Quem preferir, pode trocar o for pelo foreach, com as adaptações necessárias:

$registros  =  $conexao->GetAll('select * from tb_pessoa');

echo "<table>\n";
foreach($registros as $reg) {
  echo "<tr>\n<td>{$reg['cod_pessoa']}</td>";
  echo "<td>{$reg['nome_pessoa']}</td></tr>\n";
}
echo "</table>\n";

Por outro lado, aqueles que já trabalharam com o Visual Basic ou com o modelo ADO de acesso a dados (no qual, originalmente, o ADOdb se inspirou), talvez achem mais familiar a seguinte abordagem:

$registros  =  $conexao->Execute('select * from tb_pessoa');

echo "<table>\n";
while(! $registros->EOF) {
  echo "<tr>\n<td>{$registros->fields['cod_pessoa']}</td>";
  echo "<td>{$registros->fields['nome_pessoa']}</td></tr>\n";
  $registros->MoveNext();
}

echo "</table>\n";

Nesse caso, ao invés de GetAll (que retorna uma matriz), foi utilizado o método Execute (que também é utilizado para instruções do tipo INSERT, UPDATE e DELETE), o qual retorna um objeto que representa o conjunto de registros. Este, por seu turno, é percorrido testando-se se foi atingido o final do conjunto (EOF), exigindo uma instrução explícita para a passagem de um registro a outro (MoveNext). O valor dos campos é acessado por meio de da propriedade fields, que se constitui numa matriz associativa cujas chaves são os nomes de cada campo.

Como disse inicialmente, o ADOdb oferece várias abordagens, para que desenvolvedores das mais diferentes formações encontrem a maneira mais familiar de interagir com ele.

Dicas e Truques

  • Quem trabalha com MS SQL Server no PHP pode já ter tido dificuldades para fazer essas duas tecnologias conversarem entre si. Isso porque a biblioteca de acesso ao MS SQL Server nativa do PHP (php_mssql) apresenta severas limitações, já que sua API se baseia na antiquíssima versão 7.0 do SGBD da Microsoft. Contudo, se seu servidor PHP roda sob Windows, podemos instruir o ADOdb a utilizar o driver ADO ao invés da biblioteca PHP, com um pequeno ajuste na instrução de conexão, como segue:
    include('/path/to/ADOdb.inc.php');
    
    $conexao = NewADOConnection('ado_mssql');
    $conexao->PConnect("Provider=SQLOLEDB.1;Network Library=DBMSSOCN;Data Source=<servidor>,1433;Initial Catalog=<banco de dados>;User ID=<usuário;Password=<senha>");
    $conexao->SetFetchMode(ADOdb_FETCH_ASSOC);
    
    

    Na primeira linha, dizemos ao ADOdb para utilizar o driver ado_mssql ao invés do mssql. Na segunda linha, ao invés dos clássicos quatro parâmetros (servidor, usuário, senha e banco de dados), passamos apenas um, contendo a string de conexão ADO, que por sua vez embute os parâmetros requeridos.

  • Além do método GetAll, que retorna todo o resultado da consulta em uma matriz bidimensional, dois outros métodos “irmãos” são também bastante úteis. O método GetRow retorna o primeiro registro do conjunto (ótimo para consultas que só retornam um registro) e o método GetOne retorna o valor do primeiro campo do primeiro registro – perfeito para consultas do tipo select count(*) from tabela.
  • Os métodos GetAll, GetRow, GetOne e Execute podem receber um segundo argumento, que é uma matriz de parâmetros para a consulta. Veja no exemplo:
    $registros = $conexao->Execute('select * from tb_pessoa where nome_pessoa like ? or cod_pessoa > ?', array('Beltr%', 1002));
    

Por hoje é só, gente! Comentários, críticas e sugestões são benvindos.

PRADO para PHP 5: Active Controls (AJAX)

Post publicado originalmente em http://www.devfranca.com.br/2009/08/14/prado-para-php-5-active-controls-ajax/ em 14 de agosto de 2009.

Olá pessoal! Este é o segundo post da série sobre o framework PRADO para PHP 5. Se você chegou aqui diretamente, leia o primeiro post, pois estenderemos o projeto iniciado ali.

No primeiro projeto, implementamos um formulário simples que utiliza o método postback para o envio de requisições ao servidor web. O inconveniente desse método é o recarregamento da página inteira para que a exibição do resultado do processamento seja possível.

Uma forma melhor de obter o mesmo resultado, sem a desagradável atualização da página toda, é utilizar o método callback, que por sua vez se utiliza da tecnologia AJAX (Asynchronous Javascript and XML), capaz de atualizar apenas a região da página efetivamente alterada.

Quem desenvolve para a web sabe que trabalhar com AJAX pode ser penoso, principalmente se lidarmos diretamente com Javascript e XMLHTTPRequest. Felizmente, o Prado nos dá uma grande ajuda neste ponto, encapsulando as requisições AJAX em seus próprios componentes. E o que é melhor: em muitos casos, não é necessário sequer mexer com o Javascript!

Como assim? Vejamos como isso funciona na prática. Para começar, vamos fazer uma cópia de nosso projeto olamundo e renomeá-la como olamundo-2.0.

No arquivo /protected/pages/Home.page, vamos trocar os controles TTextBox, TButton e TLabel pelos seus “irmãos ativos”: TActiveTextBox, TActiveButton e TActiveLabel:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title></title>
</head>
<body>
  <h1>Olá, mundo!</h1>
  <com:TForm>
    Qual é o seu nome? <com:TActiveTextBox ID="txtNome" />&nbsp;
    <com:TActiveButton ID="btnEnviar" Text="Enviar" OnClick="Page.btnEnviarClick" />
    <br />
    <com:TActiveLabel ID="lblCumprimento" />
  </com:TForm>
</body>
</html>

Essa é toda a alteração necessária neste arquivo.

No arquivo /protected/pages/Home.php, vamos acrescentar apenas uma linha ao início do arquivo, antes da declaração da classe:

<?php

Prado::using('System.Web.UI.ActiveControls.*');

class Home extends TPage {

  public function btnEnviarClick($sender, $param) {
    $this->lblCumprimento->Text = "Olá, " . $this->txtNome->Text . "!";
  }

}

Como os controles ativos, por padrão, não são carregados automaticamente pelo PRADO, aquela linha serve para dizer ao framework que queremos utilizá-los. E isso é tudo. Você poderá ver o novo projeto em ação aqui e, se tiver olhos atentos, perceberá que a tela não “pisca” mais antes da exibição da saudação.

Para os mais “cismados”, e também para deixar nosso usuário ciente do que está acontecendo nos bastidores, vamos fazer um novo upgrade do projeto, agora para a versão olamundo-2.1. Acrescentaremos um notificador de atividade que será exibida na página enquanto a requisição AJAX vai e volta: uma div vermelha contendo o texto “Aguarde…”.

Vamos mexer no /protected/pages/Home.php:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title></title>
<!-- STYLE acrescentado -->
<style>
  #notif {
    background-color:#F00;
    color: #FFF;
    position:absolute;
    visibility:hidden;
  }
</style>
</head>
<body>
  <!-- DIV acrescentada -->
  <div id="notif">Aguarde...</div>
  <h1>Olá, mundo!</h1>
  <com:TForm>
    Qual é o seu nome? <com:TActiveTextBox ID="txtNome" />&nbsp;
    <!-- Propriedades ClientSide Acrescentadas -->
    <com:TActiveButton ID="btnEnviar" Text="Enviar" OnClick="Page.btnEnviarClick"
      ClientSide.OnLoading="$('notif').style.visibility='visible'"
      ClientSide.OnLoaded="$('notif').style.visibility='hidden'" />
    <br />
    <com:TActiveLabel ID="lblCumprimento" />
  </com:TForm>
</body>
</html>

Foram acrescentados um estilo (para configurar a DIV com fundo vermelho, posicionamento absoluto e sem visibilidade inicial), a DIV propriamente dita e configuradas duas novas propriedades do componente TActiveButton: ClientSide.OnLoading e ClientSide.OnLoaded. A primeira propriedade contém um código Javascript (finalmente!) a ser executado quando a requisição é despachada para o servidor e a segunda o código para quando a resposta chegar. Em nosso projeto, a lógica é simples: enviou a requisição, exibe a DIV; a resposta chegou, oculta a DIV. O resultado disso? Veja aqui.

Os mais atentos vão notar que, nas duas linhas Javascript foi utilizado o atalho $(‘notif’) ao invés do longo e tedioso document.getElementById(‘notif’). Isso porque o PRADO também não tem a intenção de reinventar a roda, e, ao contrário, incorpora algumas das melhores soluções desenvolvidas por terceiros. No caso do Javascript, o PRADO já traz consigo o Prototype (de onde vem o atalho $) e o script.aculo.us, entre outros.

Fico por aqui com este post, esperando ter sido didático na minha exposição. Para terminar, zipei as três versões do olamundo, juntamente com o PRADO, e fiz upload aqui, para facilitar. Para quem tem uma instalação PHP 5, basta descompactar num diretório acessível pelo seu servidor web.

Um abraço, e até a próxima!

PRADO: (não apenas mais um) framework para o PHP 5


Olá, pessoal! Este é o meu primeiro post aqui no devFranca. O objetivo dele é apresentar o framework PHP com o qual trabalho, e que acho bastante interessante para o desenvolvimento de aplicações web. Não deixe de comentar após a leitura. 🙂

Há cerca de três anos, percebi que as aplicações estavam migrando para a web, e a partir dessa constatação decidi mudar meu foco de desenvolvimento. Até então, meu trabalho consistia em desenvolver programas para desktop, e minha ferramenta favorita era o Delphi (embora eu já tivesse trabalhado também com o VB). Eu não era nenhum estrangeiro nas terras do desenvolvimento web, tendo já trabalhado por quatro anos com o ASP, e conhecia, portanto, as limitações dessa plataforma.

Como simpatizante das tecnologias opensource, escolher o PHP foi a decisão natural. Naquele momento, eu iria iniciar um projeto PHP do zero, e percebi que reinventar a roda não seria inteligente nem produtivo. Foi daí que parti em busca de um framework, uma caixa de ferramentas mais ou menos prontas, que me poupasse o esforço de codificar muita coisa “na unha”.

Após algumas perguntas ao Grande Oráculo, deparei-me com o PRADO (sigla para PHP Rapid Application Development Object-oriented). Dentre tantos frameworks para PHP, chamou minha atenção no PRADO o seu “jeitão” inspirado no Delphi, de que tomou emprestado vários conceitos, como a utilização de componentes e eventos, além de uma hierarquia de classes nitidamente inspirada na VCL.

classtree

Hoje, o PRADO já está na versão 3.1.6 3.1.7, e pode ser baixado gratuitamente aqui aqui, sob a licença BSD revisada. O framework vem num arquivo compactado (padrão ZIP), bastando descompactá-lo, mantendo a estrutura de diretórios, numa pasta acessível pelo seu servidor web (Apache, IIS, etc.).

Pois bem, deixemos de blablablá e vamos colocar a mão na massa, criando nosso primeiro projeto em PRADO, que terá o nome de olamundo (sugestivo e original, não?). O PRADO trabalha com uma estrutura de pastas predefinida, dentro da qual criaremos alguns arquivos, conforme mostra a figura abaixo.

O arquivo index.php, que fica na pasta-raiz do projeto, terá o conteúdo seguinte:

<?php
require('path/to/prado.php');

$application=new TApplication;

$application->run();

E só. Não se esqueça de trocar <pasta do PRADO> pelo caminho da pasta onde você instalou o PRADO.

O arquivo /protected/pages/Home.page, apesar da extensão pouco usual, é apenas um arquivo HTML no qual inserimos, além das tags padrão, as tags especiais do PRADO. No nosso projeto, seu conteúdo será o seguinte:

<html><head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title></title>
</head>
<body>
  <h1>Olá, mundo!</h1>
  <com:TForm>
    Qual é o seu nome? <com:TTextBox ID="txtNome" />&nbsp;
    <com:TButton ID="btnEnviar" Text="Enviar" OnClick="Page.btnEnviarClick" /><br />
    <com:TLabel ID="lblCumprimento" />
  </com:TForm>
</body>
</html>

Veja que eu negritei as tags especiais do PRADO. Elas representam os componentes, que por sua vez vão se transformar depois em código 100% HTML. Aqui, utilizei três componentes: TTextBox (que se tornará uma caixa de texto), TButton (um botão) e TLabel (uma área de texto estático, que será renderizada como <span>). Note que nesse arquivo não há nenhum código PHP, e essa é exatamente a intenção: separar o que é design do que é código, implementando assim o paradigma MVC (Model-view-controller).

O PRADO é totalmente orientado a objeto. Por isso, a toda página do aplicativo corresponde uma classe, derivada de TPage (como você pode ver logo mais abaixo). Cada classe de página requer dois arquivos, um .page (para a parte visual) e outro .php (para o código). Ambos os arquivos devem ter o mesmo nome, que deve coincidir também com o nome da classe. O padrão para a página inicial do PRADO é Home (há como alterar isso, criando um arquivo de configuração personalizado, assunto que ficará para uma próxima oportunidade). Tudo muito bom, mas cadê o código PHP? Está no arquivo /protected/pages/Home.php:

<?php

class Home extends TPage {

  public function btnEnviarClick($sender, $param) {
    $this->lblCumprimento->Text = "Olá, "  .  $this->txtNome->Text . "!";
  }

}

Note que, no arquivo Home.page, há um atributo OnClick na tag do TButton, referenciando um método chamado Page.btnEnviarClick. Pois bem, esse método é implementado em Home.php. Acho que todos conseguiram sacar o que o nosso “aplicativo” vai fazer: pegar o nome digitado na caixa de texto e apresentar uma saudação a ele. Quem quiser ver a coisa funcionando ao vivo e em preto-e-branco (desculpe, gente, não deu tempo de colocar CSS para deixar coloridinho :p), clique aqui.

Esse primeiro projeto implementa um formulário pelo método postback, no qual os dados são enviados ao servidor para processamento e a página é completamente recarregada para exibir o resultado. No meu próximo post, vou mostar como, com pouquíssimas alterações, é possível transformar esse aplicativo numa chamada callback, devolvendo o resultado sem recarregar a página. Em suma, veremos como o PRADO trabalha com AJAX – e isso sem mexer numa linha sequer de Javascript!

Bom gente, aqui chega ao fim minha primeira colaboração. Espero que tenham gostado. Até mais!

%d blogueiros gostam disto: