Debugando.com » PHP

Frameworks no PHP: O que, quando, por que e qual?

admin — Wed, 29 Jul 2009 20:45:15 +0000

PHP é a linguagem de programação mais famosa do mundo por várias razões: flexibilidade, facilidade de uso e vários outros fatores. Mas algumas vezes a programação se torna monótona e/ou repetitiva, e é aí que um framework pode ajudar.

O que é um framework de PHP?

De forma resumida o framework é uma estrutura, uma fundação para você criar a sua aplicação. Em outras palavras o framework te permite o desenvolvimento rápido de aplicações (RAD), o que faz economizar tempo, ajuda a criar aplicações mais sólidas e seguras além de reduzir a quantidade de código repetido. Os frameworks também permitem que os iniciantes criem aplicações mais estáveis garantindo uma boa relação entre o banco de dados e a camada externa de exibição. Isso tudo te permite gastar mais tempo desenvolvendo a aplicação em si do que repetindo os códigos que todas as aplicações têm.

A idéia padrão de trabalho por trás de um framework no PHP está ligada ao modelo MVC (Model View Controller). MVC é uma forma de programação que isola a lógica de negócio (como a aplicação funciona) da camada de exibição (a parte visual). O Model cuida do banco de dados, o View cuida da camada de exibição e o Controller cuida da lógica de negócio. Isso tudo faz com que você trabalhe mais rápido e de forma setorizada.

Por que usar um framework de PHP?

Os desenvolvedores utilizam frameworks por vários motivos, e o maior deles é para agilizar o processo de desenvolvimento. A re-utilização de código em vários projetos vai economizar muito tempo e trabalho? Isso é garantido, pois o framework já traz uma série de módulos pré-configurados (e funcionando) para fazer as mais variadas e comuns tarefas como envio de e-mails, conexão com o banco de dados, sanitização (limpeza) de dados e proteção contra ataques.

Estabilidade é outra grande vantagem dos frameworks. A simplicidade, que é um dos grandes “feitos” do PHP, também é o que possibilita inúmeros erros e falhas pelos principiantes? Nem todo código que funciona necessariamente está correto e bem desenvolvido.

Quando usar um framework de PHP?

Essa é uma dúvida muito comum em todos os níveis de desenvolvimento. Para a maioria dos iniciantes, usar um framework, além de ser mais fácil, vai ser mais estável, então é bom usá-los sempre que possível.

Em contrapartida vários programadores experientes vêem os frameworks como ferramentas usadas por programadores fracos, que não sabem como criar um código limpo, sólido e seguro.

Quando se trabalha com projetos que têm um prazo muito curto (o que eu chamo de “prazo Jack Bauer”) é sempre bom usar um framework, pois ele vai agilizar todo o processo. Outro motivo forte para o uso do framework é que você não está criando “código artesanal”? Há todo um padrão que você deve seguir para que as coisas funcionem, e está tudo documentado e explicado em uma vasta comunidade de suporte.

CakePHP

O CakePHP é uma grande opção para iniciantes e desenvolvedores avançados. Ele foi criado usando as bases e modelos do Ruby on Rails e é pesadamente focado no desenvolvimento ágil e rápido. Recentemente ele tem se tornado muito famoso por sua simplicidade e facilidade de uso.

Eu pessoalmente recomendo o CakePHP. Minha vida de programador mudou depois que eu comecei a usar ele.

Zend Framework

O Zend Framework é um framework focado no desenvolvimento de aplicações pra web 2.0. Ele tem um grande número de seguidores, fontes de suporte e uma comunidade cheia de usuários ativos e participativos. O Zend é o framework mais famoso hoje em dia, ele é robusto e permite a criação de aplicações enterprise (de grande porte) mas seu uso exige um conhecimento vasto do PHP.

CodeIgniter

Já o CodeIgniter é bastante conhecido pela sua facilidade de uso, performance e rapidez. É ideal para aplicações rodando em servidores compartilhados. Ele oferece soluções simples e de pequeno porte, com um grande número de tutoriais em vídeo, fóruns e wikis.

Fonte: Imasters

Manipulação de dados BLOB com PHP e MySQL

admin — Thu, 14 May 2009 14:41:44 +0000

Sem dúvida alguma, uma das perguntas mais frequentes em relação ao MySQL é: “como posso armazenar arquivos em uma base de dados?”. A resposta é: tens que usar o tipo de dados BLOB. Estes BLOBs (Binary Large Objects) podem armazenar praticamente qualquer tipo de dados, incluindo documentos do MS Word, imagens gif/jpeg, arquivos PDF, mp3, etc.

Neste artigo vamos ver como criar um repositório de arquivos binários usando PHP e MySQL para poder armazenar diferentes tipos de arquivos. Veremos como armazenar cada um dos arquivos em uma base de dados, para posteriormente recuperá-los.

Para testar os exemplos deste artigo, é necessário ter acesso a um servidor com suporte a PHP, além de contar com um servidor MySQL. Assumindo que você conte com os privilégios apropriados para criar a base dados, e que o MySQL está rodando no mesmo servidor que o PHP, vamos iniciar o desenvolvimento.

Criando a base de dados

Nosso repositório de documentos usará uma base dados que contenha unicamente uma tabela para armazenar todos os documentos. O banco de dados será chamado de “repositorio“, e a tabela de “arquivos“.

Código SQL para criar a tabela

CREATE TABLE arquivos(
id int not null auto_increment primary key,
nome varchar(50),
titulo varchar(50),
conteudo mediumblob,
tipo varchar(50));

Agora temos uma base chamada repositorio, que contém uma tabela chamada arquivos.

Veja abaixo informações sobre cada campo da tabela arquivos:

id - um número inteiro que nos proporcionará um identificador único para cada arquivo que iremos armazenar. Este será incrementado automaticamente cada vez que for inserido um novo registro.
nome - o nome original do arquivo, por exemplo, fot.gif, curriculum.doc, etc.
titulo - uma breve descrição de cada arquivo que será gravada na tabela, por exemplo “Carta para minha noiva”, ou “A foto do meu irmão”. Este título será usado posteriormente na visualização dos arquivos do repositório em uma página web.
conteudo – um campo do tipo binário (blob) para guardar o conteúdo de cada arquivo. Na nossa tabela usamos um tipo mediumblob, o qual pode armazenar arquivos de até 16Mb.
ipo – como veremos mais adiante, cada arquivo (seja um .doc, .gif, .pdf, etc) tem um tipo único. Quando se envia um
arquivo para o servidor web através de uma página web, o navegar envia ao servidor a informação acerca do tipo de arquivo, o tipo de conteúdo do arquivo, etc. Os tipos de conteúdo são simples cadeias. O tipo de conteúdo para um arquivo MS WORD é “application/msword”, o tipo de conteúdo para uma imagem é “image/gif”, etc.

Agregando arquivos à base de dados

Agora que temos a base de dados do nosso repositório e sabemos a finalidade de cada campo, vamos criar uma simples página web que permita selecionar um arquivo desde o navegador para posteriormente enviá-lo para um script em PHP que ficará encarregado de armazená-lo em nossa base de dados.A página web será nomeada escolher_arquivo.html e o script em PHP será chamado de guardar_arquivo.php.

A página web pode conter todo o código HTML que se deseje, mas é necessário que se inclua o seguinte formulário para que se tenha a opção de escolher um arquivo e enviá-lo ao servidor.


<form enctype="multipart/form-data" action="guardar_arquivo.php" method="post">
Descrição <input type="text" name="titulo" size="30">
Arquivo <input type="file" name="arquivo">
<input type="submit" value="Enviar arquivo">
form>

Do código que escrevemos temos que frisar o seguinte:

o formulário necessita de um atributo enctype com um valor multipart/form-data
o método de envio tem que ser POST
tem que ser usado pelo menos um campo do tipo FILE

Estes são os três requerimentos básicos que a página HTML deve cumprir para que seja possível enviar o arquivo para o servidor.

Antes de escrever o código do script guarda_arquivo.php, vamos comentar algo acerca da forma como serão recebidos os dados do arquivo em questão.

Desde a versão 4.1 do PHP é recomendada a utilização da variável $_FILES para a leitura dos dados do arquivo que está sendo enviado ao servidor. Abaixo estão listadas os índices e parâmetros recebidos pela variável. Note que o nome dos índices depende de como é nomeado o campo do tipo FILE no formulário.

$_FILES['arquivo']['name']
Nome original do arquivo
$_FILES['arquivo']['type']
O tipo MIME do arquivo, … image/gif, application/pdf, application/msword,.. etc
$_FILES['arquivo']['size']
O tamanho do arquivo em bytes
$_FILES['arquivo']['tmp_name']

O local do arquivo temporário que se cria quando o arquivo é enviado ao servidor. É nesta variável que são lidos todos os dados do arquivo em si. Se estes dados não são copiados ou movidos para outro lugar, ou em nosso caso, armazenados em uma base de dados, podem ser perdidos, já que o PHP elimina esses arquivos depois de um determinado tempo.

Por exemplo, estes são os possíveis valores para um arquivo j-odbc.zip que foi enviado ao servidor:

$_FILES["arquivo"][name] => j-jdbc.zip
$_FILES["arquivo"][type] => application/zip
$_FILES["arquivo"][tmp_name] => /tmp/phpvXQpqP
$_FILES["arquivo"][size] => 337945

Vale ressaltar que devem ser revistos e, se necessário modificar as seguintes variáveis no arquivo de configuração do PHP para que você possa fazer o upload dos arquivos para o servidor, e pode ser gerida por um script PHP.

file_uploads – diz ao PHP se pode ou não ser feito o envio de arquivos para o servidor. Essa variável deve ter o valor “On”.
upload_max_filesize – diz ao PHP qual o tamanho máximo do arquivo que pode ser enviado ao servidor. Pode ser utilizado o sufixo “M” para indicar o valor em Megabytes, por exemplo, com um valor 2M se aceita um arquivo máximo de 2 Megabytes.
upload_tmp_dir – é o diretório para onde será copiado temporariamente o conteúdo do arquivo quando for enviado ao
servidor.

Agora é o momento de mostrar o código PHP que vai armazenar o arquivo em nossa base de dados.

/* guardar_arquivo.php */

require("dbconnect.inc.php");

 $arquiivo = $_FILES["arquivo"]["tmp_name"];
 $tamanho = $_FILES["arquivo"]["size"];
 $tipo    = $_FILES["arquivo"]["type"];
 $nome  = $_FILES["arquivo"]["name"];
 $titulo  = $_POST["titulo"];

 if ( $arquivo != "none" )
 {
 $fp = fopen($arquivo, "rb");
 $conteudo = fread($fp, $tamanho);
 $conteudo = addslashes($conteudo);
 fclose($fp); 

 $qry = "INSERT INTO arquivos VALUES
 (0,'$nome','$titulo','$conteudo','$tipo')";

 mysql_query($qry);

 if(mysql_affected_rows($conn) > 0)
 print "O arquivo foi gravado na base de dados.";
 else
 print "Não foi possível gravar o arquivo na base de dados.";
 }
 else
 print "Não foi possível carregar o arquivo para o servidor.";

O arquivo dbconnetc.inc.php contém unicamente as instruções para conexão ao MySQL e selecionar a base de dados que será utilizada.

/* dbconnect.inc.php */

$conn = mysql_connect("localhost","usuário","senha");
 mysql_select_db("repositorio");

Listando os arquivos da base de dados

Já que gravamos alguns arquivos no nosso repositório, agora podemos listar as informações deles, para posteriomente fazermos o download.

/* listar_arquivos.php */

require("dbconnect.inc.php");

$qry = "SELECT id, nome, titulo, tipo FROM arquivos";
$res = mysql_query($qry);

while($fila = mysql_fetch_array($res))
{
print "$fila[titulo]


$fila[nome] ($fila[tipo])


Fazer Download



";
}

Fazendo o download dos arquivos da base de dados

Como se pode observar no código anterior, foi colocado um link para cada arquivo, chamado baixar_arquivo.php. A funcionalidade deste script será ler os dados dos arquivos que estão gravados na base de dados e enviá-los ao navegador.

Dependendo do tipo de arquivo da qual se trate, o navegador poderá mostrá-lo por ele mesmo o conteúdo do arquivo.

/* Script baixar_arquivo.php */

require("dbconnect.inc.php");

 $qry = "SELECT tipo, conteudo FROM arquivos WHERE id=$id";
 $res = mysql_query($qry);
 $tipo = mysql_result($res, 0, "tipo");
 $conteudo = mysql_result($res, 0, "conteudo");

 header("Content-type: $tipo");
 print $conteudo;

Comentário Finais

Como se pode observar, o código PHP dos scripts é bem simples, e não tem nenhum grau de dificuldade. O código foi desenvolvido com o propósito mais simples possível, para que possa ser melhorado e utilizado em aplicações mais robustas.

Fonte: Imasters

Gerando planilhas XLS para o Excel pelo PHP

admin — Wed, 01 Apr 2009 14:05:30 +0000

Recentemente precisei migrar alguns relatórios CSV para XLS, de forma que pudessem ser abertos diretamente no Excel sem aquelas telas chatas de importação de dados. Utilizei a classe Spreadsheet_Excel_Writer do PEAR e o resultado foi melhor do que o esperado.

Criando planilhas

O arquivo do Excel é organizado em uma pasta de trabalho (workbook) onde ficam uma ou mais planilhas (worksheets). O código PHP seguirá a mesma lógica, instanciando a pasta de trabalho e adicionando a ela um objeto para cada planilha. As planilhas poderão ser preenchidas conforme a posição da linha e coluna, ambas começando do zero.

php
require_once "Spreadsheet/Excel/Writer.php";

$workbook = new Spreadsheet_Excel_Writer();

$worksheet =& $workbook->addWorksheet("Título da planilha");

$worksheet->write(0, 0, "Primeira linha, primeira coluna");
$worksheet->write(0, 1, "Primeira linha, segunda coluna");
$worksheet->write(1, 0, "Segunda linha, primeira coluna");
$worksheet->write(1, 1, "Segunda linha, segunda coluna");

Observe que a planilha foi adicionada utilizando o operador de referência &. No PHP 4 isto é necessário para que a variável $worksheet deste escopo represente efetivamente a planilha dentro da pasta de trabalho $workbook. Do PHP 5 em diante este recurso não é necessário, já que variáveis apontam sempre para o mesmo objeto (exceto, claro, quando propositalmente clonados).

void Worksheet::write ( integer $row , integer $col , mixed $token , mixed $format=0 )

integer $row – número da linha onde escrever (começando do 0)
integer $col – número da coluna onde escrever (começando do 0)
mixed $token – conteúdo da célula
mixed $format – opcional, especifica a formatação da célula

O método write tenta identificar o tipo do conteúdo como texto, número, link, fórmula ou vazio. Esta identificação automática acabou me levando a um resultado inesperado ao preencher células com número de CPF, já que alguns começavam com zero e, ao serem convertidos de texto para número, acabaram tendo os primeiros dígitos removidos. Para ter certeza do formato da célula, é possível utilizar diretamente as demais funções de escrita:

writeBlank para escrever uma célula vazia, útil para formatar o estilo sem especificar valor
writeFormula para escrever uma fórmula, da mesma forma que seria feito no Excel
writeNumber para escrever um número
writeString para escrever um texto livre
writeUrl para escrever um link; o texto visível pode ser especificado no quarto parâmetro e a formatação, se alguma, no quinto parâmetro

Como a identificação de tipo pelo método write é feita com uma série de expressões regulares, utilizar os métodos de escrita para determinado tipo pode melhorar o desempenho do script com planilhas muito grandes.

Além da escrita por célula, é possível preenchermos toda uma linha ou coluna a partir de um array. Estes métodos são especialmente úteis para preencher a planilha a partir de uma consulta ao banco de dados:

mixed Worksheet::writeRow ( integer $row , integer $col , array $val , mixed $format =null )

integer $row – número da linha onde escrever
integer $col – número da coluna onde começar a escrever os valores
array $val – valores das células que serão escritas na linha
mixed $format – opcional, especifica a formatação da célula

mixed Worksheet::writeCol ( integer $row , integer $col , array $val , mixed $format =null )

integer $row – número da linha onde começar a escrever os valores
integer $col – número da coluna onde escrever
array $val – valores das células que serão escritas na coluna
mixed $format – opcional, especifica a formatação da célula

Formatando a célula

Enquanto eu migrava alguns relatórios para XLS, percebi que outra grande novidade para o usuário em comparação à importação de CSV seria melhorar o visual da planilha. A formatação de estilo é adicionada à pasta de trabalho e em seguida associada às células que receberão o estilo.

$header =& $workbook->addFormat();
$header->setFgColor(15);
$header->setBold();

$relatorio =& $workbook->addWorksheet();

$relatorio->write(0, 0, "Aluno", $header);
$relatorio->write(0, 1, "Matrícula", $header);
$relatorio->write(0, 2, "E-mail", $header);

O estilo adicionado define um tom claro de cinza para o fundo e a fonte em negrito. O Excel utiliza uma paleta de cores própria; para adicionar uma cor diferente, o método setCustomColor deve ser utilizado, passando o índice da cor como primeiro argumento (que será utilizado para identificar a cor em funções como setFgColor e setColor) e os níveis RGB como segundo, terceiro e quarto argumentos, respectivamente.

Também é possível passar um array com as configurações diretamente para o método addFormat:

$estilo_padrao =& $workbook->addFormat(array('Size' => 10));

$estilo_aluno =& $workbook->addFormat(array('Size' => 10, 'Align' => 'right', 'Bold' => 1));

$linha = 0;

$relatorio->writeString(++$linha, 0, "Homer", $estilo_aluno);
$relatorio->writeString($linha, 1, "S0001", $estilo_padrao);
$relatorio->writeString($linha, 2, "homer@example.com", $estilo_padrao);

$relatorio->writeString(++$linha, 0, "Bart", $estilo_aluno);
$relatorio->writeString($linha, 1, "S0002", $estilo_padrao);
$relatorio->writeString($linha, 2, "bart@example.com", $estilo_padrao);

Todas as opções de formatação podem ser vistas na documentação do addFormat.

Não vi nenhuma forma de deixar as colunas com largura automática, como quando damos dois cliques no divisor de colunas e a largura é reajustada automaticamente, mas o método setColumn pode ser utilizado para determinar uma largura fixa para um conjunto de colunas.

void Worksheet::setColumn ( integer $firstcol , integer $lastcol , float $width , mixed $format=0 , integer $hidden=0 )

integer $firstcol – primeira coluna do intervalo onde aplicar a formatação
integer $lastcol – última coluna do intervalo
float $width – largura das colunas
mixed $format – opcional, especifica a formatação da célula
integer $hidden – define se as colunas devem estar ocultas

Enviando para download

Uma vez que a pasta de trabalho esteja montada, basta enviar o header com o tipo de conteúdo e o nome do arquivo adequados para que o browser faça o download corretamente.

$workbook->send("teste.xls");

$workbook->close();

O método send envia os headers necessários e o close carrega o arquivo binário.

Instalando a classe

A instalação da classe é feita pelo próprio PEAR, com o detalhe de resolver as dependências necessárias e especificar que a classe ainda está em estado beta:

pear install --alldeps Spreadsheet_Excel_Writer-beta

Como utilizei a classe na intranet, o comando pôde ser executado como root pelo administrador do servidor para instalar a classe no sistema. Veja o link Installation of a local PEAR copy on a shared host para instruções de como utilizar classes PEAR em servidores compartilhados.

Documentação

Veja ainda a documentação da classe Spreadsheet_Excel_Writer para mais detalhes sobre diversos outros recursos.

Post originalmente postado em http://garotosopa.wordpress.com/gerando-planilhas-xls-para-o-excel-pelo-php/

Consultar bolsa de valores por PHP

admin — Mon, 09 Mar 2009 01:11:31 +0000

No exemplo desse artigo vamos usar um ativo da Petrobrás (PETR4, essa é a sigla) e para lermos o XML vamos usar simple_xml.

Então o que precisamos saber para consultar os índices de um ativo na bolsa?

A URL – http://www.theoziran.org/webservice/bovespa/

A sigla de um ativo – PETR4

Veja abaixo um código exemplo:

ativo;

            //A cotação do dia

            $simple_xml->dia;

            //A cotação da semana

            $simple_xml->semana;

            //A cotação dos últimos sete dias

            $simple_xml->setedias;

            //A cotação do mês

            $simple_xml->mes;

            //A cotação dos últimos trinta dias

            $simple_xml->trintadias;

            //A cotação do ano

            $simple_xml->ano;

            //A contação dos últimos 365 dias

            $simple_xml->ano-relativo;

            //Data em que os dados foram capturados

            $simple_xml->data;

?>

Configurando o PHP para conectar ao Oracle

admin — Tue, 27 Jan 2009 23:47:41 +0000

Tenho visto que muitas vezes, para pessoas que nunca trabalharam com PHP e Oracle, é um tanto quanto difícil. Embora seja simples, conexão PHP com Oracle exige um conhecimento a mais do que com os outros bancos.

Tudo começa nas configurações do PHP. Precisamos descomentar as bibliotecas responsáveis pelo conexão com Oracle.

Configurando o PHP

No Windows, vá até o diretório de instalação do Apache.

1 – Edite o arquivo \apache\php.ini

2 – Busque pela linha ;extension=php_oci8.dll descomente-a tirando o ponto e vírgula de seu início.

2 – Busque pela linha ;extension=php_oracle.dll descomente-a tirando o ponto e vírgula de seu início.

3 – Salve o arquivo editado e reinicie o apache.

No Linux, vá até o diretório /etc/phpX*/apache (onde o “X” de phpX é a versão do PHP)

1 – Edite o arquivo /etc/phpX*/apache/php.ini

2 – Busque pela linha ;extension=oci8.so descomente-a tirando o ponto e vírgula de seu início.

3 – Caso ela não exista no arquivo, deverá ser inserida. Pode inseri-la no fim do arquivo mesmo sem problemas.

Criando a conexão com o Oracle via PHP:



Agora é só começar a programar mais!

self:: e $this->. Qual a diferença?

admin — Thu, 04 Dec 2008 13:51:05 +0000

Em PHP 5 podemos referenciar métodos e atributos de uma classe dentro de outros métodos dela utilizando self:: ou $this, mas muitas pessoas não sabem quando usar um e o outro…

Basicamente a diferença está em self:: referir-se à classe e $this-> referir-se ao objeto.

Bom, suponha as classe:

marcha--;
    }
}
?>

O atributo $marcha representa a marcha que o carro está atualmente e o método reduzirMarcha decrementa esse atributo. Observe que utilizamos $this->.

Vamos instanciar um objeto dessa classe:

marcha = 2;
$corsa->reduzirMarcha();
echo $corsa->marcha; //irá retornar 1.
?>

Se utilizar-mos self:: ao invés de $this-> não irá funcionar e no PHP 5 irá dar Fatal Error por $marcha não ser uma variavel estática.

Observe agora:

Agora a classe Carro possui uma variável estática $quantidade que não poderá ser chamada a partir de um objeto e somente a partir da Classe (sem estar instanciada).

Lembre-se só utilizamos self:: para variáveis estáticas.

Aprendendo Orientação a Objetos no PHP

admin — Thu, 04 Dec 2008 13:47:55 +0000

Ensinarei aqui o básico de Orientação a Objetos em PHP.

Começando com OO:

class Teste {
	public $texto;

	function setTexto($valor) {
		$this->texto = $valor;
	}

	function getTexto() {
		return $this->texto;
	}

	function mostraTexto() {
		$texto = $this->getTexto();
		echo $texto;
	}
}

$instancia = new Teste();
$instancia->setTexto(”Teste 123 mostre isso!”);
$instancia->mostraTexto();

Explicando:

Uma classe normal em PHP começa com a palavra class.

Nela, você pode definir variáveis globais, como foi definido ali: $texto.

Pra você acessar uma variável global através de uma função, você
precisaria usar uma instância da classe, mas como o nome da classe pode
mudar, você usa o $this-> como instância, o qual você pode acessar
tanto variáveis quanto funções.

Fora da classe, caso queira acessá-la, também é necessário definir a instância com, no caso:

$instancia = new Teste();

E $instancia passou a ser a instância da classe, podendo ela acessar as
funções e executá-las, como fez em $instancia->setTexto(); e
$instancia->mostraTexto();.

Perceberam que no código eu poderia dispensar o getTexto()? Mas não
eliminei, pois ele é importante no código para deixá-lo mais fácil na
hora da manutenção. Imagine se eu usasse a variável $texto num código
gigante e tenha que, do nada, mudar seu nome ou aplicar qualquer
alteração? Ia ser difícil… Mas com isso não, basta eu fazer a alteração
e adaptá-la numa única função, o getter getTexto().

Agora você pergunta…: O que é getter? Ah, pelo nome dá pra perceber, e
é bom ir percebendo, pois num código existem muitos getters e setters,
o qual você define várias coisas do código de uma forma fácil e que
exija fácil manutenção posteriormente.

Exemplo:

class Usuario {
	public $nome;
	public $senha;
	public $idade;
	public $tel;

	function getNome() {
		return $this->nome;
	}

Arg! vamos parar por aqui! Imagina fazer isso com todos os atributos!

Aí que eu digo "Use a cabeça, amigão"! E vamos continuar! Mas melhorando o código agora:

class Usuario {
	public $nome;
	public $senha;
	public $idade;
	public $tel;

	function __construct($nome, $senha, $idade, $tel) {
		$informacoes = array(”nome” => $nome, “senha” => $senha, “idade” => $idade, “tel” => $tel);

		foreach ($informacoes as $chave => $valor) {
			$this->setter($chave, $valor);
		}
	}

	function getter($atributo) {
		if(isset($atributo)) {
			return $this->$atributo;
		} else {
			return false;
		}
	}

	function setter($atributo, $valor) {
		if(isset($atributo)) {
			$this->$atributo = $valor;
		}else{
			return false;
		}
	}

	function exibeInformacoes() {
		$informacoes = array(”nome”, “senha”, “idade”, “tel”);

		foreach ($informacoes as $atributos) {
			echo $this->getter($atributos);
		}
	}
}

$instancia = new Usuario(”Jota”, “123oioi”, 15, “5555-5555″);
$instancia->exibeInformacoes();

Viram como dá para fazer coisas legais? Não é algo muuito trabalhado,
mas já dá para brincar com coisas pessoais e ter uma boa introdução!

Ah, não sei se perceberam mas agora viram outra coisa: O método mágico
__construct. Basicamente ele é uma função com o nome da classe, nada
mais que isso.

Qualquer dúvida, só postar em comentário ou procurar na documentação do PHP em:

http://www.php.net/docs

Introdução ao XAJAX

admin — Wed, 03 Dec 2008 14:26:31 +0000

O que é o XAJAX?

XAJAX é uma classe open source em PHP que permite a vocês criar facilmente poderosas aplicações web em HTML, CSS, JAVASCRIPT e PHP utilizando AJAX. Aplicações que fazem uso do XAJAX podem fazer chamadas a funções escritas em PHP e atualizar o conteúdo de páginas, obterem acesso a um banco de dados etc, sem recarregar a página atual.

Como instalar o XAJAX?

A versão atual do XAJAX é a 0.2.4 (estável). Já está em desenvolvimento a versão beta 2, que irá provavelmente substituir a versão 0.2.x, na versão 0.5 do XAJAX onde foram feitas melhorias, e a melhor delas é a inclusão de suporte a plugins, como script.aculo.us por exemplo que teremos oportunidade de estudar. Iremos utilizar a versão 0.5 beta 2 que encontra-se disponível para download. Faça o download do arquivo, crie uma pasta chamada library dentro de seu servidor web e descompacte os arquivos do XAJAX dentro da pata library (a pasta pode ter qualquer outro nome, esse é o que eu costumo usar).

A estrutura de pastas deverá ficar como da imagem abaixo.

Ao utilizar o XAJAX em ambiente de produção as pastas examples e tests podem ser apagadas, pois as mesmas são só exemplos, e alguns bem interessantes.

Ao primeiro exemplo

Junto (e não dentro) da pasta library crie um arquivo chamado form.php, neste arquivo iremos cria um formulário para validar se os campos Nome e E-Mail estão preenchidos, utilizando o XAJAX sem recarregar a página. Clique na imagem abaixo e veja o código do arquivo form.php:

form.php




INTRODUÇÃO AO XAJAX
printJavascript('./library/xajax/'); ?>



  
    
      INTRODUÇÃO AO XAJAX
Validado o formulário 
    
    
       
      
    
    
      Nome:
      
    
    
      E-Mail:

Linhas 2 e 3

Na linha 2 é feita a inclusão da class library do XAJAX que iremos trabalhar e na linha 3 o arquivo(validacoes.php) onde iremos escrever a função de validação deste formulário;

Linha 9

A função printJavascript() é a responsável pela saída dos dados de forma asincrona e é tem que ficar obrigatoriamente entre as tags do arquivo. O único parametro necessário a essa função é o diretório onde estão os arquivos do XAJAX;

As linhas a seguir são do formulário, observem que todos os elementos utilizados na validação tem o parametro ID em sua tag.

Linha 21

Dentro da celula é criado um label com id=”resultado” para que a resposta da validação seja impressa dentro deste label;

Linhas 35 e 36

Nestas linhas criamos um botão, observe que seu type é type=”button” para que ele não submita a página, e ele ainda tem a tag onclick com uma função que irá chamar a validação dos campos. Dentro da função xajax_validaForm() passamos os valores dos campos nome e email.

validacoes.php

// Registra as funções no javascript
$ajax->registerFunction("validaForm");

####################################################
#### FUNÇÕES JAVASCRIPT REGISTRADAS PELO XAJAX	####
####################################################

function validaForm($nome = false, $email = false){

	// Instancia o objeto XAJAX response com
	// codificação padrão ISO-8859-1
	$objResponse = new xajaxResponse('ISO-8859-1');

	// Inicializa a variável de resultado
	$res = "";

	// Verifica os campos e atribui strings a $res
	if($nome == false)
		$res .= "Preencha o campo nome
\n";
	if($email == false)
		$res .= "Preencha o campo e-mail\n";

	// Verifica $res
	if(empty($res))
		$res = "Formulário preenchido com sucesso!";
	else
		$res = "".$res."";

	// Atribui a variável $res ao label resultado
	$objResponse->assign('resultado', 'innerHTML', $res);

	// Retorna a resposta de XML gerada pelo
	// objeto do xajaxResponse
	return $objResponse;
}

// Manda o ajax processar os pedidos acima
$ajax->processRequest();
?>

Linha 2 – Instânciamos o objeto xajax();

Linha 5 – Registramos uma função, a qual podemos chama-lá com JavaScript (função chamada no botão do arquivo form.php). A única coisa que devemos observar é que sempre que formos chamar alguma função em nosso HTML sempre deveremos colocar “xajax_ ” antes do nome da função;

Linha 11 – Criamos a função validaForm() com os parametros $nome e $email;

Linha 15 – Instânciamos o objeto xajaxResponde() com parametro ‘ISO-8859-1′, para que não precisemos ficar utilizando as funções de codificação(utf8_encode() e utf8_decode()) de caracteres do PHP;

Linhas 18 a 31 – Aqui simplesmente checamos se os campos foram preenchidos e configuramos a resposta que será impressa na tela;

Linha 34 – De todas, a mais interessante. O método $objResponse->assign() tem 3 parametros, o 1º (‘resultado’) é o ID do objeto que ele irá atribuir os dados que serão especificados nos parametros 2º (como seré atribuido) e 3º parametro (o que será atribuido), em nosso exemplo a varável $res;

Linha 38 – O objeto $objResponse retorna com a resposta de tudo que lhe foi atribuido;

Linha 42 – Aqui o Ajax processa tudo e pronto!

Agora é só testar.

Muitos podem até dizer que é muito mais fácil fazer isso utilizando javascript ou mesmo vbscript, eu concordo, mais a ideia aqui é somente exemplificar o uso do metodo assign() e de muitos outros que iremos conhecer numa próxima vez.

Faça aqui o download do exemplo acima.