Objota O mundo orientado a objetos

URL amigável com htaccess

Posted on dezembro 26, 2010

Posted by Rodrigo Ireno

Neste artigo vamos entender um pouco sobre a técnica de reescrita de url para torná-las “amigáveis”. Tudo isso através de configurações no arquivo .htaccess, um arquivo de configuração que serve, entre outras coisas, para mascarar URL’s. Fazendo bom uso deste arquivo de configurações podemos transformar url’s complexas e ilegíveis no que chamamos de: url’s amigáveis. Essa técnica é uma das primeiras a ser mencionada quando se ouve a sigla SEO, pois através dela é possível ganhar pontos com motores de busca como Google, Yahoo, Msn e etc.

Rewrite Engine

Um comando de configuração do arquivo htaccess. Como isso é possível? Simples. Na prática o responsável por mascarar a URL é o servidor web. O servidor Apache, pioneiro nesta técnica, implementa um módulo Mod_Rewrite, responsável pelo processamento das urls mascaradas.

O que eu ganho com isso

  • Como dito antes, facilidade na indexação de informações por motores de buscas.
  • A url se torna amigável e de fácil leitura para leitores humanos.
  • E segurança fazendo bom uso das expressões regulares é possível evitar SQL Injection.

Qual é a importância

Todos os motores de busca, ao indexar uma página web, avaliam o conteúdo da página, as palavras chave, e entre outras coisas, as URLs. Em geral ele avalia se as palavras encontradas no conteúdo e vai contando os pontos. Caso haja uma coerência entre todo o conjunto a página ganha pontos na indexação.

No caso dos motores Google, existe toda uma documentação listando uma série de recomendadas a serem seguidas para uma melhor indexação. A real técnica de avaliação é desconhecida, neste caso para eles o segredo é a chave para o sucesso.

Primeiros passos

Se você vai testar em seu serviço de hospedagem ou em um localhost não precisa se preocupar, pois praticamente todos os servidores já possuem o Mod_Rewrite abilitado. Por isso não abordarei como ativá-lo, mas para os curiosos segue o link: Como ativar o Mod_Rewrite do htaccess.

Vamos então direto ao assunto de como reescrever urls, primeiro vou descrever as linhas para depois abaixo visualizar todo o conjunto.

RewriteEngine on
Este comando ativa o modulo de reescrita do apache.

RewriteRule [expressão de mascaramento] [endereço real]
Este comando é quem realmente mascara uma url. Ele filtra requisições através da expressão regular empregada e aponta o requisitante para o endereço real do arquivo.

Obs: O endereço real ainda pode ser requisitado em qualquer momento.Pois ele só foi mascarado e não bloqueado, ou seja, ele só não é “conhecido”.

^
Este circunflexo indica o início de uma expressão regular.

^carro
Casa com qualquer coisa que comece com a palavra carro

$
Este indica o fim de uma expressão regular.

carro$

Casa com qualquer coisa que termina com carro.

Vamos então imaginar agora um arquivo php, que ao receber uma variável via url possa então printar na tela o seu conteúdo. O nome da variável é indice.

Vejamos então como seria.


<?php

if($_GET['indice']){
	echo $_GET['indice'];
}

?>

O nome deste arquivo seria então: arquivo.php

Salve este arquivo na raiz de seu  htdocs e lá mesmo crie um arquivo .htaccess (exatamente como está descrito, sem extensão nem nada). Uma curiosidade a respeito é que no sistema operacional LINUX o “ponto” na frente de um nome de arquivo significa que ele é oculto. Ele pode ser criado mesmo sem conteúdo com o bloco de notas. Certifique-se de que realmente seja um arquivo htaccess e não um arquivo de texto.

Vejamos o primeiro exemplo

RewriteEngine on

RewriteRule ^reescrita\/(.*)\.html arquivo.php?indice=$1

Este primeiro exemplo faz o seguinte. Ele recebe uma requisição qualquer e pega o conteúdo da variável $1 e joga na variável indice, que é passada via get para o arquivo php. Que por sua vez printa o conteúdo da variável na tela.

Mas o que existe na variável $1. Este sifrão seguido por um número indica que seu conteúdo é o resultado do processamento da primeira substring da requisitada. Ou seja, tudo o que vier dentro dos parênteses será repassado para ela.

Agora vejamos a expressão empregada neste caso era esta: (.*)

Os parênteses representam a substring e o “ponto e asterisco” são a expressão regular. Este comando aceita qualquer tipo de entrada: Letras, números, caracteres especiais e etc. Porém é possível barrar este tipo de entrada.

Mas antes disso, faça uma requisição para a seguinte url e veja o resultado:

http://localhost/reescrita/mariazinha.html
faça as devidas correções caso seja necessário.

Se tiver reparado no resultado vai ver que “mariazinha” foi printado na tela. Logo então faça isso pelo seu endereço real:
http://localhost/arquivo.php?indice=mariazinha

E verá que o resultado é o mesmo, porém não com a beleza e organização do primeiro. Basicamente foi isso que foi feito. Pegamos mariazinha de uma substring da expressão regular e jogamos na variável indice passada via get.

Segundo Exemplo

Existem milhares de possibilidades. Porém vejamos outro exemplo. Suponhamos que agora o conteúdo da variável indice precise ser necessariamente um número. Pois este número deve fazer referência a um índice primário de um registro em meu banco de dados.

RewriteEngine on

RewriteRule ^reescrita\/([0-9]+)\.html arquivo.php?indice=$1

Com este exemplo eu exigi que o conteúdo passado fosse um número, caso não obedeça a estes parâmetros a página será dada como não encontrada.

Vejamos o resultado.

Digitando o mesmo:

http://localhost/reescrita/mariazinha.html

e agora com

http://localhost/reescrita/23.html

Se tudo correu bem o segundo exemplo, com um número, teve sucesso e printou na tela o número fornecido.

Considerações finais

Bom este foi um breve tutorial de como se utilizar de urls amigáveis, para principalmente melhorar o seu SEO. Se você possui um blog como o wordpress ele possibilita fazer o mesmo através dos permalinks, é fato que ele coloca uma interface entre você e o htaccess mas este tipo de configuração existe.
Se você mesmo possui um site que ao gerar conteúdo,e gera evidentemente  seus próprios links, veja uma dica. Ato praticado por muitos que prezam pelo SEO de seu site.

Ao invés de possuírem links extremamente complexos com números letras caracteres ilegíveis apelam para a simplicidade de passar os IDs e o título do conteúdo.

Como seria isso:

Titulo: A escola de Mariazinha

Pode ser virtualizado em:

a-escola-de-mariazinha

Assim podendo ser empregado desta forma

URL: http://www.meusite.com.br/23/a-escola-de-mariazinha.html
Expressão: ^([0-9]+)\/(.*)\.html$ arquivo.php?indice=$1
ou
URL: http://www.meusite.com.br/a-escola-de-mariazinha-23.html
Expressão: ^(.*)-([0-9]+)\.html$ arquivo.php?indice=$2

Sendo que o número 23 poderia ser o id deste registro ou de sua categoria, depende muito de como funciona a arquitetura de seu site.

Mas se atente no fato de que isso torna sua url extremamente coesa, pois carrega em si o próprio título do artigo. E se atente também para o fato de que para alguns isso é o mínimo de SEO que poderia ser empregado em um site que busca ser bem indexado.

Finalizo então este artigo aqui. Segue uma referência para estudo de expressões regulares. Para melhor entender sobre o apache e o htaccess nada melhor que olhar um pouco sua documentação oficial.

Entendendo as Expressões Regulares

Porém, seguido deste artigo vou escrever outros que mostrarão mais possibilidades com o htaccess.

Essa foi minha dica. Qualquer dúvida poste aí.

Marcação de dados com: XML e JSON

Posted on dezembro 4, 2010

Posted by Rodrigo Ireno

Olá leitores do objota, há algum tempo já queria escrever a respeito de XML e JSON. Sendo os dois tipos de linguagem de marcação mais usados nas transferências de dados entre plataformas diferentes (sistemas de linguagens distintas), ou para uma simples aplicação com JavaScript.

Até em um comentário de um leitor citei que iria escrever sobre o assunto, porém era um título diferente do atual. Então chega de conversa 🙂

O FORMATO XML

Vamos começar pelo formato XML. Este formato de dados foi consolidado pelo W3C, sendo iniciados estudos em meados das décadas de 1990. O objetivo era criar um tipo de formato que poderia ser lido por software e que tivesse flexibilidade e simplicidade, visando, entre outras coisas:

  • Possibilidade de criação de tags (você é quem cria as tags)
  • Concentração na estrutura da informação e não em sua aparência

Ele segue um método hierárquico de formatação. Assim sendo possui tags-pai e tags-filho, e assim por diante. A grande vantagem de utilizá-lo é o fato de ser tão consolidado pelas diversas tecnologias de hoje, como navegadores e editores de texto que já reconhecem sua estrutura destacando o que é tag do que é conteúdo. Na própria Wikipédia exite uma série de relatos a respeito de suas vantagens e desvantagens.

Estrutura XML

O XML é constituído da seguinte forma:

  • Cabeçalho
  • Tag-Root

Isso é o mínimo para que seu XML seja considerado um XML. Vejamos um exemplo de cabeçalho:

<?xml version="1.0" encoding="ISO-8859-1"?>

Version: A sua atual versão é a 1.0, isso implica no modo como os interpretadores farão a leitura deste.

Encoding: Isso informa ao interpretador (software que fará a leitura) qual o tipo de padrão de caracteres utilizados no conteúdo deste xml. O Padrão popular internacional é o UTF-8 e o nacional é o ISO-8859-1.

A tag ROOT é uma tag que engloba todas as tags do seu XML, sendo sua função mostrar onde é o começo e o fim do seu XML. Um exemplo seria a tag <html> do padrão HTML, que indica onde inicia o conteúdo de uma página web, e </html> indica onde é o fim.

Agora Veja um exemplo de XML:


<?xml version="1.0" encoding="ISO-8859-1"?>
<populacao>
	<pessoa>
		<idade>23</idade>
		<nome>Henrrico<nome>
	</pessoa>
	<pessoa>
		<idade>32</idade>
		<nome>Maria<nome>
	</pessoa>
</populacao>

É possível utilizar comentários como no HTML:
<!- Meu comentário -->

E por vezes precisamos introduzir em nosso XML algum tipo de caracter especial, como por exemplo o próprio abre tag<”. Mas como fazer isso?

É preciso utilizar o comando CDATA da seguinte forma:


<?xml version="1.0" encoding="ISO-8859-1"?>
<mat>
	<expressao>
	<![CDATA[ 350 > 50 ]]>
	<expressao>
</mat>

Obs: o conteúdo da tag expressao é somente: “350 > 50”

O FORMATO JSON

JSON, um acrônimo para “JavaScript Object Notation”. Formato de intercâmbio de dados computacionais. Muito popular graças ao JavaScript, o qual permite criar um analisador JSON facilmente utilizando a função eval(). Mas como isso é possível?

Simples. Esta função é capaz de transformar string em comandos reais, sendo assim se eu escrever um objeto em formato JSON, e aplicar a função eval() nele. Poderei então utilizá-lo como se fosse um objeto iniciado com uma função new (comando padrão na inicialização de objetos).  Vejamos um exemplo abaixo.


{ MinhaLista : [
	{nome: "João",fone: "11-8579-6541" },
	{nome: "Pedro", fone: "12-6854-8452"}

	]
}

Agora vejamos como acessar esses dados com javascript:


var StringDeObjeto = '{MinhaLista : [{nome: "João",fone: "11-8579-6541" },{nome: "Pedro", fone: "12-6854-8452"}]}';

objeto = eval('('+StringDeObjeto+')');

alert( "Nome :"+objeto[0].nome+
       "\nFone :"+objeto[0].fone+"\n\n"+
       "Nome :"+objeto[1].nome+
       "\nFone :"+objeto[1].fone );

Cuidado, existe diferença entre processar um json no javascript e processar uma string com conteúdo em formato json. Veja que no caso acima usei uma string, por tanto tive que usar a função eval().

Sendo um formato bem mais simples que o XML, e mais enxuto. Acabou se tornando uma boa solução para os peixes grandes da web, como YAHOO e GOOGLE que servem milhões de usuários todos os dias.

Existem pessoas que persistem na ideia de que JSON é melhor do que XML, pois é mais simples e por tanto mais rápido de processar. Porém convenhamos, há espaço para todos. Afinal cabe ao profissional saber quando usar uma chave de fenda ou uma faca para resolver um problema.

Bom galera é isso, sei que existem muitos formatos de marcação de dados, porém esses são os mais populares e largamente utilizados por diversos tipos de sistemas. Neste artigo existe um exemplo de uso  do formato JSON.  Espero que tenha enriquecido um pouco o seu conhecimento! E futuramente iremos ver mais exemplos que façam uso destes formatos.

valew 😉

Usando classe de conexão com PDO – (exemplos práticos)

Posted on novembro 1, 2010

Posted by Rodrigo Ireno

Este artigo é uma complementação para o artigo anterior sobre PDO. Neste artigo viso ressaltar alguns detalhes não abordados anteriormente e utilizar de exemplos práticos.

Como mencionado no artigo anterior o uso do pdo facilitou muito mudar de banco de dados, porém isso não irá te livrar de uma diferença na sintaxe dos seus comandos SQL. Isso mesmo! Nem tudo é um mar de rosas com PDO.  Digamos que ele é um grande avanço para o php - afinal o Java já fazia uso deste tipo de estrutura. E como OOP agora é a bola da vez vemos pouco a pouco a transformação do php.

Outra coisa a mencionar é que não abordei como instalar o PDO, pois as atuais distribuições do php já vêm com PDO habilitado. Uma dica para os que quiserem saber quais drivers estão disponíveis para o seu servidor:

É comum não termos acesso ao php.ini de nossa hospedagem então, este é um modo de ver os drivers que estão habilitados na hospedagem que contratamos.


foreach(PDO::getAvailableDrivers() as $driver){
    echo $driver.'<br />';
}

Mas agora vamos ao que interessa, neste artigo vamos utilizar uma tabela no banco de dados Mysql para fazer algumas operações com ela utilizando pdo. Não será abordado como iniciar, pois outros artigos neste blog já descrevem este processo.

Nota: Sendo a única coisa a ressaltar de diferente do artigo anterior sobre PDO é que utilizei um array com argumentos no construtor:

array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION)

Pois estes permitem que erros sejam capturados como exceções por um bloco try/catch. Veja mais detalhes na documentação

Utilize este comando SQL para criar nosso banco e tabela clientes de exemplo ou crie manualmente.


CREATE DATABASE `objota` ;

CREATE TABLE `objota`.`clientes` (
`id` INT( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`nome` VARCHAR( 255 ) NOT NULL ,
`telefone` VARCHAR( 100 ) NOT NULL ,
`email` VARCHAR( 100 ) NOT NULL
) ENGINE = MYISAM ;

A primeira coisa que vamos fazer é inserir dados no banco. Abaixo um exemplo de inserção utilizando a classe PDO:


try{
    //executa as instruções SQL
    $oConexao->exec("INSERT INTO clientes (nome,telefone,email) VALUES ('Rodrigo', '11-333-555', 'rodrigo@objota.com.br')");
    $oConexao->exec("INSERT INTO clientes (nome,telefone,email) VALUES ('Marcos', '55-555-888', 'marcos@mm.com.br')");
    $oConexao->exec("INSERT INTO clientes (nome,telefone,email) VALUES ('Maria', '11-888-9999', 'maria@maria.com.br')");
}catch (PDOException $e){
        //se houver exceção, exibe
        echo $e->getMessage();
}

Como vemos utilizamos o método exec para executar comando SQL no banco de dados. Neste caso inserimos três registros.

Agora veremos como consultar utilizando os recursos da classe PDO:


try{
    //executa uma instrução de consulta
    $result = $oConexao->query("SELECT * FROM clientes");
    if($result){
          //percorre os resultados via o laço foreach
           foreach($result as $item){
                  //exibe o resultado
                  echo "Nome: ".$item['nome'] . " - " . $item['telefone'] . $item['email'] ."<br>\n";
           }
    }
}catch (PDOException $e){
        echo $e->getMessage();
}

Como vimos para executar uma consulta utilizamos a função query que retorna um objeto de resposta PDOStatement que pode ser percorrido utilizando um laço foreach.

Também é possível percorrer um objeto PDOStatement utilizando o método fetch dele e tratar cada linha da consulta como um objeto.

Vejamos:


try{
    //executa a instrução de consulta
    $result = $oConexao->query("SELECT * FROM clientes");

    if($result){
        //percorre os resultados via o fetch()
        while ($item = $result->fetch(PDO::FETCH_OBJ)){
            //exibe resultado
             echo "Nome: ".$item->nome. " - " . $item->telefone . $item->email . "<br>\n";
        }
    }
}catch (PDOException $e){
    echo $e->getMessage();
}

Agora veremos um recurso muito interessante do PDO, que consiste em preparar o comando antes de executá-lo. Como era de se esperar, vamos utilizar a função do PDOStatement, a prepare(). Vejamos abaixo:


try{
    //executa a instrução de consulta
    $oConexao->beginTransaction();

    $stmt = $oConexao->prepare("INSERT INTO clientes (nome,telefone,email) VALUES (?, ?, ?)");
    $stmt->bindValue(1, "Helio");
    $stmt->bindValue(2, "33-4444-5555");
    $stmt->bindValue(3, "helio@m.com.br");
    $stmt->execute();

    $oConexao->commit();

}catch (PDOException $e){
    $oConexao->rollBack();
    echo $e->getMessage();
}

Veja que neste caso eu utilizei o método beginTransaction() do objeto pdo, nosso objeto de conexão, este método abre uma transação com o banco de dados e desliga o "autocommit". A vantagem de se utilizar dele é que a operação só é commitada depois de toda a execução. E é você que tem que escrever esta função para finalizar a transação commit(), porém se o pdo capturar alguma exceção.

Ele pula para o bloco catch e a função rollback() se encarrega de retroceder as alterações feitas no banco, assim é possível garantir a medida do possível a integridade do banco e de seus dados.

Leia mais sobre transações sem autocommit em:

http://dev.mysql.com/doc/refman/4.1/pt/commit.html

Considerações finais:

Este artigo veio para fortalecer e complementar o artigo anterior sobre pdo. Espero que tenha sido esclarecedor. E mais uma observação. No início do artigo falei a respeito de alterar um atributo do pdo com esta estrutura inserida no construtor:

array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION)

Na documentação do pdo existem várias constantes como estas podendo ser utilizadas para as mais diversas coisas. Por tanto vale a pena dar uma olhada na documentação. Desta vez vou disponibilizar os arquivos necessários para a execução deste exercício. Até a próxima 😉

Download: Arquivos de Trabalho

Classes e Objetos em JavaScript

Posted on outubro 31, 2010

Posted by Rodrigo Ireno

O objetivo deste artigo é apenas mostrar a curiosa forma que toma uma classe feita em javascript puro.

Muitos usuários da biblioteca prototype não fazem questão de fazer desta forma afinal, nem sempre é viável. Para quem não sabe prototype é uma biblioteca que maximiza o poder de orientação a objetos do javascript. Porém no nosso caso presente, não a utilizaremos.

Veremos algumas coisas básicas comparando uma classe em php, por exemplo, e a classe em javascript.

A primeira coisa que podemos ver é que o JS não possui um envoltório chamado class para isso ele usa function.

Php:

class MinhaClasse{
 	//Aqui o conteúdo
}

JavaScript:

function MinhaClasse(){
 	//Aqui o conteúdo
}

Ótimo, e o construtor da classe. Em php se utiliza um método com o mesmo nome da classe ou __constructe. E em JS..  não tem!! Isso mesmo. O conteúdo do construtor fica mergulhado juntamente com os atributos.

Php:

class MinhaClasse{
        private $nome;
 	public function MinhaClasse($novoNome){
 		$this->nome = $novoNome;
 	}
}

JavaScript:

function MinhaClasse(novoNome){
  	var nome;
        this.nome = novoNome;
}

Vejamos agora uma declaração  dos famosos métodos get e set:

Php:

class MinhaClasse{
        private $nome;
 	public function MinhaClasse($novoNome){
 		$this->nome = $novoNome;
 	}
        public function getNome(){
 		return  $this->nome ;
 	}
        public function setNome($novoNome){
 		$this->nome = $novoNome;
 	}
}

JavaScript:

function MinhaClasse(novoNome){
  	var nome;
        this.nome = novoNome;
        this.getNome=function(){
 		return this.nome;
 	};
        this.setNome=function(otroNome){
 		this.nome = otroNome;
 	};
}

Agora vamos ver uma peculiaridade do javascript de passar uma função via parâmetro, ou dados no formato JSON. Veja como é simples:

Função via parâmetro:

function hello(){
 	document.write("Oi objota!");
}
function executaPraMim(funcaoQualquer){
 	funcaoQualquer(); //pronto! Ele chama a função
}

//passo uma função já implementada ou..
executaPraMim(hello());

//implementa-se no ato da parametrização
executaPraMIm(function(){
 	document.write("Essa eu implementei agora!");
});

Muito bacana não é!

Agora vejamos um exemplo bem simples de uma função que recebe dados no formato JSON.


function mostra(dados){
	Alert("O nome é: "+dados.nome+"\nemail: "+dados.email);
}
//vejamos a chamada
Mostra({nome: "Objota", email: "objota@teste.com.br"});

Neste artigo vimos como implementar classes, receber funções via parâmetro e dados no formato JSON. Neste artigo quis mostrar algumas peculiaridades do JS, nada em especial. Somente algumas dicas aos curiosos. Abaixo temos os exemplos completos coloque os dois arquivos no mesmo diretório e inicie a índex.html.

É isso! Até a próxima. Dúvidas, postem aí! 😉

Classes.js


//Classe Carro
function Carro(){
    var placa;
    var cor;

    this.getPlaca=function(){
        return this.placa;
    };

    this.setPlaca=function(novaPlaca){
        this.placa = novaPlaca;
    };
    this.getCor=function(){
        return this.cor;
    };

    this.setCor=function(novaCor){
        this.cor = novaCor;
    };
}

//Classe Pessoa
function Pessoa() {

    //@interface
    var nome;
    var idade;
    var email;
    var carro;
    //@end

    //@constructe
    this.carro = new Carro();
    this.carro.setPlaca(7520);
    this.carro.setCor("Amarelo");
    //@end

    //@implementation
    this.getCarro=function(){
        return this.carro;
    };

    this.getNome=function(){
      return this.nome;
    };

    this.getIdade=function() {
      return this.idade;
    };

    this.getEmail=function() {
      return this.email;
    };

    this.setNome=function(_nome) {
      this.nome = _nome;
    };

    this.setIdade=function(_idade) {
      this.idade = _idade;
    };

    this.setEmail=function(_email) {
      this.email = _email;
    };

    this.mostraValores=function() {
      return 'Nome: '+this.nome+
             '<br/>Idade: '+this.idade+
             ' anos<br/>Email: '+this.email+
             '<br/>Carro:<br/>* Placa:'+this.carro.getPlaca()+
             '<br/>**Cor: '+this.carro.getCor();
    };

    //Recebe uma função por parâmetro e executa
    this.executa=function(i,funcao){
          if(i > 0)
          funcao();
    };

    //Recebe dados no formato JSON via parâmetro
    this.mostraJson=function(dados){
          return 'Id:'+dados.id_conteudo+'<br/>Nome: '+dados.nome;
    };
    //@end
}

index.html


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Classes em javascript</title>
<script type="text/javascript" src="Classes.js"></script>
</head>

<body>
<script type="text/javascript">
  var Objota = new Pessoa();

  Objota.setNome('Objota - POO');
  Objota.setIdade(21);
  Objota.setEmail('email@objota.com.br');

  document.write(
    Objota.mostraValores()
  );
  document.write(
    Objota.getCarro().getPlaca()
  );

  //Altera placa do meu atributo carro, que é um objeto!
  Objota.getCarro().setPlaca(5051);

  //Passando função por parâmetro
  Objota.executa(1,function(){
      Objota.setNome('Rodrigo I.O.');
      Objota.setIdade(22);
      Objota.setEmail('bass_oliveira@hotmail.com');

      document.write(Objota.mostraValores());
  });

  //Passo dados no formato JSON via parâmetro {label: valor}
  document.write(Objota.mostraJson({id_conteudo: 50, nome: 'Manezinho'}));
</script>
</body>
</html>

Carrinho de compras orientado a objetos

Posted on setembro 1, 2010

Posted by Rodrigo Ireno

Carrinho de compras, por vezes temos curiosidade de saber qual é a melhor forma de implementar um. De fato não existe "melhor forma" existe a forma que funciona para a sua necessidade. Então vamos lá.

O objetivo deste artigo é mostrar como implementar um carrinho de compras utilizando sessão.

Para iniciar uma sessão e registrar variáveis nela é preciso iniciá-la com session_start(). Você pode ver nos seus cookies que vai aparecer um PHPSESSID que só permanecerá em seu computador durante a sua navegação no site. E bom, de fato isso é só pra te identificar.

Coloque esse session_start() no seu config.php

Quando jogamos variáveis ou objetos dentro de uma variavel de sessão o php gera um cookie no servidor, um arquivo de texto. Por isso não precisamos ficar com tanto medo de "sobrecarregar" a memória, pois isso fica no disco rígido e não na memória do servidor.

E qual é a grande vantagem de utilizar sessão, é que ela pode ser recuperada enquanto o usuário estiver navegando em seu site. Em qualquer lugar do seu site é possível criar uma veriavel na sessão e recuperá-la quando necessário.

Como seria isso?? Simples, você tem três paginas:

>index.php
>catalogo.php
>formulario.php

Vamos supor que o usuário navega pela index.php (session_start() já foi acionado lá no config), ele já tem uma PHPSESSID. Agora ele vai para o "catalogo.php" e escolhe alguns produtos. Ou seja, ele joga no carrinho (na sessão). A partir de agora é possível recuperar esse conteúdo em qualquer página fazendo a seguinte verificação:

	if(isset($_SESSION["nomeDaMinhaVariavel"])){
	//Entrou aqui, quer dizer que o valor existe.
	// e que você pode recuperá-la
	}

Bom, vamos então a nossa implementação, vamos criar um objeto Carrinho. E o objetivo deste carrinho é armazenar produtos. Vamos considerar os seguintes atributos para produto: id , nome, descricao.

id para podermos referenciar o produto escolhido, o nome do produto e uma breve descrição. Pois quando o usuário clicar em visualizar carrinho ele terá estas informações mais básicas para ver.

Vejamos a classe Carrinho, coloque ela no arquivo Carrinho.class.php para usar __autoload(), do último artigo!

Produto.class.php

<?php
class Produto{
	private $id;
	private $nome;
	private $descricao;
	private $quantidade;
	public function Produto($id, $nome, $descricao, $quantidade=1){
		$this->id = $id;
		$this->nome = $nome;
		$this->descricao = $descricao;
		$this->quantidade = $quantidade;
	}
	public function getQuantidade() {
		return $this->quantidade;
	}
	public function setQuantidade($quantidade) {
		$this->quantidade = $quantidade;
	}
	public function getId() {
		return $this->id;
	}
	public function getNome() {
		return $this->nome;
	}
	public function getDescricao() {
		return $this->descricao;
	}
	public function setId($id) {
		$this->id = $id;
	}
	public function setNome($nome) {
		$this->nome = $nome;
	}
	public function setDescricao($descricao) {
		$this->descricao = $descricao;
	}
}
?>

Carrinho.class.php

<?php
class Carrinho{
	private $produto;
	public function Carrinho(){}
        //Adiciona um produto
	public function addProduto(Produto $m){
		$this->produto[] = $m;
	}
        // Recupera um produto pelo id
	public function getProduto(int $idProduto){
		foreach($this->produto as $pro){
			if($pro->getId() == $idProduto){
				return $pro;
			}
		}
	}
        // Remove um produto pelo id
	public function removeProduto(int $idProduto){
		for($i=0;$i < count($this->produto);$i++){
			if($this->produto[$i]->getId() == $idProduto){
				unset($this->produto[$i]);
			}
		}
	}
        // lista todos os produtos
	public function listar(){
		foreach($this->produto as $pro){
			echo "<b>Código:</b> {$pro->getId()}<br/>
				  <b>Nome:</b> {$pro->getNome()}<br/>
				  <b>Descrição:</b> {$pro->getDescricao()}<br/>
				  --------------------<br/>";
		}
	}
}
?>

Depois de já criadas as entidades, vamos ao config, e depois as paginas que irão criar e recuperar o carrinho da sessão.

Config.php

Onde vamos configurar o __autoload()

<php
function __autoload($nomeClasse){
	//Verifica se existe a classe no diretório classes
	if(file_exists("classes/".$nomeClasse.".class.php")){
		//Se existe carrega
		include_once("classes/".$nomeClasse.".class.php");
	}
}
session_start();
?>

index.php

Onde vamos carregar o nosso produto

<php
include_once("config.php");

//Inicio o carrinho
$Carrinho = new Carrinho();

//Joga na sessão
$_SESSION["carrinho"] = $Carrinho;

//inicio dois produtos
$produto1 = new Produto(23,"Chave de Fenda","Chave de fenda blindada, com ponta em diamante");
$produto2 = new Produto(354,"Batedeira","Batedeira Braslenp, com três velocidades");

//Adiciona produto 1
$_SESSION["carrinho"]->addProduto($produto1);

//Adiciona produto 2
$_SESSION["carrinho"]->addProduto($produto2);

//Link para a página carrinho.php
echo "<a href=\"carrinho.php\">Meu carrinho</a>";
?>

Carrinho.php

Onde iremos recuperar o nosso produto da sessão

<?php
include_once("config.php");
//Recupera objetos da sessão
?>

<h2>Produtos no meu carrinho:</h2><br/>
<?php
if(isset($_SESSION["carrinho"])){
	$_SESSION["carrinho"]->listar();
}
else{
	echo "Não existem produtos no seu carrinho";
}
?>

Agora é só testar. utilize a estrutura de diretórios sugerida, ou uma de sua preferência.

Estrutura:
>index.php
>config.php
>carrinho.php
>classes>Carrinho.class.php
>classes>Produto.class.php

É isso meus caros, dúvidas e sugestões! postem aí. E até a próxima!

Utilizando Config para carregar suas classes

Posted on agosto 28, 2010

Posted by Rodrigo Ireno

Muito foi visto e comentado até agora a respeito de php e orientação a objetos, suas classes e recursos. Vamos então agora falar de um recurso muito importante do php na hora de utilizar suas classes.

Junto com este conceito, se você ainda não conhece, iremos falar de um arquivo chamado config. Que nada mais é do que um arquivo de configuração, onde se declara constantes do sistema (site), e onde geralmente se declara a função __autoload() do php.

Para este artigo vamos criar quatro arquivos:

index.php
config.php
Automovel.class.php
Carro.class.php

Config será nosso arquivo de configuração, index.php será o arquivo que será requisitado, e nossas classes serão carregadas pela função __autoload().

Como funciona o autoload?

Toda vez que você instancia um objeto esta função recebe por parâmetro o nome do objeto que você está instanciando. Sendo assim com o nome do objeto e uma pequena concatenação de string é possível incluir o arquivo da classe quando necessário.

Porém só é possível implementar isso uma vez, geralmente no config. Então fica bem mais fácil, pois você só precisa saber que pra carregar as classes é só dar um include no config.

Tendo isso em mente só é preciso estar atento a uma coisa. Mantenha um padrão de nomenclatura para suas classes, geralmente se faz assim:

NomeDaClasse.class.php -

O "NomeDaClass", em verde, é o mesmo nome declarado para a classe dentro do arquivo php. O final em vermelhor "class.php" é o sufixo adotado para a nomenclatura.

Vejamos abaixo um exemplo prático. Coloque as classes em um diretorio chamado classes e o restante dos arquivos no diretório raiz:

>classes>Automovel.class.php
>classes>Carro.class.php
>config.php
>index.php

Automovel.class.php


<?php
class Automovel{
	public function Automovel(){
		echo "Placa = BAE-5533<br/>";
	}
}
?>

Carro.class.php


<?php
class Carro extends Automovel{

	public function Carro(){
		parent::Automovel();
		echo "Numero de Rodas = 4";
	}
}
?>

config.php


<?php
function __autoload($nomeClasse){
	//Verifica se existe a classe no diretório classes
	if(file_exists("classes/".$nomeClasse.".class.php")){
		//Se existe carrega
		include_once("classes/".$nomeClasse.".class.php");
	}
}
?>

index.php


<?php
include_once("config.php");

//Instancio o objeto Automóvel
echo "<b>Instancio o objeto Automóvel</b><br/>";
$Automovel = new Automovel();

echo "<br/>";

//Instancio o objeto Carro
echo "<b>Instancio o objeto Carro</b><br/>";
$Carro = new Carro();
?>

Neste exemplo utilizamos um conceito já conhecido de um outro artigo, a herança de classes. Como deve ter visto na implementação, basta indicar o diretório das classes e a função autoload irá se encarregar de carregar as classes quando necessário. Veja que é você que tem que implementar esta função, por isso é muito importante verificar a existência do arquivo para depois incluí-lo, e use include_once ou include, pois caso ocorra algum erro no carregamento ele irá apresentar o erro, porém a aplicação seguirá em frente executando o resto do script.

Tudo certinho, agora acesse a página index.php e veja o resultado!

Bem mais fácil lembrar somente do endereço do config,  não !?

Esperimente criar mais classes no diretório classes. Até a próxima! 🙂

Classe de conexão com php utilizando PDO

Posted on agosto 22, 2010

Posted by Rodrigo Ireno

Olá neste artigo vamos aprender a fazer conexão com um banco de dados utilizando um recurso muito bacana que o php nos oferece, o PDO (PHP Data Object). Ele é um objeto que possibilita tornar sua "fábrica de conexões" - já vou exeplicar também - portável.

Imagine que você está usando o banco de dados MySql e que a vida é bela e seu sistema sempre usará este banco! lindo esse sonho não? 🙂

Tá! agora acorda! e veja como o mundo é cruel e as coisas não tão simples assim. Pois se você se baseia totalmente em usar funções como mysqli_connect() , mysqli_.. qualquer coisa., trate de terminar de ler este artigo!

E se esta galera! Estes métodos estão misturados em diversas partes do seu código! Vai te dar uma dor de cabeça sem tamanho, só de pensar em mudar de banco de dados. Pensando nessa, foi que desenvolveram um recurso no php, o PDO. Uma classe que se encarrega de fazer o gerenciamento dos drivers pra você. Isso mesmo! parece que existe uma luz no fim do túnel!

E lembra do que falei? - "fábrica de conexões"

Este é outro conceito muito usado, para garantir tanto uma certa organização quanto a integridade do banco de dados. É o pattern conhecido como Singleton.

Qual é a idéia? Manter uma instância única para que toda a aplicação possa utilizá-la. Veja como isso faz sentido ser utilizado principalmente para conectar-se com um banco. Toda vez que se conecta o banco abre uma porta, e se você criar conexões sem nenhum controle, dependendo do número de acessos que o seu site tiver ele vai derrubar o banco.

O conceito deste pattern está bem explícito na própria wikipedia, mas vamos fazer um código aqui também. Então vamos ao que intereça:

O PDO


/*
 Chega de funções, e funções. Tudo no método construtor do PDO
*/
$pdo = new PDO("tipoDeBanco:host=EnderecoDoHost;dbname=nomeDoBanco", "usuário", "senha" );

Veja só, o objeto já faz tudo numa tacada só. Depois disso é só ir trabalhando com ele e seus métodos de interface.

Executando uma query

Se estiver executando local, o host é localhost, senha não tem e usuário é root. Há e o tipo de banco de dados também!

<?php
try {
	// PDO em ação!
	$pdo = new PDO ( "mysql:host=localhost;dbname=tutorial", "root", "" );

	// Com o objeto PDO instanciado
	// preparo uma query a ser executada
	$stmt = $pdo->prepare("SELECT * FROM cliente");

	// Executa query
	$stmt->execute();

	// lembra do mysql_fetch_array?
	//PDO:: FETCH_OBJ: retorna um objeto anônimo com nomes de propriedades que
	//correspondem aos nomes das colunas retornadas no seu conjunto de resultados
	//Ou seja o objeto "anônimo" possui os atributos resultantes de sua query
	while ( $obj = $stmt->fetch ( PDO::FETCH_OBJ ) ) {

		// Resultados podem ser recuperados atraves de seus atributos
		echo "<b>Nome:</b> " . $obj->nome . " - <b>Telefone:</b> " . $obj->fone."</br>";
	}
	// fecho o banco
	$pdo = null;
	// tratamento da exeção
} catch ( PDOException $e ) {
	echo $e->getMessage ();
}
?>

obs: com a função fetch() é possível trazer os resultados de várias maneiras, este foi só um exemplo. O que determina o tipo de retorno é a constante "PDO::FETCH_OBJ", para mais informações vide manual. Sobre a função fetch().

Compare! um exemplo com o modo tradicional de conexão com MySql

Veja que está tudo dentro de um bloco try, catch. Para quem não sabe, o programa quando encontra um erro dentro de um bloco try, salta para o catch e consegue recuperar a exceção ou erro, por um objeto de exceção que vem por parâmetro. Para mais informações sobre o uso de pdo visite seu manual no site oficial do php.

A fabrica de conexões

Se você seguiu o link que existe ali em cima, já deve ter visto a página da wikipedia com exemplos em diversas linguagens do pattern Singleton, mas vamos terminar a coisa aqui pra não ficar dúvida! 🙂


<?php
class Conexao extends PDO {

	private static $instancia;

	public function Conexao($dsn, $username = "", $password = "") {
		// O construtro abaixo é o do PDO
		parent::__construct($dsn, $username, $password);
	}

	public static function getInstance() {
		// Se o a instancia não existe eu faço uma
		if(!isset( self::$instancia )){
			try {
				self::$instancia = new Conexao("mysql:host=localhost;dbname=conteudo", "root", "");
			} catch ( Exception $e ) {
				echo 'Erro ao conectar';
				exit ();
			}
		}
		// Se já existe instancia na memória eu retorno ela
		return self::$instancia;
	}
}
?>

Então fazendo uso desta classe toda vez que eu quiser fazer conexão com o banco eu uso o método implementado getInstance(), pois ele é quem vai me retornar uma conexão existente ou criá-la para mim.

Veja que eu coloquei direto alí os valores, senhas e talls.. pra conectar certo. Então, porém tanto pra php quanto pra java - falando de web - o ideal é centralizar todas as configurações em um único arquivo, para o site. Em java se faz uso do arquivo de configuração web.xml, já no php este arquivo de configuração geral é mais conhecido como config.

É nada mais nada menos que um arquivo com extensão .php que contem todas as configurações necessárias para o site. Acho que esse assunto ainda rende um post, vou colocar algo a respeito futuramente!
é isso obrigado por ler este post, e até a próxima! vlew 🙂

:: Este post possui uma complementação neste outro artigo! Usando Classe de Conexão com PDO (exemplos práticos)

Herança e Polimorfismo

Posted on julho 30, 2010

Posted by Rodrigo Ireno

Herança

Herança em orientação a objetos é algo simples de se entender, pois assim como um filho herda características do pai uma classe também herda características de uma superclasse. A superclasse pode ser uma classe pai, avô ou bisavô.

Enfim a superclasse vem antes da classe atual. E assim como em uma arvore genealógica uma superclasse pode ser uma subclasse de alguém, e assim sucessivamente.

Então, assim como um filho que herda os olhos do pai, uma classe herda atributos de sua super classe. E assim como (desconsidero as especulações científicas) um filho herda o temperamento e algumas atitudes do pai, uma classe herda métodos de sua super classe.

Mais que herdar atributos e métodos de uma classe para outra, existe uma real vantagem nisso tudo. Reaproveitamento de código! Afinal se já programei um método que faz exatamente isso na superclasse, pra que fazer isso outra vez? Minha classe irá herdar estes métodos e atributos! Entenderam? É simples o entendimento deste conceito, porém muito mais difícil é aplicá-lo. Mas isso fica por conta das camadas mais altas. Analistas, Engenheiros e Arquitetos de software.

Para programar em php uma classe que herda atributos e métodos de uma superclasse é muito simples. Basta usar a palavra chave "extends"

Ex: classeFilho extends classePai. Isso fica lá em cima na assinatura da classe. Veja um exemplo abaixo:


<?php
class Automovel{
	private $numeroPlaca;
	private $numeroDeRodas;

	public function Automovel($Placa, $nRodas){
		$this->setNumeroPlaca($Placa);
		$this->setNumeroDeRodas($nRodas);
	}

	public function setNumeroPlaca($novaPlaca){
		if($novaPlaca > 999 && $novaPlaca <= 9999)
		$this->numeroPlaca = $novaPlaca;
	}
	public function setNumeroDeRodas($novoNumeroRodas){
		if($novoNumeroRodas > 0)
		$this->numeroDeRodas = $novoNumeroRodas;
	}

	public function getNumeroPlaca(){
		return $this->numeroPlaca;
	}
	public function getNumeroDeRodas(){
		return $this->numeroDeRodas;
	}

}

class Carro extends Automovel{

	private $modelo;

	public function Carro($Placa, $nRodas, $modelo){
		parent::Automovel($Placa, $nRodas);
		$this->setModelo($modelo);
	}

	public function setModelo($nomeModelo){
		$this->modelo = $nomeModelo;
	}
	public function getModelo(){
		return $this->modelo;
	}

}

$obj = new Carro(8945,4,"Phusca");

echo "Modelo : {$obj->getModelo()}<br/>
	  Placa : {$obj->getNumeroPlaca()}<br/>
	  Rodas : {$obj->getNumeroDeRodas()}<br/>";

?>

Como visto no exemplo acima, a classe Carro "extend", ou seja, ela se estende a classe Automovel. Herdando atributos comuns a qualquer automóvel, veja que para elaborar uma estrutura de classes desta forma é preciso analisar bem o problema.

Repare que instanciei no final um objeto do tipo Carro e ele chama pelo método getNumeroPlaca() e getNumeroDeRodas(), sendo que ambos foram implementados na superclasse Automovel.

Nas duas classes ao declarar os atributos, utilizei private, pois isso deixa com um baixo grau de acoplamento. Porém em algumas circunstancias é necessário que uma subclasse “veja” atributos da superclasse, como se fosse public. Para isso declare como protected então esses atributos serão visíveis somente para a classe herdeira. Vide exemplo, com as mesmas classes:


<?php
class Automovel{
	protected $numeroPlaca;
	protected $numeroDeRodas;

	public function Automovel($Placa, $nRodas){
		$this->setNumeroPlaca($Placa);
		$this->setNumeroDeRodas($nRodas);
	}

	public function setNumeroPlaca($novaPlaca){
		if($novaPlaca > 999 && $novaPlaca <= 9999)
		$this->numeroPlaca = $novaPlaca;
	}
	public function setNumeroDeRodas($novoNumeroRodas){
		if($novoNumeroRodas > 0)
		$this->numeroDeRodas = $novoNumeroRodas;
	}

	public function getNumeroPlaca(){
		return $this->numeroPlaca;
	}
	public function getNumeroDeRodas(){
		return $this->numeroDeRodas;
	}

}

class Carro extends Automovel{

	private $modelo;

	public function Carro($Placa, $nRodas, $modelo){
		//parent::Automovel($Placa, $nRodas);

		//Atributos da superclasse visíveis somente dentro da classe Carro
		$this->numeroPlaca = $Placa;
		$this->numeroDeRodas = $nRodas;

		//Isto é da clase Carro
		$this->setModelo($modelo);
	}

	public function setModelo($nomeModelo){
		$this->modelo = $nomeModelo;
	}
	public function getModelo(){
		return $this->modelo;
	}

}

$obj = new Carro(8945,4,"Phusca");

echo "Modelo : {$obj->getModelo()}<br/>
	  Placa : {$obj->getNumeroPlaca()}<br/>
	  Rodas : {$obj->getNumeroDeRodas()}<br/>";

?>

Polimorfismo

Junto com esse conceito de herança está vinculado algo muito útil. O polimorfismo. A própria palavra já explica um pouco: polimorfismo (muitas formas) aqui está uma idéia bacana, um objeto genérico que pode em qualquer momento assumir uma forma específica. Muito útil quando você não sabe que objeto vem por aí.

Por exemplo, um método que recebe um objeto por parâmetro que pode variar entre alguns tipos. Se você não tem certeza do que vem aí, por que colocar algo específico. Coloque algo genérico!

Como? Veja, agora teremos um terceiro objeto Moto e um objeto de exemplo por nome de Exemplo, que irá executar toda a história:


<?php
class Automovel{
	private $numeroPlaca;
	private $numeroDeRodas;

	public function Automovel($Placa, $nRodas){
		$this->setNumeroPlaca($Placa);
		$this->setNumeroDeRodas($nRodas);
	}

	public function setNumeroPlaca($novaPlaca){
		if($novaPlaca > 999 && $novaPlaca <= 9999)
		$this->numeroPlaca = $novaPlaca;
	}
	public function setNumeroDeRodas($novoNumeroRodas){
		if($novoNumeroRodas > 0)
		$this->numeroDeRodas = $novoNumeroRodas;
	}

	public function getNumeroPlaca(){
		return $this->numeroPlaca;
	}
	public function getNumeroDeRodas(){
		return $this->numeroDeRodas;
	}

}

class Carro extends Automovel{

	private $modelo;

	public function Carro($Placa, $nRodas, $modelo){
		parent::Automovel($Placa, $nRodas);
		$this->setModelo($modelo);
	}

	public function setModelo($nomeModelo){
		$this->modelo = $nomeModelo;
	}
	public function getModelo(){
		return $this->modelo;
	}

}

class Moto extends Automovel{

	private $modelo;

	public function Moto($Placa, $nRodas, $modelo){
		parent::Automovel($Placa, $nRodas);
		$this->setModelo($modelo);
	}

	public function setModelo($nomeModelo){
		$this->modelo = $nomeModelo;
	}
	public function getModelo(){
		return $this->modelo;
	}

}

class Exemplo{
	private $objetoGenerico;

	/*
		Veja! Declaro no parâmentro que aceito
		um objeto do tipo Automovel, assim posso
		receber tanto um objeto Carro como um Moto
	 */
	public function Exemplo( Automovel $obj){
		$this->setObjetoGenerico($obj);
	}

	public function setObjetoGenerico(Automovel $novoObj){
		$this->objetoGenerico = $novoObj;
	}

	public function Mostra(){
		if($this->objetoGenerico !== NULL){
			echo "Modelo : {$this->objetoGenerico->getModelo()}<br/>
				  Placa : {$this->objetoGenerico->getNumeroPlaca()}<br/>
			  	  Rodas : {$this->objetoGenerico->getNumeroDeRodas()}<br/><br/>";
		}
	}
}

//objeto do tipo carro
$carro = new Carro(9999,4,"Phusca");

//objeto do tipo moto
$moto = new Moto(4444,2,"Ronda");

$exemplo = new Exemplo($carro);

//mostra dados do carro
$exemplo->Mostra();

//muda de objeto
$exemplo->setObjetoGenerico($moto);

//mostra dados da Moto
$exemplo->Mostra();

?>

Veja que fantástica é essa organização! Como eu disse mais difícil do que compreender herança e polimorfismo é aplicá-lo. Mas isso já é outra história, este artigo fica por aqui e até a próxima meus caros. Dúvidas? Postem a vontade.

próximo artigo: Vamos voltar a falar de conexão com banco de dados, desta vez usando um objeto. 🙂

Acesso a banco de dados com php

Posted on julho 28, 2010

Posted by Rodrigo Ireno

Olá, neste artigo vamos abordar conexão com banco de dados usando php. Sei que até agora vimos muitas coisas relacionadas a orientação a objetos, porém para fim de simplificar o entendimento vou abordar de forma procedural. Programar de forma procedural. Ou seja, não orientado a objetos. Calma! Veremos exemplos orientados a objetos também, aqui é só pra centralizar a idéia no processo de conectar. O que no final das contas é uma coisa muito simples.

Se você vem acompanhando meus artigos já deve ter visto algo sobre o xampp, mas se você estava sapeando pelo Google e parou por aqui, eis um link de um artigo que fala um pouco sobre o xampp:  Hello world em php. Ele é um aplicativo que instala um kit básico pra desenvolvimento em php. Entre os softwares instalados está o banco de dados MySql. Que é o que nos interessa neste artigo, porque vamos nos conectar com ele.

Crendo eu, que você já tem o xampp vamos prosseguir. Acesse o http://localhost e depois o phpMyAdmin. Este aplicativo é feito em php e usaremos ele para administrar nosso banco de dados.

Para manipular um banco de dados utiliza-se uma linguagem própria. Esta linguagem é o SQL. É muito fácil encontrar conteúdo sobre SQL, eis que pelo menos o banco de dados MySQL tem documentação online. Outros bancos de dados também usam SQL, porém existe uma variação da sintaxe. Para nosso exemplo utilize o código abaixo para criar o banco de dados e a tabela que iremos utilizar.


/* Cria o banco de dados */

CREATE DATABASE objota;

/*
	O código abaixo cria a tabela clientes.

	veja que os comandos são bem explícitos. (cria a tabela se ela não existe)
*/

CREATE TABLE IF NOT EXISTS objota.clientes (
  id int(11) NOT NULL AUTO_INCREMENT,
  nome varchar(50) NOT NULL,
  telefone varchar(20) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=5 ;

/* Insere alguns registros na tabela */

INSERT INTO objota.clientes (id, nome, telefone) VALUES
(1, 'Carlos', '3333-4444'),
(2, 'Mario', '5555-6666'),
(3, 'Marcela', '7894-6543'),
(4, 'Gustavo', '1535-5847');

Com o phpMyAdmin aberto em seu navegador copie este código SQL, selecione a aba SQL no menu da página inicial cole este código no campo de input e após isso clique em executar. Este código criará um banco de dados com o nome objota e uma tabela com o nome clientes com os seguintes atributos: id, nome, telefone.

Como se trata de um exemplo a tabela já virá ”populada”, ou seja, com algum conteúdo. Feito isso nosso banco de dados já existe. Iremos então usar um comando para recuperar estes dados. Mas antes, a tal conexão.

Conectando ao banco de dados

Para se conectar a um banco de dados é necessário possuir:

  • Nome do banco de dados
  • Nome do usuário de banco de dados
  • Endereço do banco de dados
  • Senha
  • Porta

Como se trata de uma conexão local o Endereço do banco no caso é sua própria máquina. Você pode referenciar ele pelo nome localhost. O nome do banco de dados é objota, neste exemplo. Por padrão no phpMyAdmin o nome padrão de usuário é root. Senha até então não existe, então simplesmente não forneça nada. Porta padrão é 3306. Vejamos o código abaixo:

<?php

$con = mysqli_connect("localhost","root","","objota","3306");

if(!$con){
	echo "Ops! <br/>";
}
else{
	// Se conectou posso fazer uma busca por dados.
	echo "Conectou!!! <br/>";

	//Vejamos um comando SQL para selecionar os dados de nossa tabela.
	$sql = "SELECT id, nome, telefone
			FROM clientes";

	//Forneço o ponteiro de conexão $con e o comando SQL vai no segundo parâmetro
	$rs =  mysqli_query($con, $sql);

	//Extraímos os dados da resource resultante em um array
	$dados = mysqli_fetch_array($rs);

	//Pronto!! eis os dados obtidos
	var_export($dados);
}

?>

Detalhando os acontecimentos. Primeiro me conectei ao banco usando a função mysqli_connect(). Faço uma breve verificação, caso esteja tudo bem prosseguimos com o acesso. Armazeno na variável $sql um comando SELECT que traz todo o conteúdo da tabela.
Logo em seguida utilizo a função mysqli_query($con, $sql) ,  repare que passo como primeiro parâmetro o ponteiro de conexão, em seguida vem a query (comando SQL). Essa função me retorna uma resource , que tecnicamente ainda não são os dados que eu pedi. Afinal quero nome e telefone da tabela. Para extrair desta resource os dados que eu quero, é preciso usar a função mysqli_fetch_array($resource) , veja que forneço a resource como parâmetro e ele finalmente me retorna um array com os dados que eu requisitei.

Obs: Neste exemplo fiz uso da função var_export($var) para mostrar todo o conteúdo do array na tela, muitos programadores usam isto para verificar o conteúdo de uma variável a fim de debugar o um código.

Porém abaixo segue mais um código que faz o mesmo que o código acima. Porém ele acessa os dados do array com um loop e mostra na tela de forma mais “apresentável”.

<?php

$con = mysqli_connect("localhost","root","","objota","3306");

if(!$con){
	echo "Ops! <br/>";
}
else{
	// Se conectou posso fazer uma busca por dados.
	echo "Conectou!!! <br/>";

	//Vejamos um comando SQL para selecionar os dados de nossa tabela.
	$sql = "SELECT id, nome, telefone
			FROM clientes";

	//Forneço o ponteiro de conexão $con e o comando SQL vai no segundo parâmetro
	$rs =  mysqli_query($con, $sql);

	//Extraímos os dados da resource resultante em um array
	while($dados = mysqli_fetch_array($rs)){

		// Com o uso do caracter ponto "."
		// é possível concatenar (unir) trechos de string
		echo "<b>Nome:</b> ".$dados['nome']." <b>Telefone:</b> ".$dados['telefone']."<br/>";
	}
}

?>

extra: veja este vídeo que mostra o phpMyAdmin em uso video

Bom pessoal, este artigo acaba aqui, porém ainda tem muita coisa pra falar e exemplificar. Foi apenas um breve exercício, mas espero ter ajudado em algo. No próximo artigo adentraremos um pouco mais em orientação a objetos, e veremos futuramente acesso a banco de dados usando um objeto. Dúvidas?

Utilizando arrays em classes

Posted on julho 21, 2010

Posted by Rodrigo Ireno

Olá, para quem já tem acompanhado meus artigos sobre php deve ter visto o último arrays e matrizes em php que mostrava como utilizar arrays em php. Neste artigo quero mostrar um exemplo prático com arrays em php em uma classe. Vendo todos os métodos de iteração.

Iteração

Este termo é usado para designar uma busca em um array. Quando digo que se deve iterar por um array, quer dizer que devo percorrer este array até encontrar algum valor ou algo assim. Para iterar por um array é preciso fazer uso de algum tipo de loop. Para não ficar nenhuma dúvida vou demonstrar como iterar por um array com diversos tipos de loop. Tudo isso dentro do paradigma de orientação a objetos.

Teremos neste artigo dois objetos. O objeto contato e o objeto agenda, que não passa de uma lista de contatos. Eis a primeira classe:

Contato


class Contato{
	private $nome;
	private $telefone;
	private $email;

	public function Contato($nome, $telefone, $email){
		$this->nome = $nome;
		$this->telefone = $telefone;
		$this->email = $email;
	}

	public function setNome($novoNome){
		$this->nome = $novoNome;
	}
	public function setTelefone($novoTelefone){
		$this->telefone = $novoTelefone;
	}
	public function setEmail($novoEmail){
		$this->email = $novoEmail;
	}

	public function getNome(){
		return $this->nome;
	}
	public function getTelefone(){
		return $this->telefone;
	}
	public function getEmail(){
		return	$this->email;
	}
}

A classe acima tem por objetivo representar a entidade lógica contato com todos os atributos relevantes ao nosso escopo. Vejamos adiante a classe Agenda:

Agenda


class Agenda{

	// Um array com objetos do tipo Contato
	private $contatos;

	public function Agenda(){
		$contatos = array();
	}

	//Adiciona contatos a lista
	public function addContato($novoObjetoContato){
		$this->contatos[] = $novoObjetoContato;
	}

	//Mostra todos os contatos com foreach
	public function mostraContatos1(){
	 	foreach($this->contatos as $obj){
	 		echo "Nome: {$obj->getNome()}<br/>
	 			  Telefone: {$obj->getTelefone()}<br/>
	 			  Email: {$obj->getEmail()}<br/>
	 			  -----------------<br/>";
	 	}
	}

	//Mostra todos os contatos com for
	public function mostraContatos2(){
	 	for($i=0;$i < count($this->contatos);$i++){
	 		$obj = $this->contatos[$i];

	 		echo "Nome: {$obj->getNome()}<br/>
	 			  Telefone: {$obj->getTelefone()}<br/>
	 			  Email: {$obj->getEmail()}<br/>
	 			  -----------------<br/>";
	 	}
	}

	//Mostra todos os contatos com while
	public function mostraContatos3(){
		$i = 0;
	 	while($i < count($this->contatos)){
	 		$obj = $this->contatos[$i];

	 		echo "Nome: {$obj->getNome()}<br/>
	 			  Telefone: {$obj->getTelefone()}<br/>
	 			  Email: {$obj->getEmail()}<br/>
	 			  -----------------<br/>";
	 		$i++;
	 	}
	}

	//Mostra todos os contatos com 'do while'
	public function mostraContatos4(){
		$i = 0;
	 	do{
	 		$obj = $this->contatos[$i];

	 		echo "Nome: {$obj->getNome()}<br/>
	 			  Telefone: {$obj->getTelefone()}<br/>
	 			  Email: {$obj->getEmail()}<br/>
	 			  -----------------<br/>";
	 		$i++;
	 	}while($i < count($this->contatos));
	}
}


Veja como iteramos pelo array. O foreach sempre itera por todo o array. Já com os outros tipos de loop posso ter mais controle sobre a iteração. Outra observação a fazer é o método nativo do php count() que retorna um número inteiro, referente ao número de elementos dentro do array.

Depois de feitas estas duas classes, vamos juntar tudo isso em um único arquivo php e executar para ver o que acontece. Copie as duas classes e cole uma e depois a outra. Depois das duas classes. Adicione este código, abaixo, (tudo entre tags php, lógico):


$obj = new Agenda();

// Instancio dois contatos
$contato1 = new Contato("Rodrigo","11-2222-5555","rodrigo@objota.com.br");
$contato2 = new Contato("objota","22-5555-1111","objota@objota.com.br");

// adiciono estes a minha lista
$obj->addContato($contato1);
$obj->addContato($contato2);

$obj->mostraContatos4();


Neste código é feita a inicialização do objeto Agenda e adicionados dois contatos. Após isso utilizamos o método mostraContatos() para mostrar todos os contatos já adicionados.

Repare que tão importante quanto utilizar métodos de iteração por arrays, vimos também um bom exemplo de orientação a objetos. Construímos duas classes, sendo que um objeto utiliza o outro. Todos em conjunto formam uma agenda.

obs: O loop mais rápido é o for, só uma dica! 🙂

Teste o arquivo e veja o resultado. Este artigo fica por aqui, até a próxima e bom aprendizado!

No próximo post vamos falar de conexão com o banco de dados! até!

Arrays e Matrizes em php

Posted on julho 17, 2010

Posted by Rodrigo Ireno

Arrays em php

Olá, neste artigo vou falar um pouco sobre array em php. Como utilizá-lo, para que serve e etc. Mas.. o que é um array?

Array é uma coleção de valores armazenada em uma única variável. Até agora vimos que é possível armazenar valores numéricos e caracteres em uma variável. Utilizando um array, é possível armazenar vários tipos de valores em uma única variável. Veja um exemplo abaixo:


<?php

	//Uma variável comum

	$valor = 123;
	$valor = "Objota";

	//Um array

	$valor = array(123,"Objota");

?>

Para recuperar um valor específico do array é preciso fornecer um índice. Este índice geralmente é um valor numérico, porém em arrays associativos, também se usa caracteres. Vejamos o segundo exemplo:


<?php
	//Um array

	$valor = array(123,"Objota");

	//A linha abaixo imprime na tela o valor "123"

	echo $valor[0];

?>

Como pudemos ver no exemplo acima, o índice inicia sua contagem a partir do zero. Como temos dois elementos no array (123 e “Objota”) temos os índices 0 e 1 acessíveis.

Arrays Associativos

Em geral todo array é associativo. No exemplo anterior o índice zero está associado ao primeiro item do array. Por omissão o php considera que o índice é um número, porém é possível declarar como será este índice. Vejamos abaixo.


<?php
	//Sem declarar o nome da chave ou índice

	$valor = array(123,"Objota");

	//Por omissão é determinado um número como índice ou chave

	echo $valor[0];

	//Declarando o nome da chave

	$valor = array("primeiro" => 123, "segundo" => "Objota");

	//Imprime "123" na tela

	echo $valor["primeiro"];

?>

Matrizes com combinações de array

Na própria matemática e em muitos sistemas, e muitos tipos de cálculo é necessário o uso de matrizes. Uma matriz  é um conjunto de linhas e colunas. Vejamos um exemplo abaixo:


<?php
	//Eis um exemplo de um matriz 3x3 (três linhas por três colunas)

	$Matriz = array(array(59,56,47),
			     array(85,57,73),
			     array(15,23,32));

	// A linha abaixo imprime 23 na tela

	//veja a referência, terceira coluna e linha 2

	//Lembrando que a contagem do índice começa do zero!

	// Neste formato o primeiro colchete define a coluna
	// e o segundo colchete define a linha
	echo $Matriz[2][1];

?>

Da mesma forma também é possível fazer isso:

<?php

// Uma matriz associativa
$valor = array(
	'Cor'			=> array( 'Vermelho', 'Branco', 'Prata' ),
	'Capacidade'	=> array( '4GB', '8GB', '16GB' ),
	'Interface'		=> array( 'Windows', 'Mac', 'Linux' ),
);

// Esta linha printa 'Vermelho' na tela
echo $valor['Cor'][0];

//Coluna 'cor' e o ítem zero '0' desta coluna

?>

Bom este foi um tutorial simples e direto para esclarecer como utilizar um array. No próximo artigo faremos uma classe para manipular arrays. Com vários tipos de loop. Dúvidas, fiquem a vontade para postar.

Classes em php – Glossário

Posted on julho 15, 2010

Posted by Rodrigo Ireno

Olá caros leitores, este artigo é uma definição sumária de cada elemento de uma classe. Utilize este artigo para consulta, sempre que necessário. Sendo um glossário será atualizado toda vez que surgir conteúdo novo.

Classe:

Uma classe em php assim como em outras linguagens tem um conjunto de métodos e atributos que tem por objetivo implementar uma entidade lógica, que pode ser baseada no mundo real ou não.

Atributos:

Um atributo representa, para classes e orientação a objetos, um dado específico, uma característica de uma entidade lógica. Em geral se deve considerar atributo um dado (característica) muito relevante de tal objeto, que é indispensável para cumprir com sua finalidade na aplicação. Por exemplo, uma classe Pessoa deve com certeza conter um atributo nome, cpf... e outros registros que tornem este indivíduo único. Um classe Automovel deve conter um atributo muito relevante, o número da placa, por exemplo.

Atributos e a visibilidade:

Em orientação a objetos se ouve muito de herança, encapsulamento. Em geral construir uma classe com um bom encapsulamento é uma boa prática de programação. Para tanto, é preciso sempre declarar seus atributos como private e fazer uso de métodos modificadores e de acesso

Método:

Um método consiste em um trecho de código que é escrito ( implementado) uma vez. Sendo possível executá-lo quantas vezes for necessário simplesmente chamando-0 pela sua assinatura.

Método construtor:

O método construtor é o responsável por inicializar um objeto com seu valor default. Um método construtor pode ter um conteúdo em seu bloco ou não. O bloco abriga as ações a serem executadas pelo método.

Em php pode-se declarar um método construtor de duas formas. Pode-se dar o nome do construtor igual ao nome da classe, isso é padrão para muitas linguagens. Ou é possível também declarar com o método nativo do php "__construct()".

Método de acesso:

Métodos de acesso são necessários quando um atributo é declarado como private. Tem a ver com a visibilidade do atributo em questão. Quando o atributo é público não é necessário um método de acesso, porém o objeto fica com um nível alto de acoplamento, e isso é ruim na orientação a objetos. Quando se utiliza private o atributo é inacessível fora da classe exceto atravez deste método, que tem por objetivo retornar o valor contido neste atributo.

Método modificador:

Tem por finalidade modificar o valor de um atributo da classe. Geralmente ele recebe o novo valor por parâmetro. Quando necessário é aconselhável fazer uma lógica de validação deste dado de entrada, para somente então atribuir este novo valor ao atributo da classe.


static:

Em php,  atributos ou métodos declarados como estáticos faz deles acessíveis sem precisar instanciar a classe. Um membro declarado como estático não pode ser acessado com um objeto instanciado da classe (embora métodos estáticos possam).

protected:

Esta palavra chave  limita o acesso a classes herdadas (e para a classe que define o item). Este conceito já é fio para entrar em herança e polimorfismo. Em termos mais simples, protected é o mesmo que public, somente para quem herda o método ou atributo. E para quem não herda nada protected tem o mesmo efeito de um private.

const

Utiliza-se esta palavra chave para transformar o atributo de uma classe um valor constante e inalterável. Para acessar uma constante de uma classe usa-se está sintaxe: NomeDaClasse::NomeDaConstante. Isso irá retornar o valor da constante existente na classe. É muito usual para números fixos usados durante o desenvolvimento, por exemplo o status de um usuário no seu site: 0 = desabilitado; 1 = habilitado; 2 = pendente; e etc. sendo mais fácil a associação de palavras.. do que de números fica mais fácil usar constantes como Status::DESABILITADO; Status::ABILITADO; Status::PENDENTE.