TryCatch

Capture-o

Iniciando com PHP: Sintaxe básica

Dec 22

Posted by Sadjow in Certificação PHP 5, PHP, PHP Básico | 2 Comments

Aqui vamos aprender um pouco sobre a sintaxe básica do PHP, falar sobre como o interpretador do PHP funciona e como escrever arquivos para que o interpretador calcule suas expressões PHP.

No caso de um servidor web, quando você acessa um página “pagina.php” em qualquer site. Antes do servidor web enviar a página para seu browser ele envia o documento para um programa chamado “Interpretador PHP”, este programa vai ler todo o arquivo em busca das tags PHP “<?php ?>” .  O programa passa linha a linha no seu documento em buscas destas tags e quando encontra a tag de abertura “<?php” passa para o modo PHP, que começa a interpretar expressões PHP até que encontra a tag de fechamento “?>” e passa novamente para o modo HTML e procura por estas tags até o final do arquivo.

No modo PHP, quando o interpretador está calculando as expressões PHP pode haver expressões de output que escrevem algo no resultado final da página web.  Como exemplo as funções:  echo, print e etc…

E, no modo HTML ele siplesmente joga o que está escrito no resultado final.

Uma imagem vale mais que isto tudo que escrevi acima não é? Então vamos ver uma:

Modos do interpretador PHP

E então o Interpretador calcula as expressões nestas áreas PHP que junta todos os saídas (output) para um resultado final que vai ser jogado para o interpretador de HTML que é o seu browser(navegador).

Resultado:

É assim que funciona.

Tags PHP

Agora vamos falar sobre os tipos de tags PHP. Existem 4 tipos de tags php.

  • <?php ?>
  • <? ?>
  • <script language=”php”></script>
  • <% %>

A primeita tag “<?php ?>” é a tag padrão, que está habilidata em todos os interpretadores PHP. Qualquer interpretador PHP reconhece estas tags.

A segunda “<? ?>” é apenas uma abreviação da primeira, sendo que tem que está habilitado no arquivo de configuração do interpretador PHP “php.ini“.

A terceira “<script language=”php”></script>” também tem que está habilitado no arquivo de configuração, e é muito grande, é bem melhor usar a primeira =).

A quarta “<% %>” são tags no estilo asp para programadores acostumados com asp que estão migrando para o PHP. Também tem que está habilitada.

Embora tenha estas opções de tags não é recomendado usar as 3 últimas  para aplicativos e bibliotecas que irão serem distribuídos por muitos servidores diferentes. Já que são tags que devem está habilitadas. Tornando assim, uma boa prática de programação sempre usar as tags padrão “<?php ?>” =).

Então vamos ao comentários:

Você sempre fica feliz quando tem que ajeitar códigos de outras pessoas ou códigos feitos por você mesmo a mais de 6 meses quando estes códigos são comentados. Comentar é sempre uma boa prática quando se está programando, mas claro que somente somente comentários relevantes e não aqueles comentários:

?View Code PHP
1
2
3
4
5

<?php
#a variável valor recebe 5
$valor = 5;
// Seria melhor comentar algo mais útil. =/
?>

Acima, na brincadeira já vimos 2 tipos de comentários PHP, ambos comentários de linha. Tudo que está escrito após “//“(barra barra) ou “#“(sharp) é ignorado pelo interpretador PHP e serve apenas para que você ou outros programadores leiam para saber alguma informação que está acontecendo no código.

Como podem ver, no segundo comentário eu usei duas vezes o “#” um para cada linha. Porque este tipo de comentário é para apenas uma linha e eu tinha duas linhas, então usei 2 sharps.

Se eu quiser fazer um longo comentário é aconselhavel usar o comentário em bloco:

Uma coisa interessante é que o PHP interpreta a tag de fechamento nos comentários em linha // ou #.

?View Code PHP
1
2
3
4

<?php
// aqui é php ?> aqui é html agora.
echo "Interessante não é?"
?>

Teste ai =)

Separação de instruções

No modo PHP cada linha é uma instrução e cada umas delas deve ser finalizada com ; (ponto-e-virgula)

?View Code PHP
1
2
3
4
5

<?php
echo "instrução 1";
print "instrução 2";
echo "instrução 3";
?>

Sendo que a última instrução antes da tag de fechamento não é obrigatória, podendo ser escrito assim:

?View Code PHP
1
2
3
4
5

<?php
echo "instrução 1";
print "instrução 2";
echo "instrução 3"
?>

Mas é uma boa prática de programação finalizar todas as instruções com ;(ponto-e-vírgula) para evitar esquecer nas outras linhas que são obrigatórias.

E também não é necessário a última tag de fechamento PHP, claro que se não houver mais nenhum HTML em diante.

?View Code PHP
1
2
3
4

<?php
echo "instrução 1";
print "instrução 2";
echo "instrução 3"

Comentem!

Bom é isso pessoal.
Até a próxima.

Tags: , ,

PHP Básico.

Dec 22

Posted by Sadjow in Certificação PHP 5, PHP, PHP Básico | No Comments

Olá, estamos iniciando os posts para a certificação PHP 5 da Zend, vamos iniciar com PHP Básico que iremos falar sobre:

  • Sintax
  • Operadores
  • Variáveis
  • Constantes
  • Estrutura de controle
  • Construções da linguagem e funções

Todo o  estudo vai ser guiado pela informação do exame presente em http://www.zend.com/en/services/certification/php-5-certification/

Iremos pesquisar, estudar em vários sites e tentar explicar tudo aqui no blog do TryCatch da melhor forma possível. Esperamos construir um bom conteúdo sobre PHP e também esperamos sua participação para ajudar a melhorar o conteúdo.

Abraço, valeu!

Tags: , ,

Layout renovado!

Dec 16

Posted by Sadjow in Uncategorized | No Comments

Opa Pessoal,
Como o Waldson falou no post anterior. Estamos entrando de férias e iremos ter mais tempo para o trycatch. Assim renovamos o layout para ficar melhor e para mudar o visual.

Estamos pensando em iniciar uma série de posts direcionados para a certificação PHP 5 da Zend. Fiquem atentos!

Valeu!

get_called_class() no PHP 5.2

Dec 2

Posted by Waldson in Download de Código, Funções PHP, Orientação à Objetos, PHP | 1 Comment

Olá galera, depois de um tempinho(ão) off estamos de volta com nosso blog, o ano letivo está acabando e agora tenho fôlego(ufa!) pra escrever novamente. Desculpem a demora e vamos em frente. :D

Não sei se voce já precisou, mas se não precisou um dia vai precisar, pegar o nome da classe atual através de um método estático. Vamos agora aplicar essa técnica pra criar um factory de objetos.:

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11

<?php
class Factory {
 
	public static function create() {
		$className = __CLASS__;
		return new $className;
	}
 
}
print_r(Factory::create());//Factory Object ( )
?>

O que este código está fazendo é: crie uma instancia de um objeto da classe que está me chamando (pelo menos era isso que devia fazer).

Voce pensa. Uau consegui! É ai que voce se engana.

Continuando:
Vamos extender nossa fábrica para termos fábrica de outro tipo de objeto. Por exemplo uma fábrica de pizza (percebam que a nossa fábrica é diferente das fábricas tradicionais para fins didáticos, Na fábrica dos design patterns temos o produto, nesse caso a pizza, e o criador que seria a fábrica de pizza (PizzaFactory). Aqui as duas classes são uma só):

?View Code PHP
1
2
3
4
5
6
7

<?php
//..
class Pizza extends Factory {
 
}
print_r(Pizza::create());//Factory Object{}
?>

Ué o que deu errado??? Era pra sair uma pizza e saiu uma fabrica. Isso vai dar indigestão!!! kkk .

O que acontece é que o PHP resolve a constante mágica __CLASS__ em tempo de compilação(op-code), e na compilação o __CLASS__ está dentro de Factory e vai retornar Factory como resolução para __CLASS__ para todas as classes filhas que chamarem esse método.

Isso me deixava bastante frustado quando eu queria fazer algo desse tipo não funcionava se eu não colocasse uma variavel com o nome da classe (CakePHP style) ou não sobrescrevesse esse método na classe filha (sobrescrita de método).

Ai surge o PHP 5.3 com a função get_called_class que resolve este problema. Um exemplo deste mesmo código em PHP 5.3 seria:

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<?php
class Factory {
 
	public static function create() {
		$className = get_called_class();
		return new $className;
	}
 
}
print_r(Factory::create());//Factory Object{}
class Pizza extends Factory {
 
}
print_r(Pizza::create());//Pizza Object{}
?>

Desta forma funciona perfeitamente. Percebam que só substitui o __CLASS__ por get_called_class que retorna o nome da classe que está chamando este método. No caso da class Pizza como ela que está chamando create então o nome dela será retornado.

Beleza Waldson e onde entra o PHP 5.2 nessa história???

Bom antes eu tinha rachado a cuca pra tentar descobrir como fazer isso e depois dei um tempo. Ai um dia desses eu volto a me interessar por esse assunto, por conta de um framework que estou desenvolvendo (tentando :P ), e me deparo com os comentários da função get_called_class e com um post do blog septuro.

Testei as alternativas, a do blog e as dos comentários da função, e todas funcionavam bem, porém não em todas as situações. O que eu fiz foi otimizar e juntar o que já tinha e acrescentar outras situações para criar um método que se comportasse igual à função do PHP 5.3 (retornar o nome da classe ou falso se for chamado fora de uma classe).

As seguintes situações são formas de chamar métodos no PHP (considere o uso de get_called_class dentro de metodo()):

  • Pode ser chamado na forma normal. Ex: Classe::metodo();
  • Pode ser chamado em um objeto. Ex: $obj->metodo();
  • Pode ser chamado em call_user_func ou call_user_func_array. Ex: call_user_func(array(‘Classe’, ‘metodo’));
  • Apesar de depreciada, pode ser chamado com call_user_method ou call_user_method_array. Ex: call_user_method(‘metodo’, $obj);
  • O nome do metodo pode estar contido em uma variavel. Ex: $obj->$metodo() ou Classe::$metodo()
  • Referencias dentro dentro de um método estatico a self ou parent. Ex: self::metodo() ou parent::metodo()
  • Objeto chamando o método do pai. Ex: parent::metodo();

E a função atende a todos estes requisitos. Espero que ela seja útil pra voces como foi pra mim. A seguir o download da função que está sob a licensa MIT:

Download get_called_class

Tags: , , , , ,

Validando Formulários com PHP – Parte 2

Jul 8

Posted by Waldson in Formulários, Orientação à Objetos, PHP, Tutorial, Validação de dados | 10 Comments

Este post é a segunda parte de um artigo. A primeira parte pode ser encontrada neste link.

Se voces testaram as classes geradas no post anterior viram que elas são bastante eficazes, porém a forma que elas estão sendo usadas não é muito produtiva. Por exemplo geralmente queremos editar e ou adicionar registros e em ambos, na maioria das vezes, a validação é a mesma, ai teriamos que copiar numa e colar na outra, se mudar algo em uma muda em outra. Isso não é muito produtivo(e viva o DRY), e as vezes , na maioria, acabamos por esquecer de ficar mudando em ambas. Pra resolver este problema vamos criar uma classe pra validar dados. A classe é bastante simples apenas recebe um array com os dados a serem validados e testa eles com as validações pré-determinadas pra cada. A classe também pode retornar um array com as mensagens de erro de cada campo.

Vamos aos fazer a classe aos poucos. Primeiro vamos ao básico:

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12

<?php
class Validador {
    private $dados;
    private $validacoes = array();
    private $erros        = array();
 
    function __construct(array $dados) {
            $this->dados = $dados;
    }
 
}
?>

A classe tem três variaveis:

  • $dados – Esta variável guarda um array associativo com os dados que queremos validar.
  • $validacoes – Esta variável guarda um array associativo que informa qual(is) validacao(ões) pertence(m) a qual(is) campo(s)
  • $erros – Esta variável guarda as mensagens de erro de cada campo

Agora criaremos um método para adicionar uma validação a um campo. Este método recebe três parâmetros: o primeiro o nome do campo, O segundo um objeto do tipo Validacao e o terceiro a mensagem de erro.

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12
13

//... 
    function addValidacao($nomeCampo, Validacao $validacao, $msgErro) {
         //primeiro checamos se o campo não tem validacão
        // se não tiver inicializamos o array 
        if (!isset($this->validacoes[$nomeCampo]))
            $this->validacoes[$nomeCampo] = array();
        $this->validacoes[$nomeCampo][] = array(
                                             'validacao' => $validacao,
                                             'msgErro' => $msgErro
                                            );
    }
 
//...

Pronto. Percebam que o parametro do meio é tipado, ou seja, aquele parâmetro só pode ser do tipo que eu informei que no caso é do tipo da nossa interface Validacao. Fazemos isso pra garantir que o objeto terá o método validar.

Criaremos um método para pegar o valor de um campo. Se o campo não existir iremos retornar uma string vazia:

?View Code PHP
1
2
3
4
5
6
7

<?php
    //...
    protected function getValor($nomeCampo) {
        return isset($this->dados[$nomeCampo]) ? $this->dados[$nomeCampo] : '';
    }
    //....
?>

Agora vamos criar um método para validar um campo. Primeiro checamos se o campo tem validação ,pois se não tiver ele está válido. Depois percorremos as validações daquele campo em busca de um erro que se ocorrer será registrado na variavel erros. Este metodo vai retornar verdadeiro ou falso:

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?php
    //valida o campo e retorna verdadeiro ou falso
    function validarCampo($nomeCampo) {
        //se tiver vazio o array de validacoes desse campo retorna verdadeiro
        if (empty($this->validacoes[$nomeCampo]))
            return true;
 
        $valorCampo = $this->getValor($nomeCampo);
        //se não itera sobre cada validacao se tiver erros adiciona no array de erros e retorna falso
        foreach ($this->validacoes[$nomeCampo] as $dados) {
            $validacao = $dados['validacao'];
            if (!$validacao->validar($valorCampo)) {
                //adiciona o erro ao array de erros
                $this->erros[$nomeCampo] = $dados['msgErro'];
                //retorna falso
                return false;
            } else {
                //se está válido e tem erro apaga o erro (usado pra quando o campo estava inválido e foi corrigido)
                if (isset($this->erros[$nomeCampo]))
                    unset($this->erros[$nomeCampo]);
            }
 
        }
       //se não tiver erros retorna verdadeiro
       return true;
    }
?>

Bom agora vamos fazer outro método pra validar todos os campos de uma vez. O método é bastante simples ele itera sobre os campos do array e vai validando cada um:

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php
    //...
    function validar() {
        if (empty($this->dados))
            return true;
        foreach($this->dados as $campo => $valor) {
            $this->validarCampo($campo);
        }
        //depois de validar todos os campos verificamos se o array de erros está vazio
       //se ele tiver é pq todos os campos estão validos se não é pq tem erros
        return empty($this->erros);
    }
   //...
?>

Pra finalizar vamos criar os métodos que checam se o objeto tem erro e que retorna os erros:

?View Code PHP
1
2
3
4
5
6
7
8

//...
    function temErros() {
        return !empty($this->erros);
    }
    function getErros() {
        return $this->erros;
    }
//...

Pronto!!! Nosso validador está completo. Agora vamos a um exemplo de uso. Eu recomendo voce sempre criar uma subclasse dela pra cada situação e adicionar as validacoes nela. Neste exemplo vamos fazer uma classe pra validar um formulário de contato. Este formulário terá os seguintes campos:

  • Nome – O nome do contato
  • Mensagem – Mensagem do contato

Com as seguintes validações:

  • O nome deve ser informado e deve ter tamanho máximo de 10 caracteres.
  • A mensagem deve ser informada.

Chamarei a classe de ValidadorFormContato:

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<?php
//require das classes ValObrigatorio, ValTamanhoMaximo, Validador, Validacao
class ValidadorFormContato extends Validador {
        function __construct(array $dados) {
            parent::__construct($dados);
            //depois de inicializarmos o construtor da classe pai colocaremos as nossas validações especificas para esta classe
            //instanciaremos um objeto de validação obrigatoria (que foi criada na parte 1)
            $obrigatorio = new ValObrigatorio();
            //também um para o tamanho máximo do campo nome
            $tamanhoMaximo = new ValTamanhoMaximo(10);
            //agora adicionaremos a este objeto estas validacoes
            $this->addValidacao('nome', $obrigatorio , 'O nome deve ser informado.');
            $this->addValidacao('nome', $tamanhoMaximo , 'O nome deve ter no máximo 10 caracteres.');
            $this->addValidacao('mensagem', $obrigatorio , 'A mensagem deve ser informada.');
 
        }
 
}
?>

Agora vamos criar o formulario:

?View Code HTML
1
2
3
4
5
6
7
8
9
10

... 
<form method="post" action="form_contato.php">
<label for="nome">Nome:</label>
<input type="text" id="nome" name="nome" /><br />
<label for="mensagem">Mensagem:</label>
<textarea id="mensagem" name="mensagem"></textarea> <br />
<input type="submit" value="Enviar" />
 
</form>
...

Percebam que não coloquei o atributo maxlength no input do nome. Fiz isso por questões de exemplo(se não, teriamos que mudar com javascript para testar a validação de tamanho máximo), mas ele deve ser colocado sim e a validação também justamente pq esses campos podem ser manipulados facilmente.

Agora vamos a form_contato.php. Aqui exibirei uma lista com os erros mais ele pode facilmente ser integrado a baixo de cada campo do form para mostrar a msg.

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//html , etc
<?php
    //form_contato.php
    //require da classe ValidadorFormContato
    if (!empty($_POST)) {
        $validador = new ValidadorFormContato($_POST);
        if ($validador->validar()) {
            //envia email, salva em banco, etc. Enfim processa os dados
        } else {
            $erros = $validador->getErros();
            echo '<ul>';
            foreach ($erros as $msgErro) {
                echo '<li>'. $msgErro . '</li>';
            }
            echo '</ul>';
        }
    }
?>

Viram como é simples deixar a validação OO e reusável. Agora ficou bem simples voce fazer suas validações, personalizar, padronizar e manipular as msg de erro.

Aqui o código da classe Validador completo :

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

<?php
class Validador {
    private $dados;
    private $validacoes = array();
    private $erros        = array();
 
    function __construct(array $dados) {
        $this->dados = $dados;
    }
    function addValidacao($nomeCampo, Validacao $validacao, $msgErro) {
        //primeiro checamos se o campo não tem validacão
        // se não tiver inicializamos o array
        if (!isset($this->validacoes[$nomeCampo]))
        $this->validacoes[$nomeCampo] = array();
        $this->validacoes[$nomeCampo][] = array(
        'validacao' => $validacao,
        'msgErro' => $msgErro
        );
    }
 
    protected function getValor($nomeCampo) {
        return isset($this->dados[$nomeCampo]) ? $this->dados[$nomeCampo] : '';
    }
 
    function validarCampo($nomeCampo) {
        //se tiver vazio o array de validacoes desse campo retorna verdadeiro
        if (empty($this->validacoes[$nomeCampo]))
        return true;
 
        $valorCampo = $this->getValor($nomeCampo);
        //se não itera sobre cada validacao se tiver erros adiciona no array de erros e retorna falso
        foreach ($this->validacoes[$nomeCampo] as $dados) {
            $validacao = $dados['validacao'];
            if (!$validacao->validar($valorCampo)) {
                //adiciona o erro ao array de erros
                $this->erros[$nomeCampo] = $dados['msgErro'];
                //retorna falso
                return false;
            } else {
                //se está válido e tem erro apaga o erro (usado pra quando o campo estava inválido e foi corrigido)
                if (isset($this->erros[$nomeCampo]))
                unset($this->erros[$nomeCampo]);
            }
 
        }
        //se não tiver erros retorna verdadeiro
        return true;
    }
 
    function validar() {
        if (empty($this->dados))
            return true;
        foreach($this->dados as $campo => $valor) {
            $this->validarCampo($campo);
        }
        //depois de validar todos os campos verificamos se o array de erros está vazio
       //se ele tiver é pq todos os campos estão validos se não é pq tem erros
        return empty($this->erros);
    }
 
    function temErros() {
        return !empty($this->erros);
    }
    function getErros() {
        return $this->erros;
    }
 
 
}
?>

Este exemplo pode ser visto clicando aqui

Bom é isso. Antes de mais nada peço desculpas pela demora (é que tava/tô meio sem tempo, mas prometo que isso não acontecerá de novo.). Abraço e até a próxima.

UPDATE:
Os arquivos para download podem ser baixados aqui.

Tags: , , , ,

Função PHP: implode

Apr 22

Posted by Sadjow in Funções PHP, PHP | No Comments

A função implode junta os elementos de um array em uma string. No primeiro parâmetro é possível definir a string separadora, que ficará entre os elementos do arrray. Para dividir como uma virgula, por exemplo:

?View Code PHP
1
2
3
4
5
6
7
8
9

<?php
$a = array('Sadjow', '20', 'sadjow@gmail.com');
$string = implode(",", $a);
echo $string;
/*
Resultado:
Sadjow,20,sadjow@gmail.com
*/
?>

Está função serve para inúmeras coisas. É muito útil quando se trabalha com arquivos de texto ou então para montar querys dinâmicas com SQL.

Veja implode no manual oficial do PHP.

Tags: , ,

PHP: Usando a função mágica __autoload

Apr 20

Posted by Sadjow in Funções PHP, Orientação à Objetos, PHP | 1 Comment

Muita gente fica fazendo include e mais includes ou requires em seus arquivos PHP quando é necessário trazer a declaração de uma classe para a memória utilizada pelo script PHP em execurção. Como por exemplo:

?View Code PHP
1
2
3
4
5
6
7

<?php
require_once('classe.php');
require_once('classe_tal.php');
require_once('classe_dois.php');
require_once('classe_pessoa.php');
require_once('alguma_classe.php');
?>

Isto é péssimo. Quanto mais classes você tiver que utilizar no em seu script mais linhas terá que escrever para incluir as classes necessárias. eu não tinha muita paciencia de fazer isto, e foi muito bom descobrir esta grande mão na roda.

Vou mostrar aqui como utilizar esta função “automágica” do PHP para carregar arquivos que contém as classes, “automágicamente”, claro.

Para fazer tudo é muito simples. Para facilitar, você primeiramente precisa padronizar os nomes dos arquivos que contém as declarações das suas classes. Alguns exemplos de padrão usando camelCase são:

NomeDaClasse.class.php
ou
NomeDaClasse.php

Depois, é necessário declarar a função __autoload antes de precisar instanciar qualquer objeto dessas classes.

Faz de conta que você precise instanciar um objeto da classe “Pessoa” e o arquivo necessário é chamado “Pessoa.class.php”.

Um exemplo simples seria:

?View Code PHP
1
2
3
4
5
6
7

<?php
// Fazendo de conta que os arquivos estão na mesma pasta para facilitar este exemplo inicial.
function __autoload($nomeDaClasse){
    require_once($nomeDaClasse.'.class.php';
}
$sadjow = new Pessoa();
?>

Pronto, bastante simples. A classe foi incluida sem precisar usar um require. Claro que neste exemplo está usando apenas um classe, o que seria mais fácil usando apenas um require. Mas para grandes projetos, quando é necessário incluir vários arquivos de classes isto é uma mão na roda. Porém, mesmo para pequenos por questão de estudo e evolução do seu código tente sempre usar as melhores técnicas e principalmente se possível tenha paciência de usar a criatividade para implementar os códigos. Desta forma, com certeza você só tem a crescer.

Abaixo vou dar um exemplo bem interessante para se usar o autoloading de classes em PHP. Para começar preste atenção na estrutura das pastas:

?View Code TXT
classes
    Pessoa.class.php
config
    config.php
index.php

o arquivo config.php:

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/*Arquivo config.php
 *@autor Sadjow Medeiros Leão | TryCatch.com.br
 */
// declaramos constantes somente para abreviar o uso.
define('DS', DIRECTORY_SEPARATOR);
define('PS', PATH_SEPARATOR);
// declaramos ROOT como o caminhi completo para a raiz do projeto.
define('ROOT', dirname(dirname(__FILE__)).DS);
 
// Com o ROOT definido fica bastante fácil achar o caminho
// completo para o diretório de suas classes.
define('CLASSES', ROOT.'classes'.DS);
 
// Já que o arquivo config.php irá ser incluído em todas a páginas
// desse projeto, declaramos a função __autoload neste arquivo.
 
function __autoload($nomeDaClasse){
    require_once(CLASSES.$nomeDaClasse.'.class.php');
}

Arquivo classes/Pessoa.class.php

?View Code PHP
1
2
3
4
5
6
7
8
9

<?php
class Pessoa {
    public $nome;
    public $idade;
    public function __construct(){
        echo 'Sou uma pessoa';
    }
}
?>

Arquivo index.php

?View Code PHP
1
2
3
4
5
6
7
8
9

<?php
// Incluímos o arquivo de configuração.
require_once(dirname(__FILE__).'/config/config.php')
 
// Agora podemos instanciar qualquer classes que esteja no diretório
// classes:
$sadjow = new Pessoa();
$waldson = new Pessoa();
?>

Desta forma é possível apenas fazer um require em todas as páginas de seu projeto e sair fazendo mágicas. Muito bom para desenvolver tantos páginas simples como principalmente Frameworks.

Tem uma função muito boa também, que não posso deixar de comentar neste artigo sobre autoloading com PHP que é a psl_autoload_register. Com ela é possível dizer qual é o nome da sua função de autoload.

Pessoal, é isto, espero que tenham gostado do artigo. Abraços.

Tags: , , , , , , , , ,

Função PHP: number_format

Apr 20

Posted by Waldson in Funções PHP, PHP | No Comments

A função number_format, como o proprio nome já diz, formata um valor númerico. Ela recebe os seguintes parâmetros:

  1. O número a ser formatado
  2. O Total de casas decimais
  3. O separador decimal
  4. O separador de milhar

Ela aceita um, dois ou quatro parâmetros (não três).

Útil quando queremos formatar numeros de ponto flutuante com a forma diferente da americana:

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11

<?php
$valor = 5.3;
echo 'R$ ' . number_format($valor, 2, ',', ''); //R$ 5,30
 
$valor = 1000000.55;
//usando espaço para separar milhar
echo number_format($valor, 2, ',', ' ');//1 000 000,55
 
//usando ponto para separar milhar
echo number_format($valor, 2, ',', '.');//1.000.000,55
?>

Espero que a explicação seja útil, abraços e até a próxima.

Veja number_format na documentação oficial do PHP.

Tags: , ,

Função PHP: var_dump

Apr 20

Posted by Sadjow in Funções PHP, PHP | No Comments

var_dump — Mostra informações sobre a variável

Esta função imprime uma saída de algumas informações sobre a variável que você passou. Será realmente aceito qualquer número de variáveis para que você possa usar uma chamada pela função para obter informação sobre muitas variáveis.

É uma boa idéia para a saída do tag HTML <pre> antes de chamar a função. Isto irá exibir o espaço branco em um formato amigável mais humana. Com a extensão Xdebug instalada, a saída será formatado e cor codificadas para facilitar a legibilidade.

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

$bool  = false;
$int   = 17;
$float = 234.62;
$str   = 'Macaco';
$arr   = array('um', 'dois');
$obj   = new stdClass();
$rsrc  = mysql_query("SELECT * FROM tabela");
$null  = null;
 
var_dump($bool);  // bool(false)
var_dump($int);   // int(17)
var_dump($float); // float(234.62)
var_dump($str);   // string(6) "Macaco"
 
var_dump($arr);
/*
array(2) {
  [0]=>
  string(2) "um"
  [1]=>
  string(4) "dois"
}
*/
 
var_dump($obj);
/*
object(stdClass)#1 (0) {
}
*/
 
var_dump($rsrc); // resource(6) of type (mysql result)
var_dump($null); // NULL
 
// É possível passar várias variáveis:
 
var_dump($str, $null, $arr);
/*
string(6) "Macaco"
NULL
array(2) {
  [0]=>
  string(2) "um"
  [1]=>
  string(4) "dois"
}
*/
 
// Mostrando array multidimencionais
$arr = array('maçã',
             'banana',
             array('zebra',
                   'elefante'),
             'cenoura');
 
var_dump($arr);
/*
array(4) {
  [0]=>
  string(4) "maçã"
  [1]=>
  string(6) "banana"
  [2]=>
  array(2) {
    [0]=>
    string(5) "zebra"
    [1]=>
    string(8) "elefante"
  }
  [3]=>
  string(7) "cenoura"
}
*/

Veja var_dump no manual oficial do PHP:

Tags: , , ,

Função PHP: scandir

Apr 20

Posted by Sadjow in Funções PHP, PHP | No Comments

scandir — Lista os arquivos e diretórios que estão no caminho especificado

Descrição:
array scandir ( string $directory [, int $sorting_order [, resource $context ]] )

Obtenha uma lista de todos os arquivos e diretórios (como um array), que estão dentro de um determinado diretório. Esta função retornará falso e dará um aviso se o caminho não é um diretório.

Por padrão irá ordená-los por ordem alfabética, na ordem crescente. Defina o segundo parâmetro para qualquer inteiro não nulo para ordenar a lista por ordem decrescente.

?View Code PHP
1
2
3
4
5
6
7
8
9
10
11
12
13

$caminho = '/home/admin/public_html/arquivos';
$lista = scandir($caminho);
/*
array (
  0 => '.',
  1 => '..',
  2 => 'cv.pdf',
  3 => 'cachorro.gif',
  4 => 'musicas',
  5 => 'logo.png',
  6 => 'index.php'
)
*/

Algumas coisas a serem observadas:

* Ambos .(ponto) e ..(ponto ponto) são retornados na lista. Certifique-se de filtrar os que não são úteis antes de mostrar ou trabalhando na lista se não irão causar resultados indesejáveis.
* Todas os diretórios são encaixados na lista ( “musicas’ é um diretório no exemplo), mas a função não é para eles
* Arquivos de todos os tipos serão incluídos

Ordenando descendente passando por um inteiro não nulo como o segundo parâmetro:

?View Code PHP
$caminho = '/home/admin/public_html/arquivos';
$lista = scandir($caminho, 17);
/*array (
  0 => 'cachorro.gif',
  1 => 'cv.pdf',
  2 => 'index.php',
  3 => 'logo.png',
  4 => 'musicas',
  5 => '..',
  6 => '.'
)
*/

O terceiro parâmetro opcional é usado para um contexto de recursos streams. Isto, naturalmente, só é aplicável se você estiver usando streams. Certifique-se de verificar o manual para mais infomações lá.

Veja scandir no manual oficial do PHP.

Tags: , , , , ,