Criando um Data Grid com POO e PHP5

Um data grid nada mais é do que a apresentação de dados em forma de tabela (lembra das <table></table>? Algo assim). Cada conjunto de registros é mostrado em uma linha, e o data grid pode ter funcionalidades de ordenação dos dados e opções para sua edição ou exclusão.

Classe Data Grid PHP

Com esta simples classe é possível criar um data grid a partir de um array com os dados que queremos apresentar na tabela. É simples criar e configurar e, com alguns comandos avançados, é possível alterar o seu comportamento para que seja possível implementar as necessidades habituais em uma estrutura desse tipo.

Essa classe foi criada com POO (Programação Orientada a Objetos) e características que estão disponíveis somente a partir do PHP5. Ela pode ser baixada clicando aqui.

Vamos começar a ver como funciona a classe utilizando um exemplo simples e inserindo funcionalidades no decorrer do artigo, para deixar nosso exemplo mais robusto.

Para começar é necessário inserir a classe nos scripts PHP antes de utilizá-la.

//incluimos a classe

require 'DataGrid.php';

Agora temos que criar um Array com os dados que serão apresentados no Data Grid. Será um array associativo, duas dimensões, onde a primeira, o array principal, receberá todos os registros a serem mostrados no data Grid, e na segunda estão cada um dos registros definidos como um array associativo.

Agora construímos o array com um algumas informações, mais adiante veremos como construir esse array através de uma consulta ao banco de dados.

//criamos o array com os dados a serem apresentados no Data Grid

$alunos = array(

array("id" => 1, "nome" => "Pepe Perez", "curso" => "Informática básica", "nivel" => 2),

array("id" => 2, "nome" => "María Suarez", "curso" => "Informática avançada", "nivel" => 1),

array("id" => 3, "nome" => "Roberto Soriano", "curso" => "Sistemas operacionais", "nivel" => 2),

array("id" => 5, "nome" => "Alberto Rodriguez", "curso" => "Inglés técnico", "nivel" => 1),

array("id" => 7, "nome" => "Julia Marcos", "curso" => "Sociologia", "nivel" => 3),

array("id" => 10, "nome" => "Socorro Rozas", "curso" => "Informática básica", "nivel" => 1),

array("id" => 11, "nome" => "Pablo Reñones", "curso" => "Informática básica", "nivel" => 2)

);

Agora, antes de continuarmos com a construção da estrutura, temos que criar alguns estilos CSS para podermos melhorar o aspecto do Data Grid

<style type="text/css">

.linhaI{background-color:#ffffcc;}

.linhaP{background-color:#ffcc99;}

.fdg_sortable {cursor:pointer;text-decoration:underline;color:#00c;}

</style>

Foram criadas três classes CSS, com seus respectivos estilos. As classes “linhaI” (linha ímpar) e “linhaP” (linha par) aplicaram estilo às linhas do Data Grid e a classe “fdg_sortable” é responsável por estilizar os títulos de cada coluna do Data Grid.

Vamos criar o data grid a partir dos dados que temos no array.

//instanciamos o objeto data grid, passando como parâmetro o array anterior

Fete_ViewControl_DataGrid::getInstance($alunos)

//VAMOS LANÇANDO DIVERSOS MÉTODOS SOBRE O OBJETO INSTANCIADO

//atributos gerais para a tabela

->setGridAttributes(array('cellspacing' => '3?, 'cellpadding' => '4?, 'border' => '0?))

//permitimos que hajam características de ordenação

->enableSorting(true)

//fazemos um setup das colunas do data grid, indicando o valor que será mostrado na primeira linha do data grid

->setup(array(

'id' => array('header' => 'ID'),

'nome' => array('header' => 'Nome'),

'curso' => array('header' => 'Curso'),

'nivel' => array('header' => 'Nivel curso')

))

//definimos os estilos para as linhas ímpares

->setRowClass('linhaI')

//definimos os estilos para as linhas pares

->setAlterRowClass('linhasP')

//chamamos o método que construirá o data grid

->render();

Todas as linhas foram comentadas para que o entendimento se torne mais simples.

Agora vejamos como inserir ou apagar coisas do data grid, para personalizá-lo. Faremos algumas coisas como:

1. Vamos ocultar o “ID” do array associativo, para que não seja mostrado.
2. No campo de nível do cursos, vamos mostrar o nível com alguns asteriscos usando uma função que converterá os números em uma cadeia de asteriscos.
3. Vamos coluna no data grid, que aparecerá antes de qualquer outra, para mostrar um contador que indicará a quantidade de registros apresentados.

Destas três coisas, a mais complicada é fazer um modelo para alterar a forma como é mostrado um campo. Para começar, precisaremos de uma função que devolva o dado que se quer mostrar, com o formato desejado.

function nivel_estrelas($num){

$estrelas = "";

for ($i=0; $i<$num; $i++){

$estrelas .= "*";

}

return $estrelas;

}

Utilizaremos essa função para atribuir como “template” para o campo nível de curso.

Vamos agora ao código utilizado para implementar todas as funcionalidades citadas no data grid:

//OCULTAR UM CAMPO NO DATA GRID

//COLOCAR UMA FUNÇÂO PARA MOSTRAR UM CAMPO

//COLOCAR UM CAMPO ANTES DAS COLUNAS DO ARRAY DO DATA GRID

Fete_ViewControl_DataGrid::getInstance($alunos)

->setGridAttributes(array('cellspacing' => '3?, 'cellpadding' => '4?, 'border' => '0?))

->enableSorting(true)

//fazemos com que o campo "id" do array associativo não seja mostrado

->removeColumn('id')

->setup(array(

'nome' => array('header' => 'Nome'),

'curso' => array('header' => 'Curso'),

//utilizamos a função template para mostrar o nivel do curso com umas estrelas

'nivel' => array('header' => 'Nivel curso', 'cellTemplate' => '[[nivel_estrelas:%data%]]')

))

//inserimos uma coluna em todos os registros do data grid(a primeira coluna será esta)

//nesta coluna mostramos um contador de registros

->addColumnBefore('Contador', '%counter%.', 'Num', array('align' => 'right'))

//definimos a partir de que número será iniciado o contador

->setStartingCounter(1)

->setRowClass('linhaI')

->setAlterRowClass('linhaP')

->render();

Novamente as linhas foram comentadas para facilitar o entendimento. Chamo a atenção sobre a linha que faz uso da função anterior como um template para um campo.

'nivel' => array('header' => 'Nivel curso', 'cellTemplate' => '[[nivel_estrelas:%data%]]')

Isto faz com que o campo “nivel”, quando for mostrado em linhas distintas do data grid, chame a função nivel_estrelas(), passando como parâmetro %data%, que é o valor que tem cada um dos registros do array associativo, no campo “nível”.

Por último vamos ver outro exemplo, um pouco mais desenvolvido, para mostrar os dados do mesmo array. Neste caso vamos simplesmente mostrar uma coluna adicional ao final de cada registro do data grid, onde iremos inserir uns links para editar e/ou apagar o registro atual.

//PARA COLOCAR UM BOTÃO PARA EDITAR OU APAGAR
Fete_ViewControl_DataGrid::getInstance($alunos)
->setGridAttributes(array('cellspacing' => '3?, 'cellpadding' => '4?, 'border' => '0?))
->enableSorting(true)
->removeColumn('id')
->setup(array(
'nome' => array('header' => 'Nome'),
'curso' => array('header' => 'Curso'),
'nivel' => array('header' => 'Nivel curso', 'cellTemplate' => '[[nivel_estrelas:%data%]]')
))
->addColumnBefore('Contador', '%counter%.', 'Num', array('align' => 'right'))
//agora mostro um campo depois de cada elelemto, com links para editar ou apagar o registro
//no interior deste campo utilizo $id$ para enviar o valor "id" do array
->addColumnAfter('actions', '<a href="exemplo3.php?editar=$id$">Editar</a> ?
<a href="exemplo3.php?apagar=$id$" onclick="return confirm('Está certo que quer apagar $nome$?')">Apagar</a>', 'Actions', array('align' => 'center'))
->setStartingCounter(1)
->setRowClass('linhaI')
->setAlterRowClass('linhaP')
->render();

Neste exemplo apenas inserimos uma linha de código para fazer uma chamada ao método addColumnAfter(), que serve para inserir uma coluna depois das colunas que formamos com o array.

->addColumnAfter('actions',
'<a href="exemplo3.php?editar=$id$">Editar</a> ? <a
href="exemplo3.php?apagar=$id$" onclick="return confirm('Está certo que
quer apagar $nome$?')">Apagar</a>', 'Actions', array('align'
=> 'center'))

Neste caso simplesmente temos que indicar como parâmetro a addColumnAfter() dois dados: o primeiro para especificar um título para a coluna e o segundo para especificar o seu conteúdo. O conteúdo dessa coluna, neste caso, são os links para editar e apagar, onde são utilizadas urls que enviam os dados por GET, que é o identificador do registro.

Montando o data grid a partir de um banco de dados

Só falta agora falar sobre como extrair os dados de uma base de dados para fazer o array de elementos que será utilizado na montagem do data grid.

No exemplo que acompanha a classe data_grid há um código para extrair a informação do MySQL, como pode ser visto nas linhas abaixo.

$users = array();

$result = mysql_query("SELECT * FROM user", $dbLinkId);

while ($row = mysql_fetch_assoc($result))

{

$users[] = $row;

}

Como se pode ver, primeiro se cria um array e logo se faz um looping pelos resultados da consulta. Cada um dos elementos retornados pela consulta será introduzido no array criado anteriormente e para ele assinalamos o array associativo que nos devolverá mysql_fetch_assoc() desse primeiro array.

Bom, pessoal, espero que esse artigo possa ser útil a vocês. Clique abaixo para poder fazer o download da classe e de um exemplo.

Clique aqui para baixar a classe data grid junto com um exemplo

Fonte: Imasters

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

Manipulação de dados BLOB com PHP e MySQL

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

<!-- ...código anterior -->
<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>
<!-- ...código posterior -->

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

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.";

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

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]
<br>
$fila[nome] ($fila[tipo])
<br>
<a href='baixar_arquivo.php?id=$fila[id]'>Fazer Download</a>
<br>
<br>";
}

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;

Gerando planilhas XLS para o Excel pelo PHP

<?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");

$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);

$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);

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

$workbook->close();

Escopo e variáveis super poderosas

Variáveis globais são aquelas definidas na raiz do script, fora de qualquer outro escopo, e que não existem dentro de uma função ou método, da mesma forma que variáveis criadas em um desses escopos deixarão de existir fora dele.

As variáveis superglobais, entretanto, podem ser acessadas em qualquer escopo, e são elas $GLOBALS, $_SERVER, $_GET, $_POST, $_COOKIE, $_FILES, $_ENV, $_REQUEST e $_SESSION. Acontece que não é possível definir uma outra variável como superglobal (ao menos não sem o uso da Runkit), e aí a confusão começa.

A partir de um escopo, para declarar que uma variável pertence ao escopo global, utiliza-se a keyword global dentro desse escopo, mesmo que a variável ainda não tenha sido definida, quando nesse caso passará a existir se definida pela função.

<?php
$chamadas = 0; 

function carregar(){
 global $chamadas, $artista; 

 $chamadas++;
  $artista = "Whitesnake";
} 

carregar();
echo $artista, " - ", $chamadas; // Whitesnake - 1
?>

Contudo, são inúmeras as vezes que observei o uso incorreto do global, fora de qualquer escopo, com o objetivo de tornar a variável uma superglobal. Mas na realidade, além de constatar o óbvio declarando que uma variável global pertence ao próprio escopo global, isso simplesmente não funciona e obriga o desenvolvedor a utilizar a keyword global novamente dentro do escopo onde deseja ter o acesso.

O diagrama acima evidencia as superglobais na direita, acessíveis de qualquer lugar, as variáveis ao fundo limitadas aos seus respectivos escopos e, compondo a linha de frente, as variáveis globais, existentes ao longo do script e que podem ser utilizadas em um determinado escopo com o uso da keyword global. Então mesmo que você chame sua variável de Docinho, ela não vai se tornar uma superglobal.

Outra maneira de utilizar variáveis globais é pela superglobal $GLOBALS, uma array associativa com referência às variáveis no escopo global.

É importante observar ainda que, de uma forma geral, variáveis globais são uma causa comum de problemas, já que você não sabe se o valor é realmente o que você espera que seja. Um método simples de evitar isso é passar as variáveis necessárias como parâmetro para a função ou objeto que vai utilizá-las.

Eu só consegui perceber o problema de confiar em variáveis globais com a ajuda da minha mãe. Certa vez ela deixou um pudim delicioso na geladeira, e na manhã seguinte colocou uma travessa de peixe na prateleira de baixo. Pronto, o pudim ficou com gosto de sardinha o resto da semana. E foi assim que eu aprendi que devo separar minhas variáveis em lugares seguros, evitando que fatores externos acabem estragando tudo sem que eu sequer perceba.

E pra ficar claro, o que foi abordado nada tem a ver com o uso da diretiva register_globals que, quando ativada, define o conteúdo de $_ENV, $_GET, $_POST, $_COOKIE e $_SERVER como variáveis globais. Então $_POST['nome'] também passa a existir como $nome, $_GET['pagina'] também como $pagina, e assim por diante. Este terrível fenômeno está desativado por padrão desde a versão 4.2 e será removido por completo no PHP 6.

Referências

• Escopo de variáveis
• Superglobais predefinidas
• (Não) Utilizando a diretiva Register Globals
• Ferramenta case utilizada no diagrama de escopo de variáveis

Fonte: Imasters

Consultar bolsa de valores por PHP

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:

<?php

            $url_base = "http://www.theoziran.org/webservice/bovespa/";

            $indice = "petr4";

            $url_xml = $url_base.$indice;

            $xml_string = file_get_contents($url_xml);

            $simple_xml = simplexml_load_string($xml_string);

            //O ativo consultado

            $simple_xml->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

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:

<?php
//Nome de usuário do banco de dados, nesse exemplo usei um usuário
//padrão do oracle,
//caso não dê certo é por que ele deve ter sido deletado ou a senha
// alterada após
//a instalação do oracle.
ora_user = "scott";
//Senha do usuário no banco de dados.
ora_senha = "tiger";
//Nesse bloco do código, especificamos as definições do banco de dados,
//como o protocolo
//de comunicação o protocolo utilizado  foi o TCP, o ip do servidor onde
//se encontra o banco de dados
//e a porta de conexão , geralmente por padrão a porta utilizada pelo
//Oracle  é a porta 1521,
//caso não dê certo com a porta 1521, alguém pode ter alterado-a no
//durante a instalação,
//e por último a instância do banco que aqui utilizamos a instância ORCL.
//Caso não dê certo nessa instância é por que no momento da instalação ela
//foi criada com um nome diferente.
ora_bd = "(DESCRIPTION=
          (ADDRESS_LIST=
            (ADDRESS=(PROTOCOL=TCP)
              (HOST=192.168.0.2)(PORT=1521)
            )
          )
          (CONNECT_DATA=(SERVICE_NAME=ORCL))
     )";
//Nesta linha fazemos a conexão com o banco usando os variáveis preenchidas
//anterior mente, logo em seguida fazemos uma verificação, se a conexão ocorreu
//com sucesso, será impresso na tela uma mensagem avisando nos de tal,
//caso não, ele imprimirá na tela uma mensagem avisando que houve um erro
if (ora_conexao = OCILogon(ora_user,ora_senha,ora_bd) )
	echo "Conexão bem sucedida. Usuário conectado: ora_user";
else
	echo "Erro na conexão com o Oracle.";
?>

Agora é só começar a programar mais!

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

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:

<?php
class Carro {
    public $marcha;
    public function reduzirMarcha() {
        $this->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:

<?php
$corsa = new Carro();
$corsa->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:

<?php
class Carro {
    public static $quantidade;
    public function __construct() {
        self::$quantidade++;
    }
}
$corsa = new Carro();
$gol   = new Carro();
echo Carro::$quantidade; //irá retornar 2. (duas instancias de carro)
?>

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

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

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

<?php
require "./library/xajax/xajax_core/xajax.inc.php";
require "./library/validacoes.php";
?>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>INTRODUÇÃO AO XAJAX</title>
<?php $ajax->printJavascript('./library/xajax/'); ?>
</head>
<body>
<form id="form" name="form" method="post" action="">
  <table width="300" border="0"
  		align="center" cellpadding="1" cellspacing="1">
    <tr>
      <td colspan="2"><p>INTRODUÇÃO AO XAJAX</p><p>Validado o formulário </p></td>
    </tr>
    <tr>
      <td width="73"> </td>
      <td width="220"><label id="resultado"></label></td>
    </tr>
    <tr>
      <td align="right">Nome:</td>
      <td><input name="nome" type="text" id="nome"
	  					size="25" maxlength="50" /></td>
    </tr>
    <tr>
      <td align="right">E-Mail:</td>
      <td><input name="email" type="text" id="email"
	  					size="25" maxlength="75" /></td>
    </tr>
    <tr>
      <td> </td>
      <td><input name="btn" type="button" value="Validar"
onClick="xajax_validaForm(document.getElementById('nome').value, document.getElementById('email').value);"/></td>
    </tr>
  </table>
</form>
</body>
</html>

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

<?php
$ajax = new xajax();

// 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<br />\n";
	if($email == false)
		$res .= "Preencha o campo e-mail\n";

	// Verifica $res
	if(empty($res))
		$res = "<font color=green>Formulário preenchido com sucesso!</font>";
	else
		$res = "<font color=red>".$res."</font>";

	// 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.

• Categorias

  • .Net
  • ASP
  • Banco de Dados
  • Carreira
  • Design
  • Dicas
  • FLEX
  • Gimp
  • Google API
  • Internet
  • Java
  • JavaScript/Ajax
  • MySQL
  • Noticias
  • Oracle
  • Photoshop
  • PHP
  • Programação
  • Ruby on Rails
  • SQL Server
  • Tecnologia

• Blogroll

  • Comando Digital
  • Professional Blogger
  • WebSapiens

• Tópicos recentes

  • Problemas em provedores causam falhas em serviços do Google, diz empresa
  • Criando menus e páginas administrativas no WordPress: Parte 2
  • Criando menus e páginas administrativas no WordPress: Parte 1
  • Twitter reforça segurança e lança encurtador de URL
  • Nova plataforma da Cisco trafega até 322 terabits por segundo
  • TVs 3D estão chegando à sua sala!
  • YouTube lança legendas automáticas
  • Como usar Skype em celulares
  • EUA Revalam parte de sua estratégia contra ciberataques
  • Google anuncia mais uma compra desta vez de um site de edição de fotos

• Ofertas Submarino