Objota O mundo orientado a objetos

PHP – Problema com caracteres na conexão com o banco de dados utilizando PDO

Posted on setembro 13, 2012

Posted by Pedro

Olá galera, fica aqui uma dica bacana para quem está tendo problemas com caracteres na conexão com o banco de dados utilizando PDO.

Problemas com charset geralmente ocorrem quando você processa os dados no seu site em um formato X e no banco em um formato diferente. Ai começam os problemas. Um exemplo simples é o uso de ISO-8859-1 na codificação do seu site e um banco de dados configurado para trabalhar com charset UTF-8.

Nesse exemplo vou configurar parâmetros de conexão como o banco de dados MySQL já que é geralmente o mais utilizando com PHP, e trabalhar com  os dados no formato UTF-8.


//Exemplo da classe em PHP com extends na classe PDO. Aqui vamos atribuir todas as variáveis da nossa conexão pra trabalhar no formato UTF-8.

class MysqlConnection extends PDO {

public function Connection($dsn, $username = "", $password = "", $driverOptions = array()) {

parent::__construct ( $dsn, $username, $password, $driverOptions );

$this->exec("SET NAMES utf8");

$this->exec("SET character_set='utf8'");

$this->exec("SET collation_connection='utf8_general_ci'");

$this->exec("SET character_set_connection='utf8'");

$this->exec("SET character_set_client='utf8'");

$this->exec("SET character_set_results='utf8'");

}

}


//Aqui é a string de conexão / $dsn que vamos usar para conectar ao nosso banco

$dsn = "mysql:host=localhost;dbname=meu_banco_de_dados;charset=utf8";

Bom é isso. Muito simples, certo?

Qualquer dúvida pode postar um comentário que irei responder.

Até a próxima.

hashDoS a falha de segurança que afeta a maioria das linguagens WEB

Posted on janeiro 1, 2012

Posted by Eder Freire

Recentemente na Alemanha aconteceu a 23ª edição da Chaos Computer Club, uma conferência de segurança muito conhecida entre os hackers de todo mundo e, pra variar, as primeiras palestras foram assustadoras. Um pesquisador encontrou uma brecha que afeta milhões de celulares no mundo todo nas redes 2G GSM, mas o que realmente me chamou atenção foi uma dupla de pesquisadores avisou que milhões de sites estão vulneráveis a um novo tipo de ataque DoS (Denial of Service), chamado hashDoS, que pode deixá-los fora do ar se não tratado com rapidez.

Os pesquisadores Alexandre Klink e Julian Wälde gesticularam e demonstraram que o problema está na maneira que certas linguagens usadas em servidores web armazenam valores em uma tabela hash. A grande maioria utiliza do mesmo método e pessoas mal-intencionadas podem tirar vantagens disso, enviando valores pré-determinados que sabem sabem que não serão tratados da forma que deveriam ser tratados. Essas requisiões, no final das contas, acaba gerando uma função quadrática que sobrecarrega os servidores.

Para provar que o método funciona, durante a apresentação, eles enviaram requisições do tipo HTTP POST com 2 MB de tamanho para um servidor WEB rodando Apache Tomcat, isso foi o suficiente para que o processamento do servidor subisse para a marca de 100% de consumo e permanecesse neste nível durante toda a palestra.

Quais linguagens afetadas?

A lista não é nada pequena. Nela constam PHP, ASP.NET, Java, Python, Ruby, Apache Tomcat, Apache Geronimo, Jetty, Glassfish, e até a V8, engine de renderização de JavaScript do Google.

Note que aqui temos interpretadores e servidor de aplicação, nessa os servidores WEB e o protocolo HTTP escaparam, sempre alvos de ataques de hackers.

Quais linguagens ja iniciaram o processo de correção e em qual versão isso ja está corrigida?

JRuby >= 1.6.5.1
PHP >= 5.3.9 (ainda está em Release Candidate), 5.4.0 RC4
Ruby >= 1.8.7-p357, 1.9.x
Apache Tomcat >= 5.5.35, 6.0.35, 7.0.35
Rack >= 1.4.0, 1.3.6, 1.2.5, 1.1.3

A Microsoft ja anunciou que vai liberar uma atualização para o ASP.NET que soluciona esse problema.

Os mais afetados com certeza serão os sites com PHP, hoje 77% dos sites em PHP rodam sob o PHP 5.2, que não teve nenhum suporte a este buf-fix. O certo é migrar-mos nossos sites para o PHP 5.3.9 RC, a 5.3 ja é a versão estável do PHP, o que garante atualizações de segurança e novos recursos.

Há linguagens que não entraram na lista, pois isso não era novidade para seus criadores, uma que vale a pena destacar, a qual eu sou fã, é o Perl, eles trataram esse problema em meados de 2003, pois ja haviam identificado essa falha.

A explicação é extramamente complexa, vale a pena dar uma olhada no vídeo da apresentação no Youtube .

Você também pode conferir o anúncio oficial.

Como usar NameSpace no php

Posted on abril 12, 2011

Posted by Rodrigo Ireno

O exemplo mais fácil para referenciar name space é a linguagem JAVA. Que usa o conceito de package e que no final das contas é a mesma coisa. O objetivo de usar este recurso é entre outras coisas organizar suas classes em grupos especializados.

No java se faz o uso de name space ao chamar um objeto diretamente ou método ou ao importar uma classe ou pacote de classes. exemplo:

import javax.swing.JOptionPane.*;

Este exemplo importa tudo o que está dentro do pacote JOptionPane.

Porém essa realidade (import) não se aplica ao php, pois utilizamos o autoload.

Vejamos abaixo uma pequena estrutura montada para utilizar este recurso no php. Implementei um config.php e uma página index.php. A primeira mudança que devemos notar é o modo como a função autoload está sendo implementada

obs: A versão do php que estou usando é 5.3.x

Seguem os arquivos da estrutura:

classes/Usuario.class.php

<?php
namespace classes;

class Usuario{

 function getIdade() {
 return 8;
 }
}

?>

classes/util/Conexao.class.php

<?php
namespace classes\util;

class Conexao{

 function getConnection() {
 return 'is connected!';
 }

}
?>

classes/util/Timer.class.php

<?php
namespace classes\util;

class Timer{

 function getNow(){
 echo "<br />".date("h:m:s")."<br />";
 }
}
?>

config.php

<?php
define("HOME", getEnv("DOCUMENT_ROOT")."/teste/");

spl_autoload_register(function ($class) {

 $nome = str_replace("\\", "/" , $class . '.class.php');

 if( file_exists( HOME . $nome ) ){
 include_once( HOME . $nome );
 }

});
?>

index.php

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

use classes\Usuario;
use classes\util\Conexao;
use classes\util\Timer;

$usuario = new Usuario();
$con = new Conexao();
$timer = new Timer();

echo $con->getConnection() . "<br />";
echo $usuario->getIdade() . "<br />";

$timer->getNow();

?>

Note que ao utilizar namespace é obrigatório respeitar a organização dos diretórios. Caso contrário a sua função de autoload não irá funcionar. Em java a organização também é feita desta forma, porém as ferramentas IDE's abstraem um pouco essa parte. Mas como disse no final das contas um package ou namespace é literalmente isso separar em diretórios diferentes o seus arquivos php que contém classes.

Dê uma fuçada na função autoload printando na tela a classe atualmente sendo chamada, e verá que o nome que é recuperado pelo seu parâmetro não traz somente o nome (mas também todo o caminho do namespace especificado no arquivo da classe).

Bom, finalizo este post aqui, e espero que tenha esclarecido algumas dúvidas. valew 😉

arquivos (descompacte no seu htdocs):  download dos arquivos

Utilizando spl_autoload_register

Posted on fevereiro 25, 2011

Posted by Rodrigo Ireno

Neste breve artigo quero mostrar como funciona a função spl_autoload_register que atua igualmente a  função __autoload. Neste caso o próprio nome já descreve em parte o que ela faz, pois esta função registra (ou empilha) mais conteúdo dentro de um escopo de autoload. Disse “escopo” e não função pois ela não pode ser utilizada junto com a função __autoload.

A grande vantagem de utilizar esta função é que você pode incluir módulos em seu sistema web sem se preocupar em incluir as classes deste módulo em seu class path. E utilizá-la é tão fácil quanto o autoload convencional.

Utilizando __autoload:

supondo que os arquivos Objota.class.php e Joao.class.php estão no mesmo diretório do arquivo index.php

Objota.class.php


<?php

class Objota{

 public function __construct(){
 echo "Incluiu Objota<br/>";
 }

}

?>

Joao.class.php


<?php

class Joao{

 public function __construct(){
 echo "Incluiu Joao<br/>";
 }

}

?>

index.php


<?php

function __autoload( $nomeDaClasse ){

 if(file_exists( $nomeDaClasse.".class.php"  )){
 include($nomeDaClasse.".class.php");
 }
 else{
 echo "Não foi possível carregar a classe";
 }

}

$obj = new Objota();

$o = new Joao();

?>

Utilizando a função spl_autoload_register:

Desta vez vamos supor que as classes Objota e Joao são de módulos completamente diferentes, por isso representei com nomes diferenciados., vejamos abaixo:

Objota.objota.class.php


<?php

class Objota{

 public function __construct(){
 echo "Incluiu Objota<br/>";
 }

}

?>

Joao.joao.class.php


<?php

class Joao{

 public function __construct(){
 echo "Incluiu Joao<br/>";
 }

}

?>

index.php


<?php

//funcao que carrega classes do modulo OBJOTA
function objota_carregar_classes( $nomeDaClasse ){

 if(file_exists( $nomeDaClasse.".objota.class.php"  )){
 include($nomeDaClasse.".objota.class.php");
 }

}
spl_autoload_register("objota_carregar_classes");

$obj = new Objota();

//funcao que carrega classes do modulo JOAO
function joao_carregar_classes( $nomeDaClasse ){

 if(file_exists( $nomeDaClasse.".joao.class.php"  )){
 include($nomeDaClasse.".joao.class.php");
 }

}

spl_autoload_register("joao_carregar_classes");

$jo = new Joao();

?>

Observação: A função spl_autoload_register sobrescreve a função autoload então se for adotar o uso desta, certifique-se de que nenhuma parte de seu sistema esteja usando o autoload convencional mas sim a spl_autoload_register.

Esta é uma solução, por exemplo, para a implantação do framework Smarty 3.0 ao seu sistema web. Pois ele utiliza esta função, e caso você não faça uso dela também, terá problemas.

Bom caros leitores este artigo (dica), fica por aqui. Caso haja dúvidas poste aí!

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

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é!