Os posts mais lidos aqui sobre PHP em 2013

Artigos mais lidos sobre PHP

Salve, galera! Fome de PHP?

O ano de 2013 foi muito interessante. Pude aprender muita coisa e, consequentemente, passar muito do que aprendi adiante. Pensando nisso, resolvi fazer essa compilação com os posts mais lidos no ano passado para que vocês possam ficar por dentro do que o pessoal tem lido por aqui!

Vamos aos posts

1. Entendendo as Expressões Regulares (19.512 visitas)

De forma impressionantes, esse artigo escrito há 7 anos continua sendo o meu artigo mais lido. Anualmente ele tem uma média de quase 20 mil visitas. Se você procurar no Google expressões regulares vai ver o link na primeira página. Muito obrigado por confiarem em mim para estudar um tema que muitas vezes é complexo.

2. Iniciando com Zend Framework 2: Skeleton e ZfcUser (6.489 visitas)

O Zend Framework 2 tem sofrido com a falta de artigos escritos em português. Provavelmente por isso que tanta gente tenha procurado esse tutorial.

3. 10 ferramentas para o desenvolvimento PHP moderno (5.316 visitas)

Aqui vemos uma compilação de ferramentas que ajudam a aumentar a produtividade do desenvolvedor PHP. O artigo está um pouco desatualizado, mas pretendo mexer nele em breve.

4. Gerando números de identificação (ID) únicos com PHP (4.491 visitas)

Um artigo que surgiu de uma dúvida que eu tinha. Aqui eu trabalho a função uniqid( ) para gerar hashs únicos e aleatórios.

5. Ping – Pingando IP, Máquinas, Endereços e URLs (4.077 visitas)Para determinar se uma máquina está ligada ou se um endereço é acessível, nada melhor do que um ping. Nesse artigo eu explico algumas maneiras de pingar IPs, máquinas e URLs.

6. 7 coisas simples em PHP que alguns ainda complicam (3.970 visitas)

Este artigo rendeu muitas visitas porque possui dicas que auxiliam na produtividade do programador PHP. Várias técnicas e abordagens para facilitar tarefas cotidianas.

7. Forçar o dowload de um arquivo (3.229 visitas)Artigo também bastante antigo ensinando a enviar um arquivo direto para download sem permitir que o navegador tente executar uma pré-visualização.

8. Descobrindo a idade através da data de nascimento (3.126 visitas)

Script simples para retornar a idade de alguém através de sua data de nascimento. Nos comentários existem várias opções ao script original.

9. Detectando o charset de uma string – UTF-8, ISO-8859-1, etc. (2.923 visitas)

Devido aos diversos erros com acentuação, as vezes precisamos descobrir em qual codificação determinada string está. Este artigo possui um pequeno snippet para realizar essa identificação.

10. PHP e Unicode – O caminho das pedras (2.635 visitas)

Artigo escrito pelo meu amigo Gustavo Ciello sobre como lidar com PHP e Unicode sem traumas.

 

E aí, gostaram da compilação? Já tinham lido todos esses artigos?

Comentem e mandem suas sugestões. Não esqueçam que sugestões para novos artigos são sempre bem-vindas!

Um abraço a todos e fiquem com Deus!
Rafael Jaques

Utilizando Sessões no Zend Framework 2 – Parte 1

Zend Framework 2

Todos nós sabemos que o PHP implementa uma abordagem stateless para aplicações. O processo do PHP inicia, as variáveis são alocadas, informações são geradas e armazenadas e então, quando a requisição é finalizada, todo o estado é perdido. Todas as informações geradas durante a requisição são perdidas quando ela acaba.

Para driblar esse problema, foi introduzido no PHP o conceito de sessões que nos permite armazenar informações entre uma requisição e outra. No entanto, como na maioria das vezes, conforme as aplicações se tornam mais complexas, a habilidade de interagir com as sessões em uma maneira que supre a necessidade de aplicação cresceu também.

Felizmente, no Zend Framework 2, existe um conjunto de classes que auxilia na redução da complexidade do gerenciamento de informações na sessão, ou seja, podemos interagir, configurar ou armazenar sem distanciar muito o programador da implementação da aplicação ou então adicionar muita complexidade ao processo.

No artigo de hoje, o primeiro de dois, vamos ver como colocar pra funcionar uma configuração básica, assim você pode ter, hoje mesmo, sessões funcionando na sua aplicação ZF2.

Para o tutorial de hoje, vou assumir que você já possui uma versão implementada de projeto básico utilizando o ZF2Skeleton (esse tutorial ensina também como utilizar o ZfcUser, mas para nós, hoje, é irrelevante).

Nós vamos estender o módulo padrão Application para dar suporte a sessões ao resto da aplicação. Para integrar esse suporte, vamos precisar fazer três coisas:

  1. Atualizar o Module.php
  2. Criar um novo Container e armazenar alguns dados
  3. Recuperar os dados

Então vamos lá!

1. Atualizar o Module.php

Primeiramente, no module/Application/Module.php, nós precisamos fazer três coisas:

  • Adicionar duas declarações use
  • Criar uma nova função para inicializar a sessão
  • Chamar a função no onBootstrap

Então, adicione as seguintes declarações:

use Zend\Session\Config\SessionConfig;
use Zend\Session\Container;

E depois vamos criar a seguinte função:

public function initSession($config)
{
    $sessionConfig = new SessionConfig();
    $sessionConfig->setOptions($config);
    $sessionManager = new SessionManager($sessionConfig);
    $sessionManager->start();
    Container::setDefaultManager($sessionManager);
}

initSession cria uma nova variável SessionConfig, que permite fornece as configurações para o gerenciador de sessão. Nós configuramos algumas opções e passamos como o único argumento ao instanciar um novo SessionManager. Finalmente chamamos o método estático setDefaultManager na classe Container, pasando a nova variável $sessionManager.

Vamos dar uma olhada mais de perto.

  • Container: Fornece a core interface para gerenciar os dados da sessão.
  • SessionConfig: Manipula configurações de várias opções da sessão.
  • SessionManager: Manipula o gerenciamento da sessão, ou seja, tarefas como inicializar, verificar a existência, regenerar id, time to live, destroy e até validação.

No onBootstrap, adicionamos o seguinte:

$this->initSession(array(
    'remember_me_seconds' => 180,
    'use_cookies' => true,
    'cookie_httponly' => true,
));

Assim podemos garantir que a sessão estará sempre configurada e pronta para uso. Com esse código no seu devido lugar, agora temos suporte a sessão disponível, utilizando cookies para guardar as informações da sessão, persistindo ela, depois que o browser é fechado, por 3 minutos.

2. Criar um novo Container e armazenar alguns dados

$sessionTimer = new Container('timer');
$sessionTimer->endTime = (float) array_sum(explode(' ', microtime()));

Maravilha, agora que já cuidamos da configuração, precisamos começar a gravar e usar informações na sessão. Então criamos um novo container de sessão chamado timer e nele colocamos o valor atual de microtime() em uma variable de container chamada endTime.

Containers são utilizados para darmos namespaces para as informações de sessão. Um namespace padrão está disponível, mas eu acho que, exceto em aplicações simples, essa não é a melhor abordagem. Então, conseguindo separar a informação, conseguimos tornar mais fácil o desenvolvimento semântico e programático da nossa aplicação.

3. Recuperar os dados

Bom, agora que a informação está gravada, vamos recuperá-la e utilizá-la. Então, em algum ponto da nossa aplicação, vou assumir que existe um controller action.

$sessionTimer = new Container('timer');
if ($sessionTimer && $sessionTimer->executionTime) {
    return sprintf(
	"Página renderizada em %s segundos.",
	$sessionTimer->executionTime
    );
}

Aqui, como quando configuramos as informações anteriores, nós utilizamos um objeto Container. Enquanto no primeiro exemplo o container não existia e seria criado, agora que ele já existe nós temos acesso a ele.

Agora, como a maioria das variáveis, nós podemos interagir com ela, verificando se a propriedade que estamos procurando, executionTime, está disponível. Se estiver, nós utilizamos um sprintf para mostrar as informações de maneira formatada.

Juntando tudo

E aqui estamos nós! Com apenas um pouquinho de trabalho a mais, já temos acesso a sessões do jeito do Zend Framework 2, com um pequeno toque de sofisticação – quer seja com as informações sendo armazenadas no backend, com a implementação de namespaces de sessão ou q quantidade de opções de configuração disponíveis. É uma biblioteca muito bacana que faz com que o trabalho com sessões fique muito mais simples.

No próximo tutorial vamos aprender como proteger as sessões contra session hijacking a partir dos validadores disponíveis e como utilizar armazenamento em diferentes backends como servidores de cache ou bancos de dados.

Espero que tenham gostado!

Um abraço a todos e fiquem com Deus.
Rafael Jaques

Adaptado do original de Matthew Setter: http://www.masterzendframework.com/sessions/using-sessions-in-zend-framework-2-part-1

Slides da palestra PHP na Tela Escura

PHP na Tela Escura

Apresentei ontem no 15º Fórum Internacional de Software Livre a minha palestra intitulada PHP na Tela Escura: Aplicações Poderosas em Linha de Comando.



Link para os slides: http://pt.slideshare.net/rafajaques/php-na-tela-escura-aplicaes-poderosas-em-linha-de-comando

Abraços a todos e fiquem com Deus!

PHPit e PHPRS no FISL 15!

FISL

Salve, galera!

Estou aqui para divulgar o 15º Fórum Internacional de Software Livre, aka FISL, que ocorrerá do dia 7 ao dia 10 de Maio de 2014 em Porto Alegre – RS.

Nessa edição estarei comandando duas atividades:

  • No dia 9, sexta-feira, apresentarei a palestra PHP na Tela Escura: Aplicações Poderosas em Linha de Comando na sala 41B às 9h (da manhã, hein!).
  • No dia 10, sábado, juntamente com o Galvão, vou coordenar o 1º Encontro Comunitário do PHPRS, também às 9 horas da matina, porém na sala 41C.

Além disso, você poderá me encontrar no stand do PHPRS que estará na área de comunidades do FISL.

Aproveite para vir apresentar suas lightning talks, conhecer a galera do PHP e trocar ideias. Espero todos vocês!

Você pode acessar o site do FISL 15 ou a programação do evento.

Um abraço a todos e fiquem com Deus.

Novidade no PHP 5.6: Funções Variádicas e Desempacotamento de Argumentos

Thumbnail_w640_h190_m_default__uploads_Modules_Newsletters_banner

Enquanto o PHP 6 não sai, vão surgindo novidades na versão anterior.

Hoje quero apresentar pra vocês duas coisas sensacionais: funções variádicas e desempacotamento de argumentos!

O que raios são funções variádicas?

São funções que permitem a passagem de um número indeterminado de argumentos. É comum no PHP a utilização de funções cujos os primeiros parâmetros sejam fixos e os subsequentes variam.

Um exemplo de função variádica no PHP é array_merge(). Podemos ver o protótipo dela na página do PHP:

array array_merge ( array $array1 [, array $array2 [, array $... ]] )

Pelo protótipo podemos ver que é possível fundir um número infinito de arrays utilizando essa função.

Antigamente era possível criar funções assim no PHP através da utilização da função func_get_args(). Essa função retorna todos os argumentos passados para uma função, independentemente se foram declarados ou não. No caso das funções variádicas é mais fácil de realizar essa declaração.

Utilizando funções variádicas

Vamos construir uma função para receber valores indeterminados e separá-los por um caractere específico:

function juntar($caractere, ...$strings) {
    // Como $strings será um array com todos os valores passados
    // podemos utilizar o implode pra juntar tudo
    return implode($caractere, $strings);
}

Você pode passar dois parâmetros, no mínimo, para essa função. O primeiro parâmetro é estático e todos os subsequentes serão colocados em um array.

Podemos também criar uma função para imprimir vários valores com um \n no final:

function quebrar_linha(...$linhas) {
    foreach ($linhas as $linha) {
        echo $linha . '\n';
    }
}

Desempacotamento de argumentos

Outra coisa bacana no PHP 5.6 é a possibilidade de utilizar o mesmo operador para avisar ao PHP que deve desempacotar o array que está sendo passado.

Para esse exemplo podemos utilizar a função mail(). Para ela são suficientes três parâmetros e vamos utilizá-los da seguinte maneira:

$email[] = 'fulano@site.com';
$email[] = 'Assunto';
$email[] = 'Mensagem';

mail(...$email);

O operador variádico (alguns chamam de “splat operator”) indica ao PHP que deve desempacotar os valores do array e separar entre os argumentos.

Considerações

PHP é uma linguagem em constante evolução. Tão logo esta versão nova seja lançada e possamos colocá-la em produção, vou postar novos tutoriais demonstrando a utilização de novas funcionalidades.

Espero que tenham gostado do post de hoje!

Um abraço a todos e fiquem com Deus!

Trabalhando com processos de longa duração no PHP

Gostaria de apresentar dois exemplos reais que requerem processos PHP que rodem por longos períodos de tempo (ou até indefinidamente):

  1. Processamento de dados: Todas as noites o seu servidor precisa vasculhar milhões de dados para atualizar rankings, tabelas e estatísticas.
  2. Dados da API de Streaming do Twitter: Requer uma conexão constante com a API do Twitter para receber as mensagens conforme elas são postadas.

As ferramentas

Uma das melhores ferramentas que temos é o PHP CLI (Command Line Interface). Essa ferramenta permite que possamos rodar o PHP diretamente da linha de comando (mais conhecido como Terminal) sem possuir um tempo limite. Todas as dores com o set_time_limit() e as brigas com o php.ini vão embora!

Se você vai trabalhar com linha de comando, provavelmente você vai precisar saber um pouquinho de bash scripting. Deixo aqui uma dica: http://aurelio.net/shell/ - uma fonte ilimitada de conhecimento sobre shell/bash.

Outra coisa bacana é o cron (crontab / cron job)

SSH vs Cron Jobs

Você precisa saber rodar algo em uma sessão SSH é diferente do que configurar um cronjob pra fazer algo pra você. Uma sessão SSH pode ser um bom lugar para testar scripts e rodá-los uma vez apenas, enquanto um cronjob é a maneira correta de configurar um script que você deseja que rode regularmente.

Se eu escrever isso na minha sessão SSH

php meuScript.php

irei executar o meuScript.php. Contudo, meu terminal ficará bloqueado até que a execução seja encerrada.

Você pode passar por isso segurando Ctrl + Z (pausa a execução) e utilizando o comando bg (envia o processo para o background).

Para processos longos, pode ser bacana, mas se você perder a sessão SSH, a execução do script será encerrada.

Você pode driblar esse problema utilizando o nohup (no hangup – “não deixar cair”).

nohup php meuScript.php

O comando nohup permite que a execução continue mesmo que você perca a sessão. Isso quer dizer que se você utilizar esse comando, enviar o processo para o background e perder a conexão com o SSH, seu comando continuará rodando.

Mas ainda acho que a melhor maneira de executar um processo diretamente no background é utilizando um & (ampersand – “e comercial”). Você adiciona no final do comando e ele vai diretamente para o background, sem precisar de nenhum atalho.

nohup php meuScript.php &

É claro que tudo isso apenas importa se você estiver rodando comandos manualmente. Se você scripts com uma certa regularidade e usando os cronjobs, então você não precisa se preocupar com esses problemas. Uma vez que é o próprio servidor quem os executa, a sessão SSH não interessa pra nada.

Algumas vezes, você pode esquecer se rodar o processo utilizando o comando nohup e, mesmo assim, querer que ele continue rodando após a desconexão do SSH. Você pode tentar rodar scripts de madrugada, por achar que serão mais rápidos, e acabar descobrindo que eles demoram muito mais. Aqui fica uma pequena dica que vai te ajudar a rodar o script como daemon, assim não se encerrará ao término da sessão SSH.

  1. Ctrl + Z para pausar o programa e voltar ao shell
  2. bg para rodar no background
  3. disown -h [num-job], onde [num-job] é o número do job que está rodando (exemplo: %1 para o primeiro job rodando; você pode listar os jobs usando o comando jobs). Isso retirará sua propriedade do processo e ele não se encerrará após a saída do terminal.

Créditos da solução ao usuário Node no StackOverflow

Processando dados com PHP

Para quem roda scripts regularmente, é interessante criar um bash script para ser executado por um job agendado.

Exemplo de um bash script que, na verdade, roda um script PHP:

Example bash script which actually runs the PHP script:

#!/bin/sh
php /caminho/para/script.php

Exemplo de um cronjob:

0 23 * * * /bin/sh /caminho/para/bashScript.sh

Se você não sabe onde colocar o código acima, utilize o comando crontab -e para editar a sua tabela do cron e salvá-la. O 0 23 * * * indica que o script rodará aos 0 minutos, 23 horas de qualquer dia, em qualquer mês e em qualquer dia da semana (agradeço ao mbodock, que me alertou um detalhe que eu havia deixado passar aqui).

# *    *    *    *    *  comando
# ┬    ┬    ┬    ┬    ┬
# │    │    │    │    │
# │    │    │    │    │
# │    │    │    │    └───── dia da semana (0 - 6) (sunday - saturday)
# │    │    │    └────────── mês (1 - 12)
# │    │    └─────────────── dia do mês (1 - 31)
# │    └──────────────────── hora (0 - 23)
# └───────────────────────── minuto (0 - 59)

Exemplo extraído do artigo Cron da Wikipedia.

Vale também ressaltar que existem alguns nomes pré-definidos que você pode utilizar no lugar do horário de agendamento:

Abreviação Descrição Equivalente a
@yearly (ou @annually) Uma vez por ano, à meia-noite de 1º de Janeiro 0 0 1 1 *
@monthly Uma vez por mês, à meia-noite do primeiro dia do mês 0 0 1 * *
@weekly Uma vez por semana, à meia-noite de domingo 0 0 * * 0
@daily Uma vez por dia, à meia-noite 0 0 * * *
@hourly Uma vez por hora, no começo da hora 0 * * * *
@reboot Quando a máquina é inicializada @reboot

Bom, agora nós temos um script básico que rodará todas as noites às 11h. Não importa quanto tempo levará para executar, apenas irá começar às 23h e só encerrará quando terminar.

Twitter Streaming API

O segundo problema é mais interessante, porque o script PHP precisa estar rodando para coletar dados. Queremos que esteja rodando o tempo todo.

Para fazer o trabalho de capturar os dados da API do Twitter, podemos usar a excelente biblioteca Phirehose (fica a dica).

A partir daí, teremos um script que manterá permanentemente uma conexão aberta com a API do Twitter, mas não podemos garantir que estará sempre rodando. O servidor pode reiniciar, podemos ter algum tipo de problema na execução ou erros de qualquer outra natureza.

Então uma solução que podemos lançar mão é: criar um bash script para ter certeza de que o processo está rodando. E se não estiver, que comece a rodá-lo.

#!/bin/sh

ps aux | grep '[m]euScript.php'
if [ $? -ne 0 ]
then
    php /caminho/para/meuScript.php
fi

Agora vamos dar uma olhada, linha por linha, o que faz esse script:

Line by line explanation:

#!/bin/sh

Inicia o script indicando qual é o path do shell.

ps aux | grep '[m]euScript.php'

O comando ps lista os processos. Depois há um pipe (|) que fará com que seja executado um comando sobre o resultado da saída. O comando grep irá procurar por ‘[m]euScript.php’. Usei a expressão regular [m] para que o comando não encontre a ele mesmo. O grep lançará um processo com meuScript.php no comando, então você sempre encontrará um resultado se não colocar alguma coisa nos brackets.

if [ $? -ne 0 ]

Verifica o retorno do último comando. Então se nada for retornado, significa que não existe nenhum resultado para [m]euScript na lista de processos.

then
    php /caminho/para/meuScript.php
fi

Essas linhas são executadas se o script php não for encontrado rodando. É esse comando que irá rodar nosso script php. Então a condicional é encerrada com fi.

Agora vamos criar um cron job para executar o script acima:

* * * * * /bin/sh rodarPraSempre.sh

Isso fará com que o sistema fique checando o tempo todo se o nosso script está rodando. Se não estiver, fará rodar.

Considerações finais

Dá pra perceber que o script de streaming do Twitter é uma versão mais avançada do processamento de dados. Ambas as versões de produção, possuem muito mais coisas, obviamente, mas vão além do objetivo proposto nesse artigo. Se você estiver interessado em estender esses scripts, é uma boa ideia ativar o sistema de logs, pois vai te ajudar a ter uma noção de como o seu sistema está se comportando.

Um abraço a todos e fiquem com Deus!

Texto adaptado do original: http://reviewsignal.com/blog/2013/08/22/long-running-processes-in-php/