Não deixem de ler a reportagem que é muito boa e que sem dúvida ajuda a levar o CakePHP cada vez mais aos sites e sistemas web.

Parabéns a revista e a todos que participaram!

Saiu hoje a nova versão do CakePHP 1.2, através da release candidate (RC) 1, usando a revisão 7119.

As maiores alterações são alterações no modo de utilizar as condições e colocar vários métodos em desuso.

Para quem quiser mais informações sobre o lançamento, consulte o link oficial (no Bakery). Quem quiser fazer o download agora, clique aqui.

Abraços e bom uso para todos.

O pessoal do CakePHP, mais especificamente o Mariano Iglesias, anunciou dia 13/05/2008 no Bakery que em breve estariam disponibilizando uma nova release, mas dessa vez para o CakePHP 1.2!

No anúncio, pede a todos “padeiros” (nós) para relatarmos bugs para que possam ser corrigidos antes de finalizar a versão. Não estão sendo aceitos pedido de melhoramento (enhancement) para a versão 1.2, mas para a 2.0 será bem vindo. Quem tiver novas idéias ou encontrou algum bug, relate através do Trac.

E neste clima de novidades, foi publicada uma nova versão da API do CakePHP 1.2, cuja versão é 1.2.0.7008. Quem quiser acessar, basta entrar no link http://api.cakephp.org/.

Abraços e vamos ficar na espera desta release tão aguardada por muitos!

Olhando alguns sites de otimização, benchmark, entre outros, vi que há algumas formas de otimizarmos os códigos sem grandes alterações, mas que podem melhorar a performance. São elas:

1) Aspas com variáveis

1.1) Aspas duplas VS aspas simples

Utilizar uma string com aspas simples é ligeiramente mais rápido que utilizar aspas duplas pelo fato da necessidade de interpretar varáveis (com aspas simples ele interpreta variáveis). Exemplo:

1
2

echo 'texto qualquer'; // Mais rápido
echo "texto qualquer"; // Mais lento

1.2) Variável em aspas dupla ou concatenando

Concatenar uma variável a uma string é muito mais rápido que colocar a variável dentro de uma string com aspas duplas.

1
2

echo 'texto qualquer ' . $variavel . ' outro texto'; // Quase duas vezes mais rápido
echo "texto qualquer $variavel outro texto"; // Bem mais lento

2) echo VS print

Utilizar a função echo é mais rápida que a função print, pois não retorna nenhum valor. A função print informa se houve mensagem de erro. O uso de print é recomendado só em casos que há necessidade de retorno (o que são poucos na prática). Além disso, é recomendável a utilização vários parâmetros no echo ao invés de concatenar strings. É opcional o uso de parâmetros nestes comandos, sendo o ideal não utilizar. Exemplo:

1
2
3

echo 'texto qualquer ' . $variavel . ' outro texto';
print 'texto qualquer ' . $variavel . ' outro texto'; // Mais lento que caso anterior
echo 'texto qualquer ', $variavel, ' outro texto'; // Note as vírgulas. Este caso é mais rápido que os anteriores

3) Variáveis

3.1) Nomes

Definir variáveis com nomes menores é consideravelmente mais rápido que nome maiores. Exemplo:

1
2

$a = 'texto';
$asdhaisuhniduahsduiash = 'a'; // Mais lento que anteiror, consideravelmente

3.2) Atribuições

Em atribuições, várias atribuições são mais rápidas que em atribuições unificadas. Exemplo:

1
2

$a=$b=0; // Mais lento
$a=0; $b=0; // Mais rápido

Usar os operadores +=, -=, /=, *= e .= também aumentam a performance. Exemplo:

1
2
3
4
5
6
7

$var = 'abc';
 
// Mais lento
$var = $var . 'def';
 
// Mais rápido
$var .= 'def';

3.3) [Pré/Pós]-incremento

Preferir o uso de pré-incremento (++$i) ao invés de pós-incremento ($i++), pois aquelas consumem um opcode a menos, visto que o segundo caso o PHP cria uma variável temporária para atribuir o valor e no primeiro caso não. PS: Isto vale apenas para PHP! Nas outras linguagens isto não se aplica.

4) Estruturas condicionais

4.1) if VS switch

Estruturas com if e vários elseif são mais rápidas que a estrutura switch. Exemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Mais rápido
if ($a == 1) {
  echo 1;
} elseif ($a == 2) {
  echo 2;
} else {
  echo 3;
}
 
// Mais lento
switch ($a) {
  case 1:
    echo 1;
    break;
  case 2:
    echo 2;
    break;
  default:
    echo 3;
}

4.2) Operador ternário VS if

Operadores ternários são significativamente mais lentos que if’s. Exemplo:

1
2
3
4
5
6
7
8
9

// Mais lento
echo $a == 1 ? 1 : 2;
 
// Mais rápido
if ($a == 1) {
  echo 1;
} else {
  echo 2;
}

4.3) Operadores de igualdade

Operadores de igualdade com comparação de tipos (===) são consideravelmente mais rápidos que apenas operadores de igualdade (==). Exemplo:

1
2

if ($a == 'a') { // Mais lento
if ($a === 'a') { // Mais rápido

5) Arrays

5.1) Definição

Definir um array pelos índices é consideravelmente mais rápido que usar o método array(…). Exemplo:

1
2

$a = array('a', 'b'); // Mais lento
$a[0] = 'a'; $a[1] = 'b'; // Mais rápido

5.2) Leitura

Verificar a existência de um elemento no array é mais rápido que procurá-lo. Exemplo:

1
2

array_key_exists('texto', $arr); // Mais lento
isset($arr['texto']); // Mais rápido

PS: Se o valor do campo pode ser null, isset irá retornar false neste caso. Portanto, tome cuidado com isto.

6) Arquivos

Usar a função file_get_contents() é ligeiramente mais rápida que utilizar a função file(), porém é mais lenta que utilizar fopen() com fread(). Exemplo:

1
2
3
4
5
6
7
8
9
10

// Mais lento
$arquivo = file('arquivo.txt'); // Retorna array
 
// Pouco mais rápido que anterior
$arquivo = file_get_contents('arquivo.txt'); // Retorna string
 
// Mais rápido, significativamente
$f = fopen('arquivo.txt', 'r');
$arquivo = fread($f, filesize('arquivo.txt'));
fclose($f);

7) Buscas e validações

7.1) Substring

Ao buscar substrings, é preferível usar, na ordem, strpos(), depois preg_match() e por último ereg(). A strpos, quando é possível de ser utilizada, tem uma eficiência muito superior as demais.

7.2) Números

Caso necessite verificar se um texto ou variável contém apenas números, é preferivel utilizar a função ctype_digit($var) ao invés de preg_match(‘/[0-9]*/’, $var).

8 ) Outras otimizações

8.1) Funções de controle de saída

Uso de Usar o método ob_start() reduz de 5 a 15% o tempo de execução.

8.2) Evitando repetição de funções

Definir uma variável com um valor que vai ser usado diversas vezes aumenta a performance consideravalmente. Exemplo:

1
2

for ($i=0, $max=count($arr); $i<$max; $i++) { // Mais rápido
for ($i=0; $i<count($arr); $i++) { // Mais lento

8.3) Processamento não necessário

Blocos de textos fixos é preferível que seja impresso fora do PHP, por exemplo:

1
2

<?php echo $var; ?>
Texto adicional grande

É preferível do que:

1

<?php echo $var . 'Texto adicional grande'; ?>

8.4) Evitar o uso de funções aliases e automágicas

Funções aliases são as funções que significam a mesma coisa que outras. Por exemplo, sizeof é sinônimo (alias) de count. Veja a lista completa de funções aliases aqui.

Funções automágicas são aquelas definidas pelo PHP: __get, __set, __autoload, __call, __sleep, …

8.5) Evitar uso de funções abrangentes

Preferir a função empty() ao invés de count(), assim como isset($var{X}) ao invés de strlen($var) < X.

8.6) Declare os métodos estáticos

Definir os métodos estáticos com a palavra static deixa seu código até 4 vezes mais rápido que o não declarado como estático. Exemplo:

1
2
3
4
5
6
7

class XXX {
  public function a() { return 1; }
  public static fuction b() { return 1; }
}
 
XXX::a(); // Mais lento
XXX::b(); // Até 4 vezes mais rápido

8.7) Evitar o operador @

Ao invés de usar o operador @, desativar a exibição de erros. Exemplo:

1
2
3
4
5
6
7

// Mais lento
@acao();
 
// Mais rápido
$old = ini_set('error_reporting', 0);
acao();
ini_set('error_reporting', $old);

9) Extra-código

Se você tem acesso ao servidor web, é recomendavel a utilização de otimizadores e/ou cachers, como o Zend Optimizer, APC, eAccelerator, memcache, etc.

Outra alternativa que pode ser usada em conjunto, é usar o callback ‘ob_gzhandler‘ na função ob_start() OU ativar a configuração zlib.output_compression no php.ini. Isso faz com que depois de gerado o código HTML, ele seja compactado e enviado para o cliente, reduzindo a quantidade de tráfego na rede.

Fontes de referência:
https://trac.cakephp.org/ticket/2764
http://phplens.com/lens/php-book/optimizing-debugging-php.php
http://benchmark.nophia.de/benchmarks.html
http://www.estvideo.com/dew/pages/phpbench/
http://ilia.ws/archives/12-PHP-Optimization-Tricks.html
http://www.vulgarisation-informatique.com/optimiser-php.php
http://www.moskalyuk.com/blog/php-optimization-tips/1272
http://www.ilia.ws/files/zend_performance.pdf
http://www.faqts.com/knowledge_base/view.phtml/aid/1/fid/40

Todo dia, no horário do almoço, na empresa, eu dou uma olhada no blog do Daniel Hofstetter, também conhecido como CakeBaker, para ver sobre novos posts. O site dele tem atualizações seguidas (praticamente uma por dia) e trás novidades sobre o que está acontecendo com os fontes, novos recursos, pontos de vista, novas idéias, referência a outros sites, etc. Em resumo, esse site eu considero uma grande fonte de referência para o dia-a-dia. O site é em inglês, realmente, mas não é um inglês pesado, não é difícil de entender e qualquer coisa é só colocar no Google Tradutor que facilmente você entende o que ele quis dizer nos seus posts, além de contar, na grande maioria dos posts, com exemplo dos novos recursos.

Outra grande fonte de informação e troca de conhecimento é no Google Groups PT. Lá você tira dúvidas, vê e aprende com os problemas dos outros, ajuda quando sabe, etc. Quem tiver alguma dúvida sobre CakePHP, pode postar lá que o pessoal vai ajudar, se possível.

Também baixo o código fonte do repositório SVN todo dia com o TortoiseSVN. Com ele eu consigo ver o que foi adicionado/retirado/otimizado/corrigido/etc. O grupo de desenvolvimento do CakePHP atualiza quase todo dia alguma coisa. Então, é melhor ver uma vez por dia do que deixar pra ver a cada nova release, pois nas novas releases entra MUITA coisa nova.

No mais, alguns sites do Google de vez enquanto para me atualizar em outras fontes, as vezes entro no site Debuggable para ver, mas não sou muito fã dele.

Um site que reune vários feeds internacionais é o CakePHP Super Feed. Ele junta os principais feeds do mundo e coloca ali.

Quem tiver outros canais, favor me informar, ficarei grato.

Tenho esse host e a única utilidade está sendo para este blog. Porém, para não deixá-lo só para isso, estou abrindo para o pessoal que deseja cadastrar projetos em CakePHP.

Para quem quiser, basta responder este tópico ou mandar um email para jrbasso@cakephp-brasil.org que crio o subdominio e passo a senha. A parte do cake será compartilhada entre todos os projetos e será sempre usada a versão mais atual do SVN, atualizada a cada semana.

Não tenho muito a oferecer quanto a controle de versão, mas serve para publicarem o trabalho realizado. Se quiserem um servidor de SVN gratuito, recomendo o http://www.assembla.com/

PS: O nome do projeto não pode ser blog e www.

 Estamos começando hoje as atividades do CakePHP Brasil. O objetivo do site é criar um blog público para o pessoal expor suas experiências, idéias, dicas, macetes, exemplos de código, casos de uso, etc. Tudo isso relacionado ao CakePHP.

Particularmente, costumo ler muitos blogs estrangeiros, até mesmo dos desenvolvedores do CakePHP. Há muito conteúdo interessante para nós desenvolvedores, porém nem todos tem o fácil acesso ou grande conhecimento com o inglês. Sendo assim, buscarei traduzir alguns posts para a comunidade.

Além disso, todos os usuários registrados estão livres para postar o que desejarem. Porém, por se tratar de um blog público, tentaremos tomar o maior cuidado possível para não virar um abuso de propagandas, spam ou mensagens que insultem ou xinguem alguém. Para isso, os posts serão analisados antes de serem publicados.

Como estamos começando agora, quem tiver dicas de plugins, temas, recursos, ou qualquer outra coisa que venha a beneficiar a comunidade, sinta-se a vontade em nos informar que buscaremos atender.