PHP do Básico ao Avançado – Aula 9 – Outras estruturas da linguagem

Tempo de Leitura: 7 Minutos

Nesta ultima parte do primeiro módulo, vamos finalizar falando sobre GENERATORS e ITERATORS, sobre a passagem de argumentos e dados por referência bem como as constantes, variáveis e outras estruturas já pré-definidas pelo PHP que podem ajudar muito a iteração e a padronização da escrita do código, bem como auxiliar na otimização e utilização de recursos como memória e processamento.

Um generator permite que você escreva código que use foreach para iterar em um conjunto de dados sem precisar construir um array em memória, o que pode fazer com que o limite de memória seja ultrapassado ou exigir uma quantidade considerável de tempo de processamento para a geração. Em vez disso, você pode escrever uma função generator, que é o mesmo que uma função normal, exceto que ao invés do retorno ocorrer única vez, um generator pode entregar o resultado quantas vezes forem necessárias para permitir que os valores sejam iterados.

Um exemplo simples para isso é reimplementar a função range(). A função range() padrão tem que gerar um array com cada valor dentro dele e retorná-lo, o que pode resultar em grandes arrays: por exemplo, chamando range(0, 1000000) irá resultar numa utilização de memória de mais de 100 MB.

Como alternativa, nós podemos implementar um generator xrange(), que só precisará de memória suficiente para criar um objeto Iterator e acompanhar o estado atual do generator internamente, que utiliza menos de 1 kilobyte de memória. Veja o exemplo:

<?php
function xrange($start, $limit, $step = 1) {
   if ($start < $limit) {
      if ($step <= 0) {
         throw new LogicException('Passo deve ser Positivo');
      }
      for ($i = $start; $i <= $limit; $i += $step) {
         yield $i;
      }
   } else {
      if ($step >= 0) {
         throw new LogicException('Passo deve ser negativo');
      }
      for ($i = $start; $i >= $limit; $i += $step) {
         yield $i;
      }
   }
}

echo 'Números impara em um range(): ';
foreach (range(1, 9, 2) as $number) {
   echo "$number ";
}
echo "\n";
echo 'Agora usando xrange(): ';
foreach (xrange(1, 9, 2) as $number) {
   echo "$number ";
}
?>

O código é muito semelhante à implementação baseada em array. A principal diferença é que, em vez de inserir valores em uma matriz, os valores são produzidos. Os geradores funcionam passando o controle para frente e para trás entre o gerador e o código de chamada.

O coração de uma função generator é a palavra chave yield. Na sua forma mais simples, uma declaração yield se parece muito com um retorno, exceto que em vez de parar a execução da função e retornar, o yield fornece um valor para o código de loop sobre o generator e pausa a execução da função do generator.

Note que podemos usar o yield de maneiras distintas, para retornar pares chave/valor (array associativo):

$data = (yield $key => $value);

$data = (yield $value);

Variáveis e Pré Definidas

O PHP fornece uma enorme lista de variáveis pré-definidas para todos scripts, que representam tudo, de variáveis externas à variáveis de ambiente. Um conceito existente, diferente de algumas outras linguagens, é Superglobais são variáveis nativas que estão sempre disponíveis em todos escopos. As variáveis pré-definidas no PHP são “superglobais”.

Essas variáveis são: $GLOBALS, $_SERVER, $_GET, $_POST, $_FILES, $_COOKIE, $_SESSION, $_REQUEST, $_ENV onde cada uma delas é um array associativo, contendo um conjunto de dados, como descrito:

$_SERVER é um array contendo informação como cabeçalhos, paths, e localizações do script. As entradas neste array são criadas pelo servidor web. Não há garantia que todos os dados estarão disponíveis, pois cada servidor web proverá algum destes e podem omitir outros, bem como fornecer outros não listados, um grande número dessas variáveis são previstas pela CGI 1.1 specification, então você deve estar preparado para trata-las se necessário.

$_GET é um array associativo de variáveis passadas para o script atual via o método HTTP GET. Onde chave é o nome da variável, e o valor seu conteúdo.

$_POST um array associativo de variáveis passados para o script atual via método HTTP POST quando utilizado application/x-www-form-urlencoded ou multipart/form-data como valor do cabeçalho HTTP Content-Type na requisição. Novamente contendo nas chaves os nomes das variáveis, e nos valores seu conteúdo.

$_FILES HTTP File Upload variáveis, array associativo de items enviado através do script atual pelo método HTTP POST. A estrutura deste será mais detalhada a frente, quando falar-mos sobre UPLOADS e vamos usar este modelo, mais basicamente sua estrutura é composta de:

Array
(
    [file1] => Array
        (
            [name] => MyFile.txt (Nome do arquivo, como enviado pelo browser)
            [type] => text/plain  (Este mime type é também definido pelo browser, e não devemos contiar totalmente nele)
            [tmp_name] => /tmp/php/php1h4j1o (nome do arquivo salvo localmente (temporário) usado pelo PHP para referenciar seu conteúdo)
            [error] => UPLOAD_ERR_OK  (= 0 se OK, outros códigos identificam erros)
            [size] => 123   (tamanho em bytes)
        )

    [file2] => Array
        (
            [name] => MyFile.jpg
            [type] => image/jpeg
            [tmp_name] => /tmp/php/php6hst32
            [error] => UPLOAD_ERR_OK
            [size] => 98174
        )
)

É um array multidimentional, contendo em cada iteração um array de chave e valor representando um campo do formulário com um arquivo, como apresentado na estrutura acima.

Array
(
    [download] => Array
        (
            [name] => Array
                (
                    [file1] => MyFile.txt
                    [file2] => MyFile.jpg
                )

            [type] => Array
                (
                    [file1] => text/plain
                    [file2] => image/jpeg
                )

            [tmp_name] => Array
                (
                    [file1] => /tmp/php/php1h4j1o
                    [file2] => /tmp/php/php6hst32
                )

            [error] => Array
                (
                    [file1] => UPLOAD_ERR_OK
                    [file2] => UPLOAD_ERR_OK
                )

            [size] => Array
                (
                    [file1] => 123
                    [file2] => 98174
                )
        )
)

Note que neste segundo exemplo, temos um array, onde existe 1 campo único no formulário, porém, esta campo permite envio de multiplos arquivos, na aula sobre uploads, vamos falar como iterar nas 2 maneiras.

$_REQUEST é um array associativo que por padrão contém informações de $_GET, $_POST e $_COOKIE juntas.

$_SESSION é um array associativo contendo variáveis de sessão disponíveis para o atual script, existem diversas funções e estruturas específicas para o trabalho com as sessões, e vamos ter um capítulo inteiro específico sobre esses manipuladores.

$_ENV são as variáveis passadas para o script atual via o método do ambiente. Estas variáveis são importadas para o PHP do ambiente sob o qual o parser do PHP é executado. Muitas são providas pelo shell sob o qual o PHP é executado e diferentes sistemas vão executar diferentes tipos de shells, uma lista definitiva é impossível. Outras variáveis de ambiente incluem variáveis CGI, elas aparecem desconsiderando se o PHP é executado como um módulo do servidor ou processador CGI.

$_COOKIE são uma forma simples de se receber as variáveis passadas para o atual script via HTTP Cookies. No PHP existem funções que facilitam o envio desses cookies e ao recupera-los podemos saber dados sobre uma sessão prévia ou preferências básicas do usuário.

$php_errormsg é uma variável contendo o texto da última mensagem de erro gerado pelo PHP. Esta variável somente estará disponível dentro do escopo no qual o erro ocorreu, e somente se a opção de configuração track_errors estiver on, EXISTEM MÉTODOS ESPECÍFICOS MAIS EFICIÊNTES PARA TRATATIVAS DE ERRO COMO MOSTRADO ANTERIORMENTE.

$http_response_header é similar a função get_headers() e retorna um array associativo contendo os cabeçalhos de resposta HTTP. $http_response_header será criada no escopo local.

Constantes PHP

O PHP possui uma série de valores definidos em constantes, que abrangem praticamente qualquer recurso, e também podem ser usadas para permitir a compatibilidade de valores por exemplo em windows e unix, formatos de dadas e horas, etc.

Note que o CORE do PHP define algumas, e as extensões também define uma outra série que passam a ficar disponíveis quando a extensão estiver compilada ou habilitada no momento. Famos falar delas quando estiver-mos falando sobre as diversas funções que as utilizam.

Algumas das disponibilizadas pelo CORE e que são especiais:
_LINE__ O número da linha corrente do arquivo.
__FILE__ O caminho completo e nome do arquivo com links simbólicos resolvidos. Se utilizado dentro de um include, o nome do arquivo incluído será retornado.
__DIR__ O diretório do arquivo. Se usado dentro de um include, o diretório do arquivo incluído é retornado. É equivalente a dirname(__FILE__). O nome do diretório não possui barra no final, a não ser que seja o diretório raiz.
__FUNCTION__ O nome da função, or {closure} para funções anônimas.
__CLASS__ O nome da classe. O nome da classe inclui o namespace em que foi declarado (por exemplo, Foo\Bar). Note que a partir do PHP 5.4, __CLASS__ também funcionará em traits. Quando utilizada em um método trait, __CLASS__ é o nome da classe que está utilizando a trait.
__TRAIT__ O nome do trait. O nome do trait inclui o namespace em que foi declarado (por exemplo, Foo\Bar).
__METHOD__ O nome do método da classe.
__NAMESPACE__ O nome do namespace corrente.

TRUE (boolean)
FALSE (boolean)
NULL (boolean)

PHP_EOL – (CR/LF) Carrige Return e Line Feed – define a combinação correta desta ou destas para o sistema em execução no momento, isso garante que sempre o formato correto será usado, indiferente do sistema onde o PHP estiver rodando.

Conclusão

Finalizamos este módulo, e a partir da próxima aula, vamos falar sobre as diversas funções que já vem incluídas com o PHP e algumas funções definidas nas extensões da linguagem que podem ser compiladas ou carregadas em tempo de execução.

Vamos falar também sobre a forma que o PHP manipula os dados, e pensar um pouco na segurança dos nossos scripts e na manipulação de entradas, considerando as diversas formas possíveis e protegendo nossos dados e nossos sistemas com uso de diversas diretrizes para boas práticas. Até lá.