Maio 05, 2012

Adicionar um novo botão trigger no ComboBox

Olá meu caro leitor ou leitora. Hoje venho falar sobre um recurso simples que podemos utilizar com o componente da classe Ext.form.field.ComboBox do ExtJS. Irei demonstrar neste post um exemplo da criação de um novo botão "trigger" utilizando o componente ComboBox.
Resolvi escrever este, pois há um tempo que utilizo este recurso (desde a versão ExtJS 3.3.1) e não vi nada que mencionasse esse recurso na API Documentation do ExtJS e até o momento nenhum blog que mencione este assunto, mas no fórum oficial do Sencha existem alguns posts sobre este recurso.
Mas o que seria o botão trigger, este é o botão que fica renderizado no final do campo do ComboBox que executa a ação de exibir a lista de dados para a seleção do usuário. Vide imagem abaixo:
ComboBox com o trigger default do ExtJS
Por default é renderizado somente um botão trigger no componente, mas existe o recurso de inserir novos botões com ações definidas pelo programador.

Introdução
Esse recurso pode ser utilizado, pois a Classe Ext.form.field.ComboBox extende a classe Ext.form.field.Picker esta classe que fornece a implementação dos botões de trigger.
A implementação do botão trigger depende de duas configurações uma seria a classe CSS com o ícone para o botão e a função que será executada no click do botão. A Classe  Ext.form.field.ComboBox utiliza a classe CSS "form-arrow-trigger" para o seu botão trigger padrão que executa o método "onTriggerClick" que irá exibir a lista de opções do ComboBox.

Requisitos para o exemplo
Abaixo está a lista dos requisitos utilizados para criação do exemplo a imagem abaixo demonstra o produto final deste exemplo com o novo botão trigger do ComboBox.
ComboBox com os novos botões trigger2
- SDK do ExtJS (até a publicação deste estava na versão ExtJS 4.1.0) download
- Servidor Web (este não é um requisito obrigatório)
Para instalação criei uma pasta com o nome de "combobox_trigger2" (sem aspas) no meu DOCUMENT_ROOT e descompactei o framework do ExtJS dentro desta pasta e alterei o nome de "extjs-4.1.0" pasta para "extjs" (sem aspas). Caso não esteja utilizando um Servidor Web basta criar a basta  "combobox_trigger2" com os arquivos.
Estrutura da pasta do exemplo
Criando os arquivos de Exemplo
Este exemplo tem somente dois arquivos "combobox_trigger2.html" e "combobox_trigger2.js". Abaixo irei postar o código destes dois arquivos e após irei frisar as partes mais importantes da criação dos botões trigger.
Arquivo combobox_trigger2.html:
<!DOCTYPE html>
<html>
<head>
<title>Exemplo Combobox com trigger2</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <!-- CSS do Framework ExtJS -->
    <link rel="stylesheet" href="extjs/resources/css/ext-all-gray.css" />
    <style type="text/css">
        body { padding: 12px 10px 0; }
    </style>

    <!-- JS para o exemplo -->
    <script type="text/javascript" src="extjs/ext-all.js"></script>
    <script type="text/javascript" src="combobox_trigger2.js"></script>
</head>
<body>
</body>
</html>
Arquivo combobox_trigger2.js:
var onTrigger2ClickCombo1 = function() {
    this.clearValue();
    
    Ext.Msg.alert('Clear Value', 'Valor do ComboBox removido com sucesso!');
}

var onTrigger2ClickCombo2 = function() {
    var estado = 'Nome do Estado: <b>{0}</b>';
    
    Ext.create('Ext.window.Window', {
         title: 'Visualizar dados do Estado'
        ,bodyPadding: 5
        ,html: Ext.String.format(estado, this.getDisplayValue())
        ,autoShow: true
        ,width: 340
        ,height: 90
        ,modal: true
    });
}
Ext.onReady(function(){
    // Habilitando os QuickTips
    Ext.tip.QuickTipManager.init();
    
    // Dados dos Estados
    var estados = [
         {'id': 1, 'nome': 'Minas Gerais'}
        ,{'id': 2, 'nome': 'Rio de Janeiro'}
        ,{'id': 3, 'nome': 'São Paulo'}
    ];
    
    // Definindo o Model do Store de Estados
    Ext.define('Estado', {
         extend: 'Ext.data.Model'
        ,fields: [
             {name: 'id', type: 'int'}
            ,{name: 'nome', type: 'string'}
        ]
    });
    
    var store = Ext.create('Ext.data.Store', {
         autoDestroy: true
        ,model: 'Estado'
        ,data: estados
    });
    
    var combo1 = Ext.create('Ext.form.field.ComboBox', {
         fieldLabel: 'Estados'
        ,displayField: 'nome'
        ,forceSelection: true
        ,valueField: 'id'
        ,emptyText: 'Selecione um Estado'
        ,store: store
        ,queryMode: 'local'
        ,typeAhead: true
        // Criando o novo trigger
        ,trigger2Cls: 'x-form-clear-trigger'
        ,onTrigger2Click: onTrigger2ClickCombo1
    });
    
    var combo2 = Ext.create('Ext.form.field.ComboBox', {
         fieldLabel: 'Estados'
        ,displayField: 'nome'
        ,forceSelection: true
        ,valueField: 'id'
        ,emptyText: 'Selecione um Estado'
        ,store: store
        ,queryMode: 'local'
        ,typeAhead: true
        // Criando o novo trigger
        ,trigger2Cls: 'x-form-search-trigger'
        ,onTrigger2Click: onTrigger2ClickCombo2
    });
    
    Ext.create('Ext.form.Panel', {
         renderTo: Ext.getBody()
        ,title: 'Exemplo Combobox trigger2'
        ,frame: true
        ,bodyPadding: 5
        ,width: 480
        ,fieldDefaults: {
             labelAlign: 'left'
            ,labelWidth: 80
            ,anchor: '100%'
        }
        ,items: [combo1, combo2]
    });
});
Conclusão
Como tinha mencionado para criar o novo botão informei a classe CSS para o atributo "trigger2Cls" e a função que deverá ser executada sendo esta informada no atributo "onTrigger2Click" para cada ComboBox (combo1 e combo2).
var onTrigger2ClickCombo1 = function() {
    this.clearValue();
    
    Ext.Msg.alert('Clear Value', 'Valor do ComboBox removido com sucesso!');
}

var onTrigger2ClickCombo2 = function() {
    var estado = 'Nome do Estado: <b>{0}</b>';
    
    Ext.create('Ext.window.Window', {
         title: 'Visualizar dados do Estado'
        ,bodyPadding: 5
        ,html: Ext.String.format(estado, this.getDisplayValue())
        ,autoShow: true
        ,width: 340
        ,height: 90
        ,modal: true
    });
}
Ext.onReady(function(){
    ...
    var combo1 = Ext.create('Ext.form.field.ComboBox', {
         fieldLabel: 'Estados'
        ,displayField: 'nome'
        ,forceSelection: true
        ,valueField: 'id'
        ,emptyText: 'Selecione um Estado'
        ,store: store
        ,queryMode: 'local'
        ,typeAhead: true
        // Criando o novo trigger
        ,trigger2Cls: 'x-form-clear-trigger'
        ,onTrigger2Click: onTrigger2ClickCombo1
    });
    
    var combo2 = Ext.create('Ext.form.field.ComboBox', {
         fieldLabel: 'Estados'
        ,displayField: 'nome'
        ,forceSelection: true
        ,valueField: 'id'
        ,emptyText: 'Selecione um Estado'
        ,store: store
        ,queryMode: 'local'
        ,typeAhead: true
        // Criando o novo trigger
        ,trigger2Cls: 'x-form-search-trigger'
        ,onTrigger2Click: onTrigger2ClickCombo2
    });
    ...
});
Nas linhas #32 e #46 são informadas as classes CSS essas já estão inclusas no arquivo de styles do ExtJS (ext-all-gray.css) é importante sempre utilizar as imagens como esta classe CSS implementa, pois facilita na questão de efeitos quando passamos o mouse em cima da imagem, ou quando está selecionada. Um exemplo de imagem seria a utilizada na classe CSS x-form-search-trigger:
Nas linhas #33 e #47 são informadas as funções de cada respectivo botão trigger. A primeira função "onTrigger2ClickCombo1" irá limpar os dados selecionado no ComboBox (combo1) e exibir uma mensagem informando a ação. Já a função "onTrigger2ClickCombo2" irá exibir uma Window com o texto do Estado selecionado.
Ação ao clicar no trigger2 do combo2
Existem algumas funcionalidades para este recurso como limpar os dados do ComboBox, exibir uma Window com um Form para cadastro de novos registros para o ComboBox, excluir o registro selecionado, entre outras ações.
Caso queira adicionar mais botões trigger no ComboBox é só seguir a ordem crescente dos atributos, ou seja, caso eu fosse inserir outro botão teria que criar no ComboBox os atributos "trigger3Cls" e "onTrigger3Click" com seus respectivos valores.
Então se tudo estiver certo abra o arquivo "combobox_trigger2.html" no browser que deverá exibir um Form com os dois Combos conforme a primeira imagem demonstrada neste post.
Espero ter sido claro sobre esse assunto mas qualquer dúvida deixe seu comentário ou mande um e-mail para bloglegolas@gmail.com.
Obrigado pela leitura e até o próximo.

Abril 13, 2012

Curso gratuito de ExtJS4 by Loiane Groner


Se você quer aprender ExtJS4 agora é a hora. A Loiane Groner lançou há um tempo em seu blog um Curso sobre ExtJS4, são várias vídeos aulas sobre o Framework explicando desde os conceitos básicos até os avançados.
Para quem não conhece o ExtJS é um Framework Javascript mantido pela empresa Sencha através de duas licenças sendo uma Comercial e outra Open Source (GPL license v3) para maiores detalhes veja no site da Sencha. Utilizado para desenvolvimento de aplicações RIA, cross browser, Orientado a Objeto e Eventos, contém vários componentes prontos como Windows, Grids (um dos melhores componentes), Forms, Panels, Charts, uma excelente API de documentação. A versão ExtJS4 surgiu com várias melhorias e novidades em relação as versões anteriores como o padrão de desenvolvimento MVC, a nova Classe ComponentQuery, melhorias nas performance dos componentes e os novos gráficos.
No site da Sencha e também no download do Framework estão alguns exemplos dos componentes do ExtJS, esses ajudam bastante no início do aprendizado. Abaixo as imagens da página de exemplo e da API Documentation do ExtJS4:

Exemplos dos componentes do ExtJS4

API Documentation ExtJS4
Todo conteúdo do curso está disponível no post do Blog da Loiane Groner sobre Curso de ExtJS 4 – Gratuito! recomendo para todos tanto iniciantes quanto já experientes, pois conhecimento nunca é demais.

Espero que gostem do curso como eu e muitos. Até o próximo post.

Março 11, 2012

Aprendendo PHP - JSON


Olá meu caro leitor(a), em meu último post sobre Carregar dados em um Formulário com jQuery demonstrei um plugin feito com jQuery onde é carregado dados em um formulário utilizando JSON, porém utilizei dados já mantidos pelo arquivo JavaScript. Agora iremos ver como trabalhar com JSON no PHP. Antes de demonstrar as funções JSON nativas do PHP vou explicar um pouco sobre JSON.
Ao contrário da imagem do famoso (pelo menos na minha época) personagem de filmes de terror Jason o JSON (JavaScript Object Notation - Notação de Objetos JavaScript) é um padrão de troca de informações entre Cliente (browser) e Servidor (PHP) assim como o XML que também é utilizado para essa funcionalidade. Na linguagem JavaScript JSON é muito mais do que só para trocar informações entre o browser e servidor é a forma de se utilizar OO em JavaScript, pois podemos criar Objects JSON com atributos e métodos (funções), mas não irei entrar em detalhes sobre JSON na linguagem JavaScript, pois não é o foco deste post.
JSON utiliza a notação "chave" com "valor" dando um exemplo bem simples seria como o CSS trabalha, pois informamos um elemento a ser inserido o estilo e dentro das chaves informamos o atributo e seu respectivo valor como o exemplo abaixo.
body {
    background-color: #c60;
}
Assim ao criarmos um JSON este terá um atributo com seu respectivo valor. Porém este valor tem um tipo, ou melhor falando é tipado, onde pode receber valores do tipo string, number, array, boolean ou até mesmo um Object. Abaixo está um modelo de um JSON.
// Object JSON
var aluno = {
     nome   : 'Legolas Kun'
    ,email  : 'legolas@teste.com'
    ,cursos : [
         {nome: 'Análise de Sistemas', periodos: 5}
        ,{nome: 'Engenharia', periodos: 10}
    ]
};
Esse exemplo acima é feito na linguagem JavaScript para demonstrar como é a estrutura do Object JSON. A difinição do JSON é dado pelos atributos informados entre os caracteres de chaves.
Debugando o código:
Linha #2 a #9: é a definição do Object JSON;
Linha #3 e #4: informamos dois atributos no Object "nome" e "email" com o valor do tipo string;
Linha #5 a #8: é definido no atributo "cursos" um array de Objects;

As funções nativas para manipulação de JSON foram incluidas na verão 5.2 do PHP, pois antes era necessário a inclusão de um arquivo para fazer esta manipulação. Abaixo irei demonstrar as funções nativas do PHP e exemplos práticos de sua utilização.
Obs.: Os funções do PHP utilizam os dados em UTF8, ou seja, os dados passados para codificar/decodificar devem estar em UTF8.

Sintaxe da função json_encode():
json_encode(mixed $valor)
Cria um Object JSON através do dados passado pelo parâmetro. Conforme documentação esse parêmtro pode ser de qualquer tipo menos resource que é uma variável com conteúdo externo.
Parâmetros:
$valor (mixed): Valor que será criado o JSON
$retorno (string): Retorna a String com o JSON formatado
Geralmente o parâmetro que passamos para esta função é um Array de dados, pois assim é criado o JSON conforme a estrutura passada. Abaixo irei demonstrar alguns exemplos de como utilizar esta função.

Exemplo 1: Gerando um JSON através do Array
<?php
// Array com os valores
$aluno = array(
    'nome'   => 'Legolas Kun',
    'email'  => 'legolas@teste.com' 
);
 
// Exibindo no browser o JSON criado
echo json_encode( $aluno );
 
/* 
Saída:
{"nome":"Legolas Kun","email":"legolas@teste.com"}
*/
?>
Exemplo 2: Gerando um JSON com Objects
<?php
// Array com os valores
$aluno = array(
    'nome'   => 'Legolas Kun',
    'email'  => 'legolas@teste.com',
    'cursos' => array(
        array(
            'nome'     => 'Analise de Sistemas',
            'periodos' => 5
        ),
        array(
            'nome'     => 'Engenharia',
            'periodos' => 10
        )
    )
);
 
// Exibindo no browser o JSON criado
echo json_encode( $aluno );
 
/* 
Saída:
{
    "nome":"Legolas Kun",
    "email":"legolas@teste.com"
    "cursos":[
        {
            "nome":"Analise de Sistemas",
            "periodos":5
        },
        {
            "nome":"Engenharia",
            "periodos":10
        }
    ]
}
*/
?>
Esse último exemplo demonstra a criação de um Object JSON com um atributo recebendo um Array de Objects JSON veja a definição da estrutura do Array que foi criado. O índice "cursos" recebe um Array multidimensional. Desta forma será criado um atributo no JSON com um Array de Objetos.

Agora que vimos como criar um Object JSON no PHP iremos ver como decodificar um JSON no PHP. Esse recurso é muito utilizado (pelo menos por mim) para receber um Object JSON via Ajax e criar um Array com os dados do JSON enviado. Vamos para a função do PHP.

Sintaxe da função json_decode():
json_decode(string $json [, boolean $assoc])
Recebe uma string com o Object JSON e retora um Object do PHP ou um Array dos dados dependendo do segundo parâmetro da função.
Parâmetros:
$json (string): String com o JSON a ser decodificado
$assoc (boolean): Quando informado o valor true o retorno será um Array Associativo, caso contrário um Object do PHP. Por default este valor é false.
$retorno (mixed): Irá retornar um Object ou Array dependendo do segundo parâmetro da função.
Exemplo 3: Decodificando um JSON simples
<?php
// JSON a ser decodificado
$json = '{"nome":"Legolas Kun","email":"legolas@teste.com"}';

var_dump( json_decode( $json ) );

/* 
Saída:
object(stdClass)[1]
  public 'nome' => string 'Legolas Kun' (length=11)
  public 'email' => string 'legolas@teste.com' (length=17)
*/
?>
Exemplo 4: Decodificando um JSON simples para Array
<?php
// JSON a ser decodificado
$json = '{"nome":"Legolas Kun","email":"legolas@teste.com"}';

var_dump( json_decode( $json, true ) );

/* 
Saída:
array
  'nome' => string 'Legolas Kun' (length=11)
  'email' => string 'legolas@teste.com' (length=17)
*/
?>
Veja esses dois exemplos o Exemplo 3 retorna um Object com os dados do JSON já o Exemplo 4 retorna um Array com os dados do JSON. Abaixo está um exemplo de decodificação de um JSON com Objects.

Exemplo 5: Decodificando um JSON com Objects
<?php
// JSON a ser decodificado
$json = '{
  "nome": "Legolas Kun",
  "email": "legolas@teste.com",
  "cursos": [
    {
      "nome": "Analise de Sistemas",
      "periodos": 5
    },
    {
      "nome": "Engenharia",
      "periodos": 10
    }
  ]
}';

var_dump( json_decode( $json ) );

/*
Saída:
object(stdClass)[1]
  public 'nome' => string 'Legolas Kun' (length=11)
  public 'email' => string 'legolas@teste.com' (length=17)
  public 'cursos' => 
    array
      0 => 
        object(stdClass)[2]
          public 'nome' => string 'Analise de Sistemas' (length=19)
          public 'periodos' => int 5
      1 => 
        object(stdClass)[3]
          public 'nome' => string 'Engenharia' (length=10)
          public 'periodos' => int 10
/*
?>
Veja neste exemplo que cada atributo do JSON se tornou um atributo do Object (Class) do PHP e o atributo "cursos" é um Array com Objects. Veja os exemplos abaixo de como utilizar o retorno do JSON decodificado.

Exemplo 6: Manipulando os dados decodificados
<?php
// JSON a ser decodificado
$json = '{
  "nome": "Legolas Kun",
  "email": "legolas@teste.com",
  "cursos": [
    {
      "nome": "Analise de Sistemas",
      "periodos": 5
    },
    {
      "nome": "Engenharia",
      "periodos": 10
    }
  ]
}';

// Criando o Array com os dados do JSON decodificado
$dadosJson = json_decode( $json, true );

// Saída: Nome: Legolas Kun Email: legolas@teste.com
echo sprintf( 'Nome: %s Email: %s',$dadosJson['nome'], $dadosJson['email'] );
?>
Neste exemplo decodifico um JSON em um Array, como cada atributo do JSON virá um índice do Array de retorno podemos acessar os valores de cada atributo do JSON pelo índice do Array como é demonstrado na linha #22 do código acima.
O exemplo abaixo irei utilizar o retorno default da função de decodificação do JSON. Para acessar os dados que foram criados devemos usar o conceito da POO (Programação Orientada a Objetos). Sei que não mencionei sobre POO em meu blog, mas irei informar sucintamente no exemplo como acessar os dados do retorno da decodificação utilizando as notações da OO.Irei utilizar o mesmo exemplo acima porém retirando o segundo parâmetro da função:
<?php
// JSON a ser decodificado
$json = '{
  "nome": "Legolas Kun",
  "email": "legolas@teste.com",
  "cursos": [
    {
      "nome": "Analise de Sistemas",
      "periodos": 5
    },
    {
      "nome": "Engenharia",
      "periodos": 10
    }
  ]
}';

// Criando o Object com os dados do JSON decodificado
$obj = json_decode( $json );

// Saída: Nome: Legolas Kun Email: legolas@teste.com Quantidade de Cursos: 2
echo sprintf( 'Nome: %s Email: %s Quantidade de Cursos: %d',$obj->nome, $obj->email, count( $obj->cursos ) );
?>
Em PHP na POO para acessarmos os atributos públicos (de livre acesso) de um Object devemos informar o objeto da Classe e utilizar os caracteres -> para informar qual atributo publico que queremos acessar. Veja na linha #22 que utilizamos a notação "$obj->nome". Estou informando que no Obejct de retorno eu irei acessar o valor do atributo "nome" da Classe. Assim exibindo o valor do atributo. Veja que eu informei o atributo dos cursos do objeto "$obj->cursos" dentro da função do PHP "count()". Esse atributo contém um Array com dois Objects PHP assim retornando o valor para a mensagem.

Por último porém não menos importante a função para resgatar o último erro ocorrido na Codificação/Decodificação do JSON. Infelizmente essa função só está habilitada na versão 5.3 ou superior do PHP.

Sintaxe da função json_last_error():
json_last_error()
Esta função não possui parâmetros e irá retornar o valor entre 0 e 5 que informa o tipo de erro que foi retornado, podemos utilizar as constantes do PHP para verificar o erro ocorrido na Codificação/Decodificação do JSON. Abaixo segue a tabela com as constantes:
Constantes PHP
Constante Valor
JSON_ERROR_NONE 0
JSON_ERROR_DEPTH 1
JSON_ERROR_STATE_MISMATCH 2
JSON_ERROR_CTRL_CHAR 3
JSON_ERROR_SYNTAX 4
JSON_ERROR_UTF8 5

Exemplo 7: Verificando alguns Erros da Decodificação
<?php
// String válida do JSON
$json[] = '{"Nome": "Legolas Kun"}';

// Inválida String JSON, pois os valores devem estar entre ""
$json[] = "{'Nome': 'Legolas Kun'}";

// Inválida String JSON, pois não é um JSON válido
$json[] = '{"Son Gohan"}';

// LOOP para verificar os erros da Decodificação
foreach ($json as $string) {
    echo 'Decodificado: ' . $string;
    json_decode($string);

    switch (json_last_error()) {
        case JSON_ERROR_NONE:
            echo ' - Sem Erros';
        break;
        case JSON_ERROR_DEPTH:
            echo ' - Número de índice máximo excedido';
        break;
        case JSON_ERROR_CTRL_CHAR:
            echo ' - Caractere de controle inesperado encontrado';
        break;
        case JSON_ERROR_SYNTAX:
            echo ' - Erro na sintaxe do JSON';
        break;
        case JSON_ERROR_UTF8:
            echo ' - UTF-8 caracteres malformados, possivelmente incorretamente codificado';
        break;
        default:
            echo ' - Erro desconhecido';
        break;
    }

    echo '<br />';
}

/*
Saída:
Decodificado: {"Nome": "Legolas Kun"} - Sem Erros
Decodificado: {'Nome': 'Legolas Kun'} - Erro na sintaxe do JSON
Decodificado: {"Son Gohan"} - Erro na sintaxe do JSON
*/
?>
Com o exemplo acima vimos que é fácil verificar se a decodificação do JSON retornou algum erro utilizando as constantes do PHP. Espero ter sido claro nesta parte de JSON com PHP, pois é um dos recursos que mais utilizo e que vejo mais dúvidas nos fóruns. Deixem seu comentário com dúvidas, sugestões.
Um forte abraço e até o próximo post que irei falar sobre estrutura de repetição fechando a parte de PHP estruturado.

Fontes:
http://www.php.net/manual/pt_BR/ref.json.php
http://www.json.org/
http://www.w3schools.com/xml/
http://www.w3schools.com/css/

Janeiro 20, 2012

Carregar dados em um Formulário com jQuery

Olá meu caro leitor, hoje venho trazer um post totalmente diferente dos demais publicados até o momento em meu blog. Este ano resolvi seguir uma linha diferente mostrando mais do que somente um tutorial ensinando a programar com PHP. Neste post irei falar um pouco de jQuery, ou melhor, de um plugin que fiz para popular dados em um formulário HTML.
Em uns dos meus projetos utilizando a lib jQuery eu precisei popular dados em um formulário HTML através da resposta de uma requisição Ajax. Através desta necessidade utilizando os recursos de plugins do jQuery foi criado meu primeiro plugin para preencher um formulário com os dados da resposta do Servidor, sendo essa resposta um Object  JSON .
Abaixo segue o código do plugin que carrega os dados em um formulário através de um Object JSON:
(function($){
    /**
     * Método que irá setar os valores nos campos do Form referente ao Object passado
     * via parâmetro.
     * @author Weslley Alves
     * @email wesshead@gmail.com
     * @version v0.0.2
     * @date 2011-12-19
     * @param {Object} data Obejto com os dados para os campos do Formulário
     * @return {Wrapped} Retorna o Elemento do Formulário
     * @use O atributo do Object ("nome") seja igual ao valor do atributo "name" do campo.
     * @example
     * HTML: 
     * Chamada: $('form').loadData({'nome':'Weslley Alves'});
     */
    $.fn.loadData = function(data){
        // Interando sobre o Object passado e setando os valores nos campos
        for(var campo in data){
            // Recuperando o elemento do campo
            var el = $(this).find('[name="'+ campo +'"]');
            
            // Verificando se foi resgatado mais de um Objeto
            if(el.length > 1){
                // LOOP para verificar se deve ser setado o valor
                $(el).each(function(i,v){
                    // Setando o valor no Elemento
                    $(this).setValue(data[campo]);
                });
            } else{
                // Setando o valor no Elemento
                $(el).setValue(data[campo]);
            }
        } // Fim da interação no Objeto com os dados
        
        // Retornando o Elemento do Formulário
        return this;
    }

    /**
     * Método que irá setar o valor passado via parâmetro no Elemento referênciado
     * @author Weslley Alves
     * @email wesshead@gmail.com
     * @version v0.0.1
     * @date 2011-12-19
     * @param {Number/String} value Valor a ser setado no Elemento referênciado
     * @return {Element} Retorna o Elemento referênciado
     * @use Deve ser chamado este método através do Elemento HTML.
     * @example
     * HTML: 
     * Chamada: $('#nome').setValue('Weslley Alves');
     */
    $.fn.setValue = function(value){
        // Campo "checkbox" ou "radio"
        if($(this).is('input[type=checkbox]') || $(this).is('input[type=radio]')){
            // Verificando se o valor do elemento é igual ao passado no Object
            if($(this).is('input[value='+ value +']')){
                $(this).attr('checked', true);
            }
        } else { // Demais campos
            $(this).val(value);
        }

        // Retornando o Elemento referênciado
        return this;
    }
})(jQuery);
Pelos comentários no código dá para ter uma ideia de como funciona o plugin para carregar os dados nos elementos de formulário. Mas vamos criar um exemplo para utilização deste plugin. Para isso será necessário os seguintes arquivos:
  • jquery-1.7.1.min.js (Última versão até a data deste post)
  • jquery-formjson.js (Código do plugin informando acima)
  • Arquivos de exemplo no Github. Para baixar clique com no botão download ou em cima do arquivo clique com o botão direito do mouse e selecione a opção "Salvar link como".
Os arquivos acima são necessários para o exemplo, assim crie uma pasta no seu DOCUMENT_ROOT (no meu caso d:\wamp\www) com o nome "blog_legolas" e dentro desta pasta crie uma pasta com o nome "preencher_formulario". Está última pasta que irá armazenar os arquivos baixados. Coloque todos arquivos nessa pasta ficando a estrutura como abaixo:
- www
  - blog_legolas
    - preencher_form
      estilos.css
      jquery.formjson.js
      jquery-1.7.1.min.js
      preencher_fomulario.html
      preencher_formulario.js

Abaixo está o HTML do arquivo "preencher_form.html":
<html>
  <head>
      <title>Exemplo preencher formulário com jQuery</title>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        
      <!-- CSS PARA OS CAMPOS DO FORMULÁRIO -->
      <link rel="stylesheet" type="text/css" href="estilos.css" />
        
      <!-- SCRIPT DO JQUERY -->
      <script type="text/javascript" src="jquery-1.7.1.min.js"></script>
        
      <!-- SCRIPTS COM O PLUGIN -->
      <script type="text/javascript" src="jquery.formjson.js"></script>
        
      <!-- SCRIPTS PARA PREENCHER OS DADOS -->
      <script type="text/javascript" src="preencher-formulario.js"></script>
  </head>
  <body>
    <div class="content">
      <h2>Carregar dados em um formulário com jQuery</h2>
      <form accept-charset="utf-8">
        <div class="form input">
          <label for="nome">Nome:</label>
          <input type="text" size="40" name="nome" id="nome" />
        </div>
        <div class="form input">
          <label for="email">E-mail:</label>
          <input type="text" size="40" name="email" id="email" />
        </div>
        <div class="form radio">
          <label>Sexo:</label>
          <input type="radio" name="sexo" id="sexo-masculino" value="M" />
          <label for="sexo-masculino">Masculino</label>
          <input type="radio" name="sexo" id="sexo-feminino" value="F" />
          <label for="sexo-feminino">Feminino</label>
        </div>
        <div class="form checkbox">
          <label for="ativo">Ativo:</label>
          <input type="checkbox" name="ativo" value="1" id="ativo" />
        </div>
        <div class="form select">
          <label for="estado-civil">Estado Civíl:</label>
          <select id="estado-civil" name="estadocivil">
            <option value="">Selecione um Estado Civíl</option>
            <option value="1">Casado (a)</option>
            <option value="2">Separado (a)</option>
            <option value="3">Solteiro (a)</option>
            <option value="4">Viúvo (a)</option>                        
          </select>
        </div>
        <div class="form textarea">
          <label for="observacao">Observação:</label>
          <textarea rows="3" name="observacao" id="observacao"></textarea>
        </div>
        <div class="form actions">
          <button id="btn-carregar-1" name="carregar-1">Carregar 1</button>
          <button id="btn-carregar-2" name="carregar-2">Carregar 2</button>
        </div>
      </form>
    </div>
  </body>
</html>
Formulário de exemplo
A imagem acima demonstra o resultado final do formulário. Abaixo está uma breve descrição do código e dos arquivos:
Linha #7: adiciono a página o arquivo com o CSS para o layout do formulário;
Linha #10: adiciono a página o arquivo Javascript da lib do jQuery, este pode ser baixado no site do jQuery;
Linha #13: adiciono a página o arquivo Javascript com o código do plugin criado;
Linha #16: adiciono a página o arquivo Javascript com o exemplo do uso do plugin;
Linha #19 a 59: HTML com o Formulário de exemplo, note que temos alguns elementos de formulário com seus respectivos nomes e ids. Esses campos serão preenchidos através do plugin "jquery.formjson.js";
Linha #56 a 57: botões que irão setar os dados no Form.
Abaixo está o código referente ao arquivo javascript "preencher_formulario.js". Este arquivo contém dois objects com os valores a serem setados nos campos do formulário e a ação de cada botão.
$(document).ready(function(){
    // Objeto com os dados para serem preenchidos no Formulário
    var objeto1 = {
         'nome'         : 'Weslley Alves'
        ,'email'        : 'wesshead@gmail.com'
        ,'sexo'         : 'M'
        ,'ativo'        : 1
        ,'estadocivil'  : 1
        ,'observacao'   : 'Esse texto foi inserido dinâmicamente pelo Plugin!!!'
    };
    
    // Objeto com os dados para serem preenchidos no Formulário
    var objeto2 = {
         'nome'         : 'Ifitrini Helm'
        ,'email'        : 'ifitrini@gmail.com'
        ,'sexo'         : 'F'
        ,'ativo'        : 0
        ,'estadocivil'  : 3
        ,'observacao'   : 'Texto atualizado através do object!!!'
    };
    
    // Monitorando o evento Click do primeiro botão do Formulário
    $('#btn-carregar-1').bind('click', function(e){
        // Parando a ação do botão
        e.preventDefault();
        
        // Carregando os dados no Formulário
        $('form').loadData(objeto1);
    });
    
    // Monitorando o evento Click do segundo botão do Formulário
    $('#btn-carregar-2').bind('click', function(e){
        // Parando a ação do botão
        e.preventDefault();
        
        // Carregando os dados no Formulário
        $('form').loadData(objeto2);
    });
});
Linha #3 a #10: criado o Object com os dados para serem preenchidos no formulário quando o botão "Carregar 1" for clicado;
Linha #13 a #20: criado o Object com os dados para serem preenchidos no formulário quando o botão "Carregar 2" for clicado;
Linha #23 a #29: monitoro o evento "click" do botão de id "btn-carregar-1" para que quando for clicado preencher o formulário com os dados no Object "objeto1"; O método do event "preventDefault()" irá parar o evento do botão, ou melhor, do elemento.
Linha #32 a #38: monitoro o evento "click" do botão de id "btn-carregar-2" para que quando for clicado preencher o formulário com os dados no Object "objeto2";
Nos dois botões eu informo utilizando o "bind" do jQuery que deve ser monitorado o evento "click" do elemento e informo que quando este evento acontecer deve ser invocada a função passada como segundo parâmetro no método "bind". Veja que esta função recebe um parâmetro que é o Object Event da ação. Para maiores detalhes veja na API do jQuery sobre o evento click.
Agora só falta testar no browser e ver o resultado. Vá no endereço http://localhost/blog_legolas/preencher_formulario/preencher_formulario.html e clique no botão "Carregar 1" deve ser preenchido o formulário com os dados do Object na referência "objeto1" do arquivo javascript, conforme imagem abaixo:
Dados carregados do objeto1
Agora clique no botão "Carregar 2" e será preenchido o formulário com os dados do do Object na referência "objeto1" do arquivo javascript, conforme imagem abaixo:
Dados carregados do objeto2
O exemplo é simples, mas o plugin pode ser bem útil para formulários com vários campos. Espero que esse plugin possa ajudar muitos no dia a dia do desenvolvimento. Qualquer dúvida, sugestão ou até mesmo críticas deixem o seu comentário.
Obrigado pela leitura e até o próximo post onde irei mostrar a utilização de Objects JSON com PHP.

Dezembro 25, 2011

Aprendendo PHP - Incluindo arquivos PHP


No último post sobre "Aprendendo PHP - Criando Funções" nós criamos as nossas próprias funções como a função para alterar o formato da data, verificação de um valor no Array. Geralmente as funções são criadas em um arquivo separado para ficar mais fácil a manutenção e o gerenciamento dessas funções. Porém quando precisarmos utilizar alguma função ou conteúdo contida em um outro arquivo PHP nós devemos incluir este arquivo nas nossas páginas. O PHP nós fornece as funções "include" e "require", as duas servem para incluir o conteúdo do arquivo informado porém a diferença entre as duas funções seria que a função "include" caso ocorra um erro na inclusão dos dados do arquivo um erro do tipo "warning" será lançado e sua aplicação não irá parar, já a função "require" caso ocorra algum erro na inclusão do conteúdo do arquivo será lançado um erro do tipo "fatal error" parando a execução da aplicação.
Vamos simular algumas situações de inclusão de arquivos para isso primeiramente iremos construir a nossa estrutura de pasta.
Se você está acompanhando desde o início dos meus post deve ter visto o post "Instalando e Configurando o WAMP" nele menciono sobre como configurar o WAMP no ambiente Windows. Para este post iremos precisar de um servidor WEB para demonstrar os exemplos de inclusão de conteúdo de arquivos nas páginas PHP. Caso você utilize outro tipo de serviço como o XAMP ou até mesmo Apache crie uma pasta no seu DOCUMENT_ROOT (no meu caso pasta www do WAMP) com o nome "blog_legolas" (sem aspas). Crie o arquivo "includes.php" dentro desta pasta criada com o conteúdo abaixo:
<?php
/**
 * Função que irá receber uma data no formato YYYY-MM-DD e irá converter para o formato DD/MM/YYYY
 * @param {String} $data String com a data no formato YYYY-MM-DD
 * @return {String} Retorna a data no formato DD/MM/YYYY
 */
function alterarDataBanco($data) {
    // Criando um Array com os dados da data
    $dadosData = explode("-", $data);

    // Criando a String de retorno no formato DD/MM/YYYY
    return $dadosData[2] ."/". $dadosData[1] ."/". $dadosData[0];
}
?>
Esta é a mesma função que criamos no meu último post, iremos utilizar esta para demonstrar a inclusão de arquivos no PHP. Agora crie um arquivo com o nome "inclusao_arquivos.php" com o conteúdo abaixo:
<?php
// Chamando a função para converter a data
echo alterarDataBanco("2011-01-31");
?>
Agora execute esta página no browser (http://localhost/blog_legolas/inclusao_arquivos.php). Se tudo ocorrer certo será exibido um erro do tipo "fatal error" informando que não foi possível chamar a função conforme imagem abaixo:
Erro retornado pelo PHP
Isso ocorre porque está função não está definida dentro do no nosso script. Para termos acesso a função que está em outro arquivo devemos incluir o arquivo com as funções no nosso script. Para isso irei utilizar uma das duas funções fornecidas pelo PHP. Assim o código da página "inclusao_arquivos.php" ficará como está abaixo:
<?php
// Incluindo o arquivo com as funcionalidades
include("includes.php");

// Chamando a função para converter a data
echo alterarDataBanco("2011-01-31"); // Saída: 31/01/2011
?>
Agora atualize a página em seu browser e verifique que o erro não existe mais mostrando o resultado "31/01/2011". O resultado seria o mesmo se na linha #2 eu utilizasse a função "require()" informando o arquivo a ser incluído.

Adicionando conteúdo de um arquivo:
Também podemos inserir conteúdos de outros arquivos não necessariamente funções como o exemplo acima demonstra. Vamos supor um exemplo que no sistema existe um Menu que aparece em toda aplicação, daí podemos criar um arquivo com o Menu e incluir este em nossos scripts.
Vamos criar o arquivo com o Menu do sistema e para estudarmos mais sobre inclusão de arquivo com PHP nós iremos armazenar o arquivo com o Menu em um diretório diferente do arquivo que irá requisitar este. Crie uma pasta dentro do projeto com o nome de "includes" e dentro desta crie um arquivo chamado menu.html. Ficando assim a estrutura:
- blog_legolas
  - includes
      menu.html
Note que criamos um arquivo HTML ao invés de um PHP, pois como meu arquivo irá ter somente dados estáticos não preciso criar um arquivo PHP para isso.
Obs.: sempre quando o seu arquivo não conter scripts PHP salve ele como HTML, pois cada arquivo PHP é interpretado pelo Servidor Web e se não há necessidade de ser interpretado este não deve ser salvo como PHP.
Informe o código abaixo no arquivo HTML criado:

Agora crie um novo arquivo dentro da pasta do projeto com o nome de "cadastro_usuario.php" com o conteúdo abaixo:
<html>
<head>
    <title>Cadastrar Usuário</title>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    
    <style type="text/css">
        .menu {
            border: none;
            
            padding: 0;                
        }
        
        .menu {
            border: none;
            font: 12px Gill, Helvetica, sans-serif;
            margin: 15px 0;
        }
        .menu li {
            list-style: none; 
            margin: 0;
            display: inline;
        }
        .menu li a {
            background: #e6b800;
            border: 1px solid #404040; 
            color: #fff;
            margin: 0;
            padding: 5px;
            text-decoration: none;
        }
        .menu li a:hover {
            background: #003d4c;
            color: #fff;
            border-color: #fff;
        }
    </style>
</head>
<body>
    <?php
        // Incluindo o arquivo com menu Principal
        include('includes/menu.html');
    ?>
</body>
</html>
Esse nosso arquivo tem conteúdo HTML e PHP. Note que o nosso arquivo está salvo com a extensão PHP, pois temos um código PHP informado no meio do HTML. Esse é um recurso muito utilizado no dia a dia do PHP e também outas linguagens Server Side. No meio de código HTML podemos embutir códigos PHP para acrescentar dinamismos nos código.
Debugando o código:
#6 a 36: estilo para o menu da aplicação;
#39 a 42: inclusão do arquivo com o menu da aplicação;
Note na linha #41 informei o caminho onde o arquivo está, pois como estamos na estrutura principal do nosso projeto, ou seja, estamos dentro da pasta "blog_legolas" devemos informar para a função de inclusão de arquivos que este está dentro da pasta "includes" com o nome "menu.html".
Vá no browser e execute este novo arquivo para verificar como ficou o menu (http://localhost/blog_legolas/cadastro_usuario.php).
Menu principal da aplicação
Neste exemplo utilizamos a estrutura de pastas para informar a localização exata do arquivo. Um outro exemplo de inclusão seria incluir um outro arquivo que está uma estrutura acima da onde o arquivo se encontra, por exemplo, vamos dizer que temos um arquivo dentro da pasta includes com o nome "usuario.php" só que este arquivo deve incluir outro arquivo que está na pasta do projeto "blog_legolas". Desta forma devemos informar na função de inclusão que deve ser retroagido uma estrutura de pasta e resgatar o arquivo. Exemplo:
<?php
// Incluindo o arquivo na estrutura acima
include('../banco.html');
?>
Utilizando os caracteres "../" informamos que deve ser voltado uma estrutura de pasta e resgatar o arquivo "banco.php". Outro exemplo seria incluir um arquivo que está em uma pasta na estrutura principal do projeto:
<?php
// Incluindo o arquivo na pasta em uma estrutura acima 
include('../class/banco.html');
?>
Informamos neste exemplo que deve ser retornado uma estrutura de pastas, entrar na pasta "classes" e resgatar o arquivo. Esta referência de estrutura de arquivo depende de qual local estamos. Seguindo o exemplo dado. Temos na estrutura do projeto duas pastas "includes" e "class" onde a primeira pasta contém o arquivo "usuario.php" e a segunda pasta contém o arquivo "banco.php". Assim ficando a estrutura abaixo:
- blog_legolas
  -class
      banco.php
  -includes
      menu.html
  inclusao_arquivo.php
Se estamos no arquivo "banco.php" e desejamento incluir um arquivo que está na estrutura inicial do projeto, deve ser utilizado os caracteres "../" para denotar que deve ser voltado uma estrutura, ou seja, voltar para a pasta principal do projeto.
Se estamos no arquivo "inclusao_arquivo.php" e desejamento incluir um arquivo que está na pasta "includes" que está na estrutura inicial do projeto, deve ser utilizado o nome da pasta e o arquivo, pois estamos na estrutura principal do projeto "includes/menu.html".
Se estamos no arquivo "menu.php" e desejamento incluir um arquivo que está na pasta "class" que está na estrutura inicial do projeto, deve ser utilizado os caracteres "../" para denotar que deve ser voltado uma estrutura, ou seja, voltar para a pasta principal do projeto e dentro da pasta "class" incluir o arquivo "banco.php" ficando assim a string da função de inclusão "../class/banco.php".

Inclusões de arquivo são muito importantes, pois podemos separar a lógica da aplicação em arquivos diferentes e incluir este onde a lógica deverá ser utilizada, como por exemplo este menu. Criamos uma única vez a lógica do menu (apesar de ser estático) e incluímos este arquivo em toda aplicação, assim se alguma opção do menu for retirada ou acrescentada somente este arquivo deve ser alterado, não todos os arquivos da aplicação.
Então meu caro leitor vou ficando por aqui e espero que esse possa auxiliar e direcionar muitos no aprendizado com o PHP.
Forte abraço e até a próxima.

Fontes:
http://www.w3schools.com/php/php_includes.asp
http://php.net/manual/pt_BR/function.include.php
http://php.net/manual/pt_BR/function.require.php

Outubro 27, 2011

Aprendendo PHP - Criando Funções

Meu caro leitor(a) depois de muito tempo sem postar venho através deste retornar nos tópicos "Aprendendo PHP". Como prometido hoje iremos desenvolver nossas próprias funções no PHP. O post anterior "Aprendendo PHP - Arrays" eu falei um pouco de algumas funções do PHP para tratamento de Arrays. Essas funções já são da linguagem, mas as vezes temos a necessidade de criar algo específico para uma funcionalidade do sistema, algo que pode ser reaproveitado em todo código, etc.
Para a criação de funções deve ser seguido alguns conceitos:
- O nome da função não pode conter acentuação
- O nome da função não pode conter caracteres especiais (. , / ? ...)
- O nome da função não pode ser uma palavra reservada do PHP (int, string, for, const, etc).
A criação de novas funções segue a estrutura abaixo:
<?php
function nomeDaFuncao(param_1, param_2, ..., param_n) {
    // Toda lógica da função
    return "retorna da função";
}
?>
O código acima demonstra o esqueleto de uma função. Primeiramente começamos a declarar esta utilizando a palavra reservada do PHP (function), após informamos o nome desta função (nomeDaFuncao) e dentro do parênteses iremos informar os parâmetros que esta função recebe (nem toda função é obrigada a receber parâmetros), entre as chaves iremos informar toda a lógica da função e por último podemos informar o retorno (return) desta função. O retorno da função não é obrigatório, pois nem todas as funções irão retornar dados.
Então vamos ao que interessa, o código abaixo demonstra a criação de uma nova função:
Criando uma função:
<?php
function exibirMensagem() {
    echo "Olá meu nome é Weslley Alves";
}
    
// Chamando a função
exibirMensagem();
?>
Debugando o código:
Linha #2: declaração da função. Sempre a palavra reservada function seguido pelo nome da função;
Linha #3: toda lógica da função deve ficar dentro do scopo¹ da função, ou seja, entre as chaves da denominação da função. Neste caso estou só exibindo um texto no browser;
Linha #7: local onde estou chamando minha função;
1 - scopo: abrangência da função. Corpo da função
Esta função é bem simples só exibe um texto com o nome de uma pessoa, mas caso este nome sejá dinâmico, ou seja, preciso informar qual o nome deve ser exibido. Podemos passar parâmetros para esta função. Note que esta função não recebe nenhum parâmetro e nem retorno.

Passando parâmetros para a função:
A passagem de parâmetros é muito comum em funções, pois geralmente precisamos receber algum valor para a lógica da função ser mais concisa. A passagem de parâmetros acontece dentro dos parenteses da função. Esses parâmetros podem ser de qualquer tipo String, Int, Array, Object, etc
Em outras linguagens esses parâmetros teriam que ser tipados (informado o tipo do valor que será recebido), porém como já foi falado em um dos meu posts anteriores PHP é fracamente tipado, então não é necessário informar o tipo de dados que será recebido, mas temos que sempre tomar cuidado com isso, pois caso a lógica da função espera receber um int e você descuidadosamente envia uma string daí pode surtir em algum erro de lógica.
Então iremos aproveitar a mesma função acima alterando para que essa receba um parâmetro com o nome a ser exibido:
<?php
/**
 * Função que irá receber o nome do Usuário logado
 * @param {String} $nomeUsuario Variável que irá receber o nome do Usuário Logado
 */
function exibirMensagem($nomeUsuario) {
    echo "Olá meu nome é $nomeUsuario";
}
   
// Chamando a função
exibirMensagem("Legolas Kun"); // Saída: Olá meu nome é Legolas Kun
?>
Debugando o código:
Linha #2 a #5: comentário da função;
Linha #6: ; declaração da função definindo o nome e o parâmetro para ser recebido;
Linha #11: chamando a função passando como parâmetro uma string com o nome do usuário logado;

Algo muito importante que também devemos saber é que as vezes podemos mencionar que o parâmetro existe na assinatura da função, mas ele não é obrigatório. "Mas como assim?"
No PHP temos a facilidade de informar um valor default para o parâmetro da função. Desta forma ao ser chamada a função não necessariamente precisamos passar o parâmetro, mas assim o PHP irá utilizar o valor informado na criação do parâmetro. O exemplo abaixo demonstra uma função que irá verificar se existe um valor no array de Nomes. Por default este nome será o "Nagato":
<?php
/**
 * Função que irá verificar se existe um valor no array de Nomes
 * @param {String} $nomeUsuario Variável que irá receber o nome do Usuário a ser verificado no array. Defaul "Nagato"
 * @return {Boolean} Retorna true caso exista o valor no array ou false
 */
function checkValor($nomeUsuario = "Nagato") {
    // Array dos Nomes
    $arrNomes = array("Weslley", "Legolas", "Hiei");
      
    // Verifica se existe o valor no array
    return in_array($nomeUsuario, $arrNomes);
}
    
// Chamando a função
var_dump(checkValor("Legolas")); // Saída: boolean true
    
// Chamando a função sem passar nome
var_dump(checkValor()); // Saída: boolean false    
?>
Debugando o código:
Linha #2 a #6: comentário da função;
Linha #7 a #13: definição da função que recebe por parâmetro uma String o nome a ser verificado se existe dentro do array de nomes. Por default estamos mencionando que o valor do parâmetro será "Nagato".
Linha #12: utilizo a função do PHP para verificar se existe o nome passado via parâmetro no array de nomes. Esta função do PHP retorna true se o valor existir no array ou false.
Linha #16 e #19: verifico com a função PHP var_dump o tipo do retorno da função.
Na linha #16 é retornado true, pois o nome passado via parâmetro existe no Array de nomes. Já na linha #19 não passamos nenhum parâmetro assim a função irá utilizar o valor default informado para o parâmetro neste caso "Nagato".

Criando uma função para formatar data:
Vamos agora criar um método muito comum no dia a dia dos programadores. Esta função irá converter uma data no formato "YYYY-MM-DD" em uma data no formato "DD/MM/YYYY". Isso é muito comum no dia a dia, pois o primeiro formato geralmente é como o dado está salvo no Banco de Dados já o segundo é como deve ser exibido para o usuário. Existem outras formas de se fazer esta alteração de formato, mas como esta função é mais para didática irei demonstrar como fazer pelo PHP. Vamos então analisar o código abaixo:
<?php
/**
 * Função que irá receber uma data no formato YYYY-MM-DD e irá converter para o formato DD/MM/YYYY
 * @param {String} $data String com a data no formato YYYY-MM-DD
 * @return {String} Retorna a data no formato DD/MM/YYYY
 */
function alterarDataBanco($data) {
    // Criando um Array com os dados da data
    $dadosData = explode("-", $data);

    // Criando a String de retorno no formato DD/MM/YYYY
    return $dadosData[2] ."/". $dadosData[1] ."/". $dadosData[0];
}

// Chamando a função para converter a data
echo alterarDataBanco("2011-01-31"); // Saída: 31/01/2011
?>
Debugando o código:
Linha #2 a #6: comentários da função;
Linha #7 a #13: criação da função que recebe por parâmetro uma String com uma data no formato YYYY-MM-DDD.
Linha #9: utilizo a função do PHP "explode" que retorna um Array com os fragmentos da String cujo estejam separados pelo carácter passado no primeiro parâmetro.
Linha #12: utilizo a concatenação criando uma String com a data no formato DD/MM/YYYY.
Linha #16: chamada da função passando como parâmetro a data no formato YYYY-MM-DD.
Para fazer o caminho contrário, ou seja, receber a data no formato DD/MM/YYYY e retornar uma String no formato YYYY-MM-DD seria alterado somente o caracter na linha #9 e o retorno da data na linha #12 da função.

Criamos funções quando notamos que existe uma lógica no desenvolvimento que poderá ser reutilizada, como o nosso exemplo acima a função "alterarDataBanco()" pode ser utilizada em todas as páginas PHP que criarmos.
No próximo post irei falar sobre como incluir arquivos na página PHP utilizando as funções disponibilizadas pelo PHP. Então até mais.

Junho 22, 2011

Aprendendo PHP - Arrays

Bom meu caro leitor, depois de um bom tempo sem postar volto através deste para contuniar os posts sobre "Aprendendo PHP" neste irei demonstrar algumas funções de manipulação de Arrays do PHP. Este é uma continuação do post Quem quer aprender PHP?
Recomendo que se você não saiba o que é um Array, o que são Arrays multidimensionais, Arrays associativos dê uma olhada neste post para esclarecimento das dúvidas.
Fica difícil englobar TODAS as funções de Manipulação de Arrays somente neste post e para dizer a verdade teria muitos posts sobre este assunto, mas irei abordar aquelas funções que mais utilizo e que também vejo em muitos tutoriais. Então vamos aos estudos.

Sintaxe da função print_r:
print_r(mixed $expressao [, bool $retorno = false ])
Imprime a informação sobre uma variável de forma legível. Muito utilizado para impressão de dados de Array mostrando os índices e o seus respectivos valores.
Parâmetros:
$expressao (mixed): A expressão a ser impressa
$retorno (bool): este parâmetro é utilizado caso queira ao invés de exibir a informação na tela resgatar esta.
Retorno:
(mixed) Caso a expressão seja do type string, integer ou float será exibido o valor da variável, caso seja fornecido um array será demonstrado este com seus indíces.
Exemplos:
<?php
    // Array com os dados
    $material = array("Lápis", "Borracha");

    // Exibindo na tela o resultado
    print_r($material); // Saída: Array ( [0] => Lápis [1] => Borracha ) 
?>

Sintaxe da função count:
count(mixed $arr [, int $modo ])
Resgata o número de elementos do Array.
Parâmetros:
$arr (mixed): Array a ser verificado a quantidade de elementos
$modo (int): Este parâmetro é mais utilizado para Arrays Multidimensional. Se for especificado COUNT_RECURSIVE (ou 1) irá recursivamente contar todos os elementos da Matriz (Opcional).
Retorno:
(int) Retorna o número de elementos do Array.
Exemplos:
<?php
    // Array com os dados
    $alunos = array("Legolas Kun","Klaus Helm","Toguro");

    count($alunos); // Saída: 3
?>

Sintaxe da função sort:
sort(array $entrada, [, int $sort_flags ])
Essa função ordena os valores de um array. Os elementos serão ordenados do menor para o maior ao final da execução dessa função.
Parâmetros:
$entrada (array): Array a ser ordenado
$sort_flags (int): Flag utilizado para alterar o modo de ordenação.
Flags para tipo de ordenação:
SORT_REGULAR: compara os itens normalmente (não modifica o tipo) SORT_NUMERIC: compara os itens numericamente
SORT_STRING: compara os itens como strings
SORT_LOCALE_STRING: compara os itens como strings, baseado no locale atual. Adicionado no PHP 4.4.0 e PHP 5.0.2. Antes do PHP 6, usava local do sistema, que pode ser alterado usando setlocale(). Já no PHP 6, você precisa usar a função i18n_loc_set_default().

Retorno:
(boll) Retorna TRUE caso a ordenação tenha sido realizada com sucesso ou FALSE caso o contrário.
Exemplos:
<?php
    // Criando o Array dos Índices
    $estados = array("MG","SP","RJ","SC","CE","RR");

    // Ordenando os dados do Array
    sort($estados);

    // Imprimindo o Array
    print_r($estados); // Saída: Array([0]=>CE [1]=>MG [2]=>RJ [3]=>RR [4]=>SC [5]=>SP)
?>

Sintaxe da função array_push:
array_push(array $array, mixed $valor [, mixed $... ])
Insere novos índices no array passado como parametro.
Parâmetros:
$array (array): Array a ser adicionado novos elementos
$valor (mixed): Valor a ser acrescentado no array.
$... (mixed): Valores a serem acrescentados no array (Opcional).

Retorno:
(int) Retorna o número de elementos do novo Array.
Exemplos:
<?php
    // Criando o Array
    $alunos = array("Legolas Kun","Klaus Helm","Toguro");

    // Adicionando novos Elementos no Array
    $count = array_push($alunos, "Hiei Tash", "Themary");

    echo "Número de Elementos: $count"; // Saída: Número de Elementos: 5

    // Imprimindo o Array
    print_r($alunos); // Saída: Array ( [0] => Legolas Kun [1] => Klaus Helm [2] => Toguro [3] => Hiei Tash [4] => Themary )
?>

Sintaxe da função array_merge:
array_merge(array $array, [, array $array1 [, array $... ]])
Funde um ou mais arrays.
Parâmetros:
$array (array): Array principal para ser fundido.
$array1 (array): Array que será fundido no Array principal.
$... (mixed): Demais Arrays para fundir no Array principal.

Retorno:
(array) Retorna novo Array fundido.
Exemplos:
<?php
    // Criando o Array Principal
    $estados = array("MG","SP","RJ","SC");
    // Array com novos estados
    $nEstados = array("CE","RR");
    // Fundindo os Arrays
    $novoArray = array_merge($estados, $nEstados);
    // Imprimindo o novo Array
    print_r($novoArray); // Saída: Array ([0]=>MG [1]=>SP [2]=>RJ [3]=>SC [4]=>CE [5]=>RR)
?>

Sintaxe da função array_combine:
array_combine(array $indices, array $valores)
Esta função cria um array Associativo utilizando um Array para os índices e outro para os valores.
Parâmetros:
$indices (array): Array contendo os índices do novo Array.
$valores (array): Array com os valores de cada índice do Array de índices.

Retorno:
(array) Retorna novo Array criado ou FALSE se o número de elementos de cada array não são iguais ou se os arrays são vazios.
Exemplos:
<?php
    // Criando o Array dos Índices
    $indices = array("idade","nome","sexo","email");
    // Criando o Array dos Valores
    $valores = array("27","Legolas Kun","M","legolas@teste.com.br");
    // Fundindo os Arrays
    $novoArray = array_combine($indices, $valores);
    // Imprimindo o Array
    print_r($novoArray); // Saída: Array ([idade]=>27 [nome]=>Legolas Kun [sexo]=>M [email]=>legolas@teste.com.br)
?>

Sintaxe da função array_diff:
array_diff ( array $array1 , array $array2 [, array $ ... ] )
Esta função irá comparar a diferença entre o array1 com o array2.
Parâmetros:
$arra1(array): Array que será comparado
$array2 (array): Array para comparar.
$... (array): Outros Arrays para comparação.

Retorno:
(array) Retorna um Array com todas as entradas de array1 que não estão presentes em algum dos outros arrays.
Exemplos:
<?php
    // Criando o Array a ser comparado
    $conjA = array(1,2,3,4,5);

    // Criando o Array a ser comparado
    $conjB = array(3,4);

    // Recebendo o resultado da Diferença A - B
    $dif = array_diff($conjA, $conjB);

    // Imprimindo o Array
    print_r($dif); // Saída: Array([0]=>1 [1]=>2 [4]=>5)
?>
Não sei se você se lembra, mas utilizei neste exemplo o conceito de Conjuntos Numéricos da Matemática, pois a idéia desta função é exatamente o mesmo da Matemática.
Obs.: Se você notar na Saída do comando na linha #12 a função array_diff retorna além dos valores que contém no conjunto A ($conjA) e não está no conjunto B ($conjB) ele retorna também o índice do valor no Array, como por exemplo o valor "5" que tem o índice "4" conforme o Array $conjA.

Sintaxe da função array_replace:
array_replace ( array &$base , array &$array1 [, array &$... ] )
Esta função irá trocar o valor dos registros do Array $base pelos valores passados nos demais Arrays.
Parâmetros:
$base(array): Array com os valores base para serem substituidos.
$array1 (array): Array com o índice e valor a ser substituido no Array $base
$... (array): Outros Arrays para substituição.

Retorno:
(array) Retorna o novo Array com os valores substituidos.
Exemplos:
<?php
    // Criando o Array de base
    $nicks = array("Legolas", "Rodrigo Santos", "Crow", "Bigodin");

    // Criando o Array com os índices e valores a serem substituidos
    $nomes = array(0 => "Weslley Alves", 2 => "Igor", 3 => "Bruno");

    // Imprimindo o Array de Base antes da substituição
    print_r($nicks); // Saída: Array ([0]=>Legolas [1]=>Rodrigo Santos [2]=>Crow [3]=>Bigodin) 

    // Substituindo os valores
    $novoArray = array_replace($nicks, $nomes);

    // Exibindo uma quebra de linha HTML
    echo "
";

    // Imprimindo o Array de Base antes da substituição
    print_r($novoArray); // Saída: Array ([0]=>Weslley Alves [1]=>Rodrigo Santos [2]=>Igor [3]=>Bruno)
?>
Neste exemplo foi substituido os Nicks do usuário pelo Nome dele, como podem ver o Array "$nomes" eu informo qual posição do Array de base ($nicks) que deverá ser substituido pelo valor informado no meu Array de substituição ($nomes).
Abaixo um exmplo com Array associativo:
<?php
    // Criando o Array de base
    $dados = array("nome" => "Legolas", "idade" => "", "sexo" => "M", "profissao" => "");

    // Criando o Array com o índice e valor a ser substituido
    $profissao = array("profissao" => "Programador PHP");

    // Criando o Array com o índice e valor a ser substituido
    $idade = array("idade" => "27");

    // Substituindo os valores
    $novoArray = array_replace($dados, $profissao, $idade);

    // Imprimindo o Array de Base antes da substituição
    print_r($novoArray); // Saída: Array ([nome]=>Legolas [idade]=>27 [sexo]=>M [profissao]=>Programador PHP)
?>
Note que neste exemplo além de ser utilizado o índice associativo do Array eu utilizei mais de um Array para substituição dos valores, onde o primeiro Array ($profissao) irá substituir o valor do índice "profissao" do Array de Base ($dados), já o segundo Array de substituição irá trocar o valor do índice "idade" do Array de Base.
Com esse último exemplo finalizo este post sobre funções PHP para Arrays e espero que este possa ajudar muitos leitores. Mais detalhes acesssem o link de referência abaixo para ver mais funções de Manipulação de Arrays.
No próximo post irei demonstrar a criação de funções no PHP como por exemplo para validar data, para exibição de dados, etc.
Muito obrigado pela leitura e qualquer dúvida, sugestão é só comentar.

Referência:
http://www.php.net/manual/pt_BR/ref.array.php