marcuscavalcanti.net » PHP

Primeiras impressões sobre o Yii framework

Marcus Cavalcanti — Thu, 09 Apr 2009 05:33:49 +0000

Seguindo a febre de frameworks, que borbulham a todo momento, em todas as linguagens, de todos os gostos, surge então mais um! Na verdade, se fosse mais um eu nem me daria ao trabalho de estar escrevendo sobre algo que seria irrelevante, mas esse tal de Yii Framework ao que me parece veio para ficar, mesmo tendo pouquíssimo contato com ele, acho que dá para afirmar isso com alguma certeza.

O que é o Yii Framework?

O Yii é um framework que está sendo mantido e desenvolvido pelo criador do framework Prado, que é um famoso framework PHP baseado no conceito de event-driven programming, que a grosso modo seria um framework em que o seu fluxo é determinado por eventos.

Comparação com outros frameworks

Quando digo que o Yii não é mais um framework MVC, digo, pois ele parece ser muito mais maduro, estável, flexível e bem projetado que o restante, além do que ele é focado em performance, ou seja, foi desenvolvido pensando em aplicações Web “parrudas” e que precisam ser escaláveis.

Tenho alguma experiência com frameworks em PHP, já desenvolvi projetos que estão em produção usando o Kohana, Code Igniter e o Drupal (também é um framework!), além de já ter desenvolvido aplicações dummy usando o Zend Framework, Akelos e Cake, e por isso posso afirmar que o Yii é diferenciado. Por exemplo, o Code Igniter eu gosto bastante, mas ele é muito lightweight e não é PHP 5, o Zend Framework é sólido, mas na verdade é mais um conjunto de componentes do que um framework, o Kohana, que é um fork do CI, é interessante, mas ainda precisa comer muito feijão com arroz, o Cake sinceramente não me agrada e o Akelos é bem interessante, mas tem pouca comunidade e documentação. Nenhum desses, com exceção do ZF, me parece ser um projeto a longo prazo como o Yii.

O Yii é baseado em várias idéias do queridinho Ruby on Rails, e assim como o RoR possui geradores de código para gerar: controllers, models, scaffoldings apenas usando linha de comando. Ainda não me acostumei muito com essas idéias de geradores de código hehe, sou um pouco conservador em relação a isso, e muita “mágica” as vezes me preocupa, mas de qualquer maneira esses geradores trazem uma agilidade absurda e no final das contas se houver um equilíbrio entre agilidade e controle do que está sendo gerado, acho que vale muito a pena.

Principais atrativos

Além de ser bem projetado, com uma arquitetura bem definida, uso de design patterns e facilidade de ser extendido, o que me atraiu no Yii foi algumas features mais avançadas e que outros frameworks não possuem nativamente, como: sistema de cache em camadas (usando memcached e apc), suporte a web services (WS-*), internacionalização de verdade, sistema de autenticação/permissão usando RBAC, integração nativa com jQuery, acesso a dados usando DAO, ORM + ActiveRecord (com lazy loading, inclusive), etc.

Outro ponto que me convenceu foi a documentação, que é bem completa, clara e objetiva, possuindo manuais, tutorias, screencasts, fóruns e API.

O framework também é todo modularizado, permitindo que componentes sejam desenvolvidos para serem totalmente desacoplados da aplicação.

Aprendizado

A curva de aprendizado do Yii é muito mais alta que a do CI ou do Kohana, por exemplo, apesar de no site do framework dizer o contrário. Mesmo com o framework tendo uma documentação extensa, skeletons para construção da aplicação e geradores de código, entender como funciona o framework e sua arquitetura não é tão simples como os outros frameworks citados anteriormente, mas isso não quer dizer que o código seja ilegível, ou difícil de entender, muito pelo contrário, como a tendência dos frameworks hoje em dia é descomplicar e humanizar, acredito que o Yii tenho seguido essa linha, apenas acho que para um desenvolvedor inexperiente será mais árduo aprender o Yii do que o CI.

O que pode melhorar

Como é um framework recente, mesmo tendo muitas funcionalidades mais avançadas, algumas outras ainda senti falta. Por exemplo, o framework ainda não tem um suporte para testes, seja BDD ou TDD e isso hoje em dia é inaceitável. O RoR, por exemplo, é um framework que tem a parte de testes muito forte dentro do framework e toda sua comunidade também é assim, em PHP isso é um pouco diferente, portanto seria interessante que o Yii começasse a fornecer mecanismos para realização de testes, porém nada impede que se integre o SimpleTest ou PHPUnit com o Yii.

Outra coisa que senti falta também foi suporte para serviços REST, o framework apesar de oferecer suporte a Webservices, só oferece suporte para Webservices no padrão SOAP/WSDL, REST seria muito interessante, até mesmo porque um dos pilares do framework é performance.

Conclusão

Estou animado com esse novo framework, apesar de ter pouco contato, senti seriedade no trabalho, mas só posso afirmar tudo que eu disse depois que eu tiver uma experiência real com o framework.

No momento estou participando de um job novo, em que estou definindo o que será usado como framework web, na verdade, não gosto e não costumo usar tecnologias que não tenho experiência em projetos que estou a frente, mas como esse projeto não é crítico e nem complexo, possa ser que eu use o Yii para ter uma opinião formada sobre o mesmo, e caso eu opte realmente por essa opção, irei comunicando o progresso.

Convertendo objeto em array com PHP

Marcus Cavalcanti — Thu, 22 Jan 2009 02:10:44 +0000

Mais do que nunca têm-se trabalhado com objetos em PHP, algumas vezes de forma certa, outras vezes de forma errada, mas isso não vem ao caso, a questão é que com a explosão dos frameworks MVC e o uso da camada modelo como representante dos dados de uma aplicação, tornou-se muito comum enviar objetos ao invés de arrays para nossa camada de visualização. Até aí nenhum problema, o problema surge quando precisamos trabalhar em cima desses objetos e realizar ordenações, filtrar elementos repetidos, extrair elementos específicos, dentre outras necessidades. Apesar da SPL ter chegado, o PHP ainda não tem um framework como o Collections Framework do Java para realizar esse trabalho, então muitas vezes torna-se árduo e nem um pouco prazeroso fazer certas operações. Entretanto o PHP possui boas funções para manipular arrays e em muitos casos torna-se vantajoso transformar objetos em arrays, pois assim é possível fazer o uso dessas funções.

Pensando nas situações descritas acima e também baseado em necessidades reais do meu dia-a-dia, criei uma função muito simples que converte um objeto em array.

Imagine um objeto com a seguinte estrutura:

TableEditor Object
(
    [db] => Resource id #82
    [pk] => id_idioma_afiliado
    [table] => idioma_afiliado
    [fields] => Array
        (
            [id_idioma_afiliado] => Array
                (
                    [display] => id_idioma_afiliado
                    [input] => text
                    [values] =>
                    [default] =>
                )
 
            [afiliado_id] => Array
                (
                    [display] => afiliado_id
                    [input] => text
                    [values] =>
                    [default] =>
                )
 
            [idioma_id] => Array
                (
                    [display] => idioma_id
                    [input] => text
                    [values] =>
                    [default] =>
                )
 
            [tx_descricao_afiliado] => Array
                (
                    [display] => tx_descricao_afiliado
                    [input] => textarea
                    [values] =>
                    [default] =>
                )
 
            [tx_transfer] => Array
                (
                    [display] => tx_transfer
                    [input] => textarea
                    [values] =>
                    [default] =>
                )
 
            [tx_informacao_afiliado] => Array
                (
                    [display] => tx_informacao_afiliado
                    [input] => textarea
                    [values] =>
                    [default] =>
                )
 
            [tx_apresentacao_afiliado] => Array
                (
                    [display] => tx_apresentacao_afiliado
                    [input] => textarea
                    [values] =>
                    [default] =>
                )
 
        )
)

Se quiséssemos ordená-lo, por exemplo, apesar de não ser difícil, demandaria tempo.
Mas e se ao invés de um objeto, tivéssemos um array? Algo como:

Array
(
    [db] => Resource id #82
    [pk] => id_idioma_afiliado
    [table] => idioma_afiliado
    [fields] => Array
        (
            [id_idioma_afiliado] => Array
                (
                    [display] => id_idioma_afiliado
                    [input] => text
                    [values] =>
                    [default] =>
                )
 
            [afiliado_id] => Array
                (
                    [display] => afiliado_id
                    [input] => text
                    [values] =>
                    [default] =>
                )
 
            [idioma_id] => Array
                (
                    [display] => idioma_id
                    [input] => text
                    [values] =>
                    [default] =>
                )
 
            [tx_descricao_afiliado] => Array
                (
                    [display] => tx_descricao_afiliado
                    [input] => textarea
                    [values] =>
                    [default] =>
                )
 
            [tx_transfer] => Array
                (
                    [display] => tx_transfer
                    [input] => textarea
                    [values] =>
                    [default] =>
                )
 
            [tx_informacao_afiliado] => Array
                (
                    [display] => tx_informacao_afiliado
                    [input] => textarea
                    [values] =>
                    [default] =>
                )
 
            [tx_apresentacao_afiliado] => Array
                (
                    [display] => tx_apresentacao_afiliado
                    [input] => textarea
                    [values] =>
                    [default] =>
                )
 
        )
)

Ficaria muito mais fácil, não?!

Para obter esse resultado, basta jogar a funçãozinha abaixo como um helper no seu projeto ou criar um método estático em sua classe utilitária. Segue:

```
function objectToArray ($object) {
```
```
	if ( count($object) > 1 ) {
```
```
		$arr = array();
```

		for ( $i = 0; $i < count($object); $i++ ) {

			$arr[] = get_object_vars($object[$i]);

```
		}
```
```
 
```
```
    	        return $arr;
```
```
 
```
```
	} else {
```
```
		return get_object_vars($object);
```
```
	}
```
```
}
```

Para utilizar, é simples:

```
// $object é o seu objeto
```
```
print_r(objectToArray($object));
```

A boa notícia é que esta função preserva toda hierarquia dos seus objetos criando dimensões dentro desse array, no caso uma matriz. O exemplo que eu usei foi bem simples, apenas para poder ilustrar o uso da função, mas caso tivéssemos um objeto mais “complexo” toda sua estrutura seria mantida sem problemas.

Uma dica bem simples, mas espero que seja de grande utilidade! :)