Não seria ótimo se pudéssemos importar nossos dados em JSON no PHP e tratá-los como no JavaScript? Pois é, a partir do PHP 5.2.0 já temos uma extensão para JSON incluída, e é dela que vou falar nesse post.

Com o advento do Ajax, JSON se tornou um formato para intercâmbio de dados bem mais eficiente e compacto que XML. E nada como tratá-lo como um objeto também no lado do servidor, assim como fazemos no JavaScript. As duas funções que tratam da conversão objeto-string e string-objeto no PHP são json_encode e json_decode, respectivamente.

Objeto para String

Quem já não amaldiçoou o PHP transformando manualmente um array em uma string JSON? É uma tarefa fácil, mas extremamente chata, principalmente se precisarmos usar recursão. A função json_encode faz todo o trabalho sujo pra você. Basta passar o array contendo os dados como parâmetro.

$json = array("user" => "JulioGreff", "action" => "status", "text" => "online");
echo json_encode($json);

Além de simples arrays como esse, podemos fazer algo mais complexo, com arrays dentro de arrays, em vários níveis.

$json = array("group" => "Web", "action" => "list");
$json["list"] = array("JavaScript", "Ajax", "WebStandards");
$json["users"] = array(array("name" => "JulioGreff", "status" => "online"));
echo json_encode($json);

No exemplo, além do sub-membro também coloquei um array comum, criado certinho. Adeus, foreach!

String para Objeto

Essa era uma parte complicada, transformar uma string recebida em um objeto, para podermos trabalhar. Com a função json_decode virou moleza.

$json = '{"user_id": 5, "action": "post", "text": "JSON no PHP"}';
$json = json_decode($json);
echo $json->action; // "post"
echo $json->text; // "JSON no PHP"

Veja que estamos usando um objeto, e não um array, por isso usamos o -> (equivalente ao ponto em JavaScript). Para que a função retorne um array, passamos um segundo parâmetro (booleano) indicando se o objeto deve ser transformado em um array (true) ou não.

$json = '{"user_id": 5, "action": "post", "text": "JSON no PHP"}';
$json = json_decode($json, true);
echo $json["action"]; // "post"
echo $json["text"]; // "JSON no PHP"

JSON Válido

Lembre-se sempre das aspas no JSON! Caso contrário, json_decode não irá funcionar. As aspas são necessárias em todas as strings, inclusive as chaves.

Também é necessário observar a codificação das strings para a função json_encode, pois a função só funciona com UTF-8.

Vou ficando por aqui. Até a próxima!

O Yoomp é uma “rede agregadora de blogs, blogueiros e simpatizantes”, surgida há pouco tempo. Nos últimos dias estive utilizando o serviço, pra ver como era, e decidi postar aqui minhas primeiras impressões quanto à essa iniciativa.

O serviço foi criado pelo Rodrigo Fante, do Fazedor de Site, e pelo Danilo Ardenghi, do Blog Pessoal. Logo que o serviço foi lançado, o Rodrigo comentou aqui no blog pedindo uma breve avaliação. Eu o fiz, dei algumas sugestões (como as URLs amigáveis, já implantadas), mas não pude ir muito a fundo. Hoje pretendo mostrar a opinião depois de um certo tempo de uso, as partes boas e as partes nem tão boas do serviço.

Prós

O Rodrigo e o Danilo foram muito criativos na criação do Yoomp. Vi muitas funcionalidades que não havia visto em serviço algum, além de outras que foram muito bem implementadas. Então, vamos à lista.

• Yoomp Burner: além de um simples distribuidor de feeds, o Yoomp Burner protege seus feeds contra os splogs, os plagiadores de conteúdo. Não tive a oportunidade de testar o serviço, mas parece estar funcionando bem e é uma idéia sensacional.
• Blog Rank: provavelmente inspirado no PageRank, o BlogRank calcula a popularidade dos blogs, a partir de certos critérios, resultando em uma nota de 0 a 10. O meu já é 2! Além de saber seu BlogRank, você também pode mostrá-lo em seu blog através do widget do BlogRank, lançado dia 22.
• Avaliação dos Blogs: essa eu achei demais. O ranking da página inicial (Destaques) é calculado de acordo com as avaliações dos usuários, nos critérios Layout, Conteúdo, Escrita, Persuasão, Confiabilidade, Publicidade, Domínio e Acessibilidade. Bola dentro, adorei o sistema. Aproveite e avalie o meu blog também!
• Interação: essa também é genial. O serviço também integra características de rede social. Você pode, além de escolher favoritos, como em qualquer serviço, definir outros blogueiros como seus amigos, enviar recados para outros blogueiros e comentar sobre outros blogs, deixando os blogueiros mais próximos e nos torna mais humanos dentro do serviço.
• Monetização: se você escolher por mostrar pelo menos um resumo de seus posts na página de seu blog, você pode indicar seu código do AdSense, que aparecerá junto com seus textos, ou seja, você exibe seus anúncios no Yoomp também! Eu já indiquei o meu…
• Flickr: também achei a idéia interessante, embora não a tenha utilizado. Além de seus posts em seu blog, você também pode importar suas fotos do Flickr. Se não bastasse, você também pode escolher quem poderá ver suas fotos: qualquer um, usuários do Yoomp, seus amigos ou somente você.

Contras

Embora tenha funcionalidades geniosas e muito bem-feitas, o Yoomp tem alguns problemas também. Vou citar os que encontrei, e alguns bastante incômodos, mas não que prejudicasse a qualidade do serviço.

• O login não é lá muito eficiente. Mesmo que eu escolha a opção para lembrar, tenho que me logar novamente toda vez que acesso o Yoomp. Não que seja um grande problema, mas é no mínimo incômodo ter que digitar nome e senha toda hora. Update: o login foi atualizado hoje, como o Rodrigo disse nos comentários. Agora sim ficou bom.
• Os títulos das páginas não são descritivos o suficiente, já que estão com o mesmo texto das URLs. Além disso, é necessário aplicar um pouco de usabilidade neles também.
• Falta um serviço de ping, para que os novos posts sejam vistos pelo sistema logo que postados. Tenho que esperar até o servidor resolver indexar meus posts sempre que atualizo o blog.
• O snapshot dos blogs também tem problemas, principalmente com o Blogspot, que não é mostrado corretamente. Além disso, troquei meu layout há mais de uma semana e o snapshot ainda continua azul. Mesmo que eu clique em “Atualizar a Imagem do Site”, a situação continua a mesma.
• A seção Últimos Artigos poderia incluir um link direto para o blog de onde veio, sem precisar abrir o perfil do mesmo.
• Não entendi mesmo como funcionam os Yoompies. Pra que servem, tudo bem, mas de acordo com o texto explicativo, basta a participação e o número sobe. Avaliei vários blogs, incluí dois, enviei alguns recados, adicionei favoritos e amigos e continuei nos 20. Fiquei sem entender.
• Algumas páginas, como o Sobre, estão simplesmente vazias. Outras, como a Ajuda, poderiam ser melhor exploradas. A ajuda poderia incluir tópicos como a configuração do AdSense, dos widgets, entre outras funcionalidades.

Conclusão

Como todo serviço em início de vida, o Yoomp tem seus defeitos, mas sinceramente tem um potencial enorme, pois é muito criativo e inovador. Parabenizo tanto o Rodrigo quanto o Danilo pela iniciativa e pelo bom trabalho.

O Diego Carrion, do MouseOver Studio, nomeu meu blog como de referência merecida. “Diz que até não é … Um mau blog”.

Agradeço muito a nomeação, Diego, e vou me esforçar para manter o blog digno de tal.

Com o poder a mim investido, também nomeio alguns blogs que considero dignos de referência:

• Bermonruf, do Bernardo Rufino (paradão, diga-se de passagem).
• Fazedor de Site, do Rodrigo Fante (esse também anda bem ocupado).
• Jader Rubini (volta pra blogosofera, rapaz, estamos sentido falta!).
• Tiago Floriano
• Rafael Marin (blog fora do ar por enquanto, esqueceu de pagar o domínio…)
• Blog Pessoal, do Danilo Ardenghi (conheci há pouco, muito legal)
• Pensamento Web, do Cau Guanabara

E agora, as regras para nomeação:

• Este prêmio deve ser atribuído aos blogs que considerem ser bons. Entende-se como bons os blogs que você costuma visitar regularmente e onde deixa comentários.
• Só e somente se recebeu o “Diz que até não é um mau blog”, deve escrever um post, indicando a pessoa que lhe deu o prêmio com um link, a tag do prêmio, as regras e a indicação de outros 7 blogs para receberem o prêmio.
• Deve exibir orgulhosamente a tag do premio no seu blog, de preferência com um link para o post em que fala dele.

Sei que alguns dos indicados andam ocupados, mas se não puderem postar tudo bem. E também tem alguns que não podem postar por motivos de força maior, mas logo estão de volta (né, Rafael?).

Volto com a terceira parte sobre JavaScript Orientado a Objetos. Então chega de papo e vamos logo ao que interessa.

Propriedades Estáticas

Propriedades e métodos estáticos são aqueles que podem ser acessados de qualquer lugar do script, sem a necessidade de instanciar a classe. Considera-se que o JavaScript não suporta esse conceito, já que não possui classes, mas pode-se também simular.

Funções não deixam de ser objetos, e objetos podem ter propriedades. Veja no exemplo:

function Person() {  }
        Person.staticMethod = function() { alert("Método Estático"); }
        Person.staticMethod(): // "Método Estático"
        var me = new Person();
        me.staticMethod(); // Retornará erro

Também muito simples, e bem útil em certas ocasiões. Podemos tomar como exemplo a Mootools, com o Class e Class.empty. Class é um construtor, e Class.empty é um método estático.

Herança

A herança é outro conceito que o JavaScript não implementa formalmente, necessitando das famosas gambiarras. Quando bem empregada, permite uma grande reutilização de código, criando classes derivadas a partir de uma superclasse (classe-mãe), herdando todas as propriedades.

Existem vários tipos específicos de pessoas, em vários sentidos. Brasileiros, portugueses, americanos, vendedores, médicos, desenvolvedores… Mesmo sendo mais específicos, todos eles têm características comuns de uma pessoa. Assim, o construtor Brazilian é derivado de Person.

Primeiro, vamos criar os construtores com suas propriedades.

function Person() {
                this.eyes = 2;
                this.speak = function(message) {
                        alert(message);
                }
        }
        function Brazilian() {
                this.birthCountry = "Brasil";
        }

Pessoas falam, e isso se aplica também aos brasileiros, mas nem todas as pessoas nasceram no Brasil. Assim, a superclasse (ou super-construtor) é Person, e somente nela definimos as propriedades comuns.

Para fazer a herança existem vários métodos, mas vou explicar agora somente o que considero o mais simples e usado. Basta criar uma instância do “super-construtor” no protótipo do construtor derivado, assim:

Brazilian.prototype = new Person;

Todo o construtor Person foi instanciado como parte de Brazilian. Agora podemos criar um objeto Brazilian e utilizar tanto as propriedades específicas (definidas no próprio construtor) quanto as do “super-construtor”.

var me = new Brazilian("Julio Greff");
        alert(me.birthCountry); // "Brasil"
        me.speak("Olá!"); // "Olá!"

Existem outros métodos para herança, mas como já disse ficarão para outra oportunidade. E a série sobre JavaScript Orientado a Objetos se encerra aqui! Qualquer correção ou sugestão será bem vinda, basta comentar! Até!

O JavaScript, apesar de ser usado há muito tempo quase que exclusivamente como linguagem de programação estruturada, também é uma linguagem de programação orientada a objetos poderosa. Nessa segunda parte da série, vamos nos aprofundar um pouco mais nessa técnica de programação.

A Propriedade prototype

No JavaScript, toda função construtora possui uma propriedade chamada Function.prototype. Essa propriedade nos permite adicionar e, em certos casos modificar, propriedades ou métodos de um construtor, após sua definição. Diferente de PHP, por exemplo, podemos adicionar propriedades durante a execução.

function Person() {}
        var me = new Person();
        alert(me.eyes); // undefined
        Person.prototype.eyes = 2;
        alert(me.eyes); // 2

Como se pode notar, na primeira tentativa não tínhamos a propriedade definida. Após isso, adicionada em tempo de execução, já temos a propriedade definida.

Também há certas exceções na utilidade do Function.prototype. A primeira delas é que essa propriedade não consegue sobrescrever qualquer coisa que já tenha sido definida no construtor. Não podemos definir uma propriedade no construtor e depois mudar seu valor através de Function.prototype.

function Person() { this.eyes = 2; }
        var me = new Person();
        alert(me.eyes); // 2
        Person.prototype.eyes = 1;
        alert(me.eyes); // 2, continuo tendo 2 olhos

Para resolver esse problema e continuar usando Function.prototype, podemos definir a propriedade fora do construtor usando a técnica, e sobrescrevê-la da mesma maneira.

function Person() {}
        Person.prototype.eyes = 2;
        var me = new Person();
        alert(me.eyes); // 2
        Person.prototype.eyes = 1;
        alert(me.eyes); // 1

Outro pequeno problema é quando definimos objetos ou arrays através dessa propriedade. Veja:

function Person() {}
        Person.prototype.uses = ["watch", "glasses"];
        var me = new Person();
        var you = new Person();
        me.uses.push("hat");
        alert(me.uses); // ["watch", "glasses", "hat"]
        alert(you.uses); // ["watch", "glasses", "hat"]

Com base no exemplo, pode-se ver que o array é compartilhado, assim como todos os seus itens. Moral da história: é preferível definir tudo no próprio construtor, ou então definir apenas métodos através de Function.prototype.

Encapsulamento

Formalmente, encapsulamento ainda não existe no JavaScript, mas podemos usar esse recurso disfarçado.

Tudo o que criamos dentro de nossos construtores está no escopo público, ou seja, pode ser acessado de dentro do construtor ou do restante do script. Uma maneira de simular variáveis privadas, que só podem ser acessadas de dentro do construtor e por seus métodos, é utilizando o escopo local. Lembra-se de quando falei sobre escopo de variáveis?

function Person() {
                this.public = "Variável Pública";
                var private = "Variável Privada";
                this.publicMethod = function() {
                        alert(this.public);
                        alert(private);
                }
                var privateMethod = function() {
                        alert(private);
                }
                this.callPrivate = function() {
                        alert(private);
                }
        }
        var me = new Person();
        alert(me.public); // "Variável Pública";
        alert(me.private); // undefined
        me.publicMethod();
        me.privateMethod(); // Retornará erro
        me.callPrivate();

O exemplo acima exemplifica bem de onde cada tipo de variável pode ser acessado. Já o uso de variáveis protegidas (protected) necessitam de mais gambiarras, mas isso fica pra outra vez.

Quanto ao uso de métodos privados só existe um pequeno problema: não é possível acessar propriedades ou métodos públicos diretamente. Para isso, é necessário modificar o escopo em que a função executada, através de Function.bind (função user-defined).

function Person() {
                this.public = "Variável Pública";
                var bindPublic = function() {
                        alert(this.public);
                }.bind(this);
                bindPublic();
        }
        var me = new Person();

Para testar, lembre-se de copiar a função Function.bind!

E a parte 2 se encerra aqui. Volto na parte 3 pra falar mais um pouco sobre programação orientada a objetos. Até lá!