O poder do PHP

Graças à sua versatilidade, há mil e uma maneiras de resolver um determinado problema com PHP. Contudo, sempre existem aquelas dicas, guardadas com carinho, que podem lhe ajudar a resolver um problema de última hora São estas dicas, juntamente com uma breve história do PHP, que apresentamos nesta matéria

Oficialmente conhecido como PHP: Hypertext Preprocessor, o PHP é uma linguagem script processada no servidor, diferente do JavaScript, que é interpretado pelo próprio browser. Diferente de outras linguagens scripts utilizadas para construção de sites (como Perl), o PHP permite que páginas HTML comuns ganhem vida com recursos como por exemplo, o acesso a bancos de dados dos mais diferentes fabricantes.

O PHP foi idealizado por Rasmus Lerdorf como um recurso para verificar quem acessava o seu curriculum no site. Alguns afirmam que o PHP nasceu como uma extensão de um módulo de Perl, mas não vamos entrar em discussões por causa disso. A partir do esforço inicial de Lerdorf, o desenvolvimento envolveu a contribuição de centenas de pessoas que achavam aquela linguagem interessante, pois lhes permitia fazer coisas importantes como processar dados de formulários de forma mais simples em seus sites. Nada muito além do que faria um clássico Perl CGI. Provavelmente o primeiro grande recurso do PHP aconteceu quando, em meados de 1995, foi integrado o suporte a mSQL e nasceu o que hoje conheceríamos como PHP/FI (PHP Versão 2).

Em apenas dois anos, com a contribuição de pessoas no desenvolvimento e no uso, já haviam mais de 50.000 usuários de PHP. Foi então que o projeto pessoal de Rasmus se tornou um projeto com centenas de pessoas contribuindo para seu desenvolvimento ao redor do mundo. Zeev Suraski e Andi Gutmans, agora participantes sempre presentes no projeto PHP, transformaram aquele breve utilitário para processar formulários de livros de visitas no que foi conhecido como a versão 3 do PHP.

E como funciona?

O principal motivo que leva as pessoas a começarem a desenvolver em PHP é a questão da facilidade e similaridade com outras linguagens de programação. Quem conhece os primórdios do desenvolvimento para web lembra como era sofrível fazer o simples parser de um formulário para um cgi feito em C. Sem contar o fato de pegar arquivos binários enviados por formulário; mesmo com o uso de bibliotecas específicas para isso, ainda não era a coisa mais agradável do mundo.

A questão da similaridade da sintaxe do PHP com C vai além de condicionais e variáveis (veja Figura 1). É possível desenvolver aplicações orientadas a objeto também, trazendo consigo todas as vantagens dessa metodologia. Assim, com algumas adaptações, você pode portar suas aplicações cliente para um ambiente web, simplesmente utilizando os diagramas criados na definição do seu sistema. Se preferir, pode até criar suas próprias aplicações clientes para Linux com PHP e GTK.

O PHP tem seu core desenvolvido em C, o que permite uma grande velocidade e segurança no processamento dos dados. Além disso, o design da linguagem permite o desenvolvimento de novas bibliotecas e módulos que supram as necessidades do desenvolvedor. Para isso, basta que você conheça bem o que precisa, conheça como implementar isso em C e ler a documentação sobre como integrar sua aplicação ao PHP. Assim foi o caso dos módulos de acesso a Mysql, PostgreSQL, Oracle, sockets e até bibliotecas de manipulação de Flash. Apesar da grande integração com módulos e bibliotecas de terceiros, a integração desses módulos ao core do PHP responde a critérios definidos pela equipe principal de desenvolvimento, que envolve, entre outras pessoas, o próprio Lerdorf.

Embora inicialmente mantido sob a GPL, o grupo de desenvolvimento do PHP preferiu criar sua própria licença de distribuição por motivos relacionados com a popularização da linguagem. Em resumo, é possível modificar e distribuir o PHP, de forma comercial ou não, desde que fiquem claras para o usuário as modificações feitas.

Crescendo a cada dia

Que o PHP é adotado cada vez mais por sites em todo o mundo, não é novidade. São raros os casos de sites da comunidade Open Source que não se utilizam do PHP pelo menos para processar formulários. Da mesma forma, grandes organizações como a IDG e instituições como a Unicamp optaram pelo PHP. Além de ser um Software Livre, é possível criar novos módulos e bibliotecas de forma muito prática e integrá-los ao PHP. Melhor ainda, o PHP está disponível para diferentes servidores web e sistemas operacionais, desde Apache + Linux até o MacOS X.

É fácil acompanhar o esforço da comunidade em utilizar o PHP, basta fazer uma pesquisa por aplicações desenvolvidas com PHP cadastradas em sites como freshmeat e sourceforge, dois grandes sites que apóiam o desenvolvimento Open Source. Somente no freshmeat existem mais de 400 referências de aplicações desenvolvidas. São ferramentas com as mais diversas finalidades, desde gerenciamento de sites até sistemas de CRM e gerenciamento de redes prontos para ser instalados.

Evolução atrás de Evolução

Como toda grande linguagem de desenvolvimento que se preze, o PHP está sempre em evolução. Desconsideremos os mais de 90 módulos oficiais distribuídos na versão atual do PHP. Você ainda considera que o PHP é uma linguagem que não atende às suas necessidades? Não é o que a Zend acha.

Criada por Zeev Suraski, participante ativo do projeto PHP, a Zend é uma empresa que investe sua tecnologia no PHP. Baseado no Zend Engine criado pela equipe do projeto PHP, a Zend criou uma série de recursos que prometem aumentar a performance das aplicações em PHP, inclusive um “codificador” de PHP que transforma a seqüência de códigos dos scripts PHP em um formato criptografado.

Além da aposta da Zend em desenvolver produtos baseados no próprio engine do PHP, em setembro deste ano, Andrei Zmievski apresentou a proposta do PHP-GTK, um projeto que visa criar aplicações clientes utilizando PHP e essa biblioteca de desenvolvimento. Encontramos até mesmo no site codigoaberto.org.br duas aplicações que fazem uso dessa biblioteca.

Veremos a partir de agora algumas dicas quentes e selecionadas especialmente para aqueles que querem se aperfeiçoar no PHP sem perder tempo.

Exemplo de código PHP #include “zend_compile.h” #include “zend_execute.h” #include “zend_highlight.h” #include “zend_indent.h” #include “zend_extensions.h” #include “php_content_types.h” #include “php_ticks.h” #include “php_logos.h” #include “SAPI.h” #ifndef ZTS php_core_globals core_globals; #else PHPAPI int core_globals_id; #endif static void php_build_argv(char *s, zval *track_vars_array ELS_DC PLS_DC); #define SAFE_FILENAME(f) ((f)?(f):”-”) static PHP_INI_MH(OnSetPrecision) { ELS_FETCH(); EG(precision) = atoi(new_value); return SUCCESS; }

Validando campos com Expressões Regulares

Isso mesmo. Por que ficar matando o tempo com procedimentos estressantes somente para validar campos? Veja, por exemplo, como é simples verificar se um campo é um e-mail válido:

if( !eregi(“^[A-Za-z._-]+@[A-Za-z-]{1,}\.[a-z]{2,3}”,$campo))

        echo “e-mail inválido”;

Que tal esta para validar CEP:

if( !eregi(“^[0-9]{5}-[0-9]{3}”,$campo))

        echo “CEP inválido”;

// Definição de cabeçalho para imagem tipo gif

header(“Content-type: image/gif”);



// Definição de cabeçalho especificando aplicação binária

header(“Content-type: application/octet-stream”);

$strNomeArquivo = “./arquivo.txt”;



// Re-definimos o cabeçalho do script PHP para ser

// interpretado como uma aplicação. Logo, como os

// navegadores possuem trava de segurança contra execução de

// arquivos, o usuário fará o download desse arquivo e

// decidirá se irá executá-lo ou não.

Header(“Content-type: application/octet-stream; name=$strNomeArquivo”);

Header(“Content-Disposition: attachment; filename=$strNomeArquivo”);



if($fp = fopen($strNomeArquivo, “r”))

{

        // Enviamos o arquivo de 4 em 4 kbytes

        while($buffer = fread($fp, 4096))

        {

                echo($buffer);

        }

        fclose($fp);

}

Trabalhando com Cookies

Não há nada mais simples do que trabalhar com cookies com PHP. Você está ligado a apenas uma função, a setcookie(). Uma vez definido um “biscoitinho”, a referência é feita a ele como se você estivesse referenciando uma variável qualquer postada por um formulário: $variavel

Você pergunta: “Só isso?”. É, só isso. Achou fácil? Bom, então aqui vão algumas dicas sobre isso.

Cookies são recursos utilizados para guardar informações sobre o cliente no próprio cliente. Usamos bastante naqueles sites onde o usuário marca “Não quero mais digitar minha senha” ou algo parecido. Não vamos comentar aspectos de segurança quanto a isso. É preciso ter um pouco de ética quando se trabalha com desenvolvimento. Não guarde informações que possam ferir a privacidade do usuário. (como senhas)

Continuando, um cookie pode ser muito chato em vários aspectos. Ele quer se sentir o melhor, por isso quando você define um cookie, não defina absolutamente nada antes dele. Isso significa que, nem mesmo um espaço em branco no seu script é permitido. É, ele é chato assim mesmo.

// Definindo um cookie com o IP do usuário

setcookie(“strIPUsuario”,HTTP_SERVER_VARS [“REMOTE_ADDR”]);



// Referenciando um cookie gravado

echo $strIPUsuario;

Existem outras opções quando definimos um cookie, mas basicamente precisamos somente dessas duas. Vale lembrar também que, em alguns browsers, os cookies tem uma certa “latência” que faz com que demorem para ser gravados (algo em torno de segundos). Na pior das hipóteses, grave o cookie e redirecione sua página para outro lugar. Esse intervalo é o suficiente para o cookie ser fixado. Você também pode gravar arrays de cookies da mesma forma que cria uma variável.

// Um array com 5 posições

$semana = array(“segunda”,”terça”,”quarta”,”quinta”,”sexta”);



for( $i = 0; $i < sizeof($semana); $i++ )

setcookie(“strSemana[$i]”,$semana[$i]);

A chamada a esses cookies é igual a qualquer outro cookie, variável ou elemento de array. Você criou 5 cookies, cada um com um índice. Para referenciá-los faça assim:

// Mostrará “segunda->sexta”

echo $strSemana[0] . “->” . $strSemana[4];

Além dessas opções normais, ainda é possível definir fatores como tempo de vida do cookie, diretório e domínio onde ele funcionará e se deverá ficar sob s-http.

// Criamos um cookie chamado biscoito, cujo valor é chocolate e que tem um tempo de vida de 1 hora

setcookie(“biscoito”,

          “chocolate”,

          time() + 3600);



// Mudamos o valor do cookie biscoito para baunilha e aumentamos seu tempo de vida de 1 para 2 horas. 
//Mas agora ele só funciona, ou seja, pode ser referenciado, se estiver abaixo do diretório /pessoal no site

setcookie(“biscoito”,

          “baunilha”,

          time() + 7200,

          “/pessoal”);



// Acabamos de jogar fora nosso cookie biscoito. Mudamos seu tempo de vida para menos de 1 hora. Ou seja, ele já deve ser inútil para nós.

//

// obs.: em alguns browsers a morte do cookie demora alguns segundos. 
//Por isso, prefira redirecionar a página para outro lugar antes de fazer alguma nova chamada ao cookie destruído.



setcookie(“biscoito”,

          “baunilha”,

          time() - 3600,

$SQL = “SELECT nome, telefone, sexo, idade, cep, endereco,

               cidade, pais, estado, esporte FROM usuario”;

$db = mysql_query($SQL,$query);

$res = mysql_fetch_array($db);

extract($db,EXTR_PREFIX_ALL,”p”);

Utilizando conexões globais

Isso é uma questão de ordem. Sabemos que o PHP tem condições de gerenciar centenas de conexões com bancos de dados, servidores e outros recursos de maneira bem prática. Mas por que sobrecarregá-lo? Sempre que possível, prefira conexões (também chamadas de resources) globais.

Outra dica que pode salvar seu amigo PHP é aproveitar que você já está usando conexões globais e deixá-las ainda mais simples. Como? Declare-o em um arquivo comum a todo seu site / sistema. Crie um arquivo geral.php e em seu interior abra a conexão que irá utilizar.

// arquivo geral.php

<? 

define(“DBSERVER”,”192.168.1.1");

define(“DBUSER”,”usuario”);

define(“DBPASS”,”senha”);



$conn = mysql_connect(DBSERVER,DBUSER,DBPASS);

?>

Nos demais arquivos, tudo o que você precisa fazer é incluir o arquivo geral.php e utilizar a conexão como desejar.

include(“geral.php”);

A conexão será acessível em qualquer lugar e ainda por cima vai simplificar a sua vida quando (e se) tiver que mudar alguma coisa em relação a ela.

<html>

<body>

Meu nome é $nome<br>

Eu fiz o script $SCRIPT_NAME

</body>

</html>

$nome = “Sr. Daewoo”;

define(“MINHA_PAGINA”,addslashes(implode(“”,file(“pagina.html”)) ));

$PAGINA = MINHA_PAGINA;

eval(“\$PAGINA= \”$PAGINA\”;”);

$paginaHTML = $PAGINA;

echo $paginaHTML;

Suprimindo mensagens de erro

Isto é muito importante. Portanto, preste atenção. O tratamento de erros em qualquer sistema deve ter muita prioridade. A questão é simples: você faz sistemas (na maioria das vezes) para usuários. Se o usuário não gosta do sistema, você vai ter problemas.

Algo muito comum desse tipo acontece quando você deixa de tratar mensagens de erro (ou exceptions) de seu sistema. De alguma maneira, na face da terra sempre tem alguém que consegue descobrir uma exceção no seu sistema que irá gerar uma mensagem de erro inesperada. Muitas vezes isso pode ser realmente ruim. Imagine que está abrindo uma conexão com um servidor qualquer e, de repente, BUM!, o servidor caiu. O que irá aparecer na tela? O warning da sua conexão com o servidor juntamente com seu usuário e senha para conexão. Bom isso, não? Alguém realmente mal-intencionado pode utilizar essas informações para lhe provocar uma grande dor-de-cabeça. Como resolver esse problema em curto prazo? A “@” (arroba). Isso mesmo. A “@” na frente de qualquer função irá suprimir as mensagens de erro. Como por exemplo:

$ds=@ldap_connect(“ldap.meudominio”);

Nesse caso, se algum erro vier a acontecer na conexão com o servidor de LDAP, nada será mostrado. As mensagens serão suprimidas pela “@”. Óbvio que você vai precisar fazer o debug da aplicação. Portanto, não esqueça de tirar a “@” sempre que for fazer isso.

Forçando a limpeza do Cache

Páginas com atualizações dinâmicas podem gerar alguns problemas, principalmente se isso estiver relacionado com o cache dessas páginas. E mesmo que você venha a resolver esse problema no seu browser, ainda pode ter problemas com um possível servidor proxy até o seu webserver. Como resolver o problema? O pessoal do PHP tem algumas dicas interessantes sobre isso.

// A página especifica que seu conteúdo expirou em 26 de julho de 97 e que o servidor deve procurá-la como uma versão mais atual

header (“Expires: Mon, 26 Jul 1997 05:00:00 GMT”);



// A função gmdate usa o momento atual para avisar ao

// servidor que a página acabou de ser modificada

header (“Last-Modified: “.gmdate(“D, d M Y H:i:s”).”GMT”);





// Isto é para os servidores proxy. Basicamente ele diz “não me cacheie! Baixe-me sempre!”

header (“Cache-Control: no-cache, must-revalidate”);



// ...e este é para seu navegador. Nem sempre funciona

// devido à falta de padrão entre as especificações de cada um deles, mas, não custa tentar.

header (“Pragma: no-cache”);

Uma simples implementação da função header pode significar a liberdade desse cache %@*@*#%! (pelo menos por enquanto)

Acessando servidores POP com o PHP

Quem já procurou por bibliotecas de acesso a servidores POP3 em PHP deve ter se deparado com soluções do tipo “conversar” em nível de socket com o servidor. Funciona, mas é muito trabalhoso mesmo. É possível obter o mesmo resultado, mas com a biblioteca de acesso a IMAP. ­ É! IMAP! ­ Parece até brincadeira, mas não é. Com a função imap_open é possível acessar tanto caixas postais do tipo IMAP quanto POP. Para isso basta definir corretamente a string de conexão. Para abrir a INBOX de um servidor POP, podemos fazer da seguinte maneira:

$pop = imap_open(“{localhost:110/POP3}INBOX”,”usuario”,”senha”);

Os parâmetros de porta, protocolo e caixa postal podem ser livremente alterados, lembrando que para mailboxes do tipo IMAP não precisam especificar a porta, apenas que utilizam esse protocolo para conexão. No caso, para acessar um servidor IMAP:

$imap = imap_open (“{localhost:143}INBOX”, “usuario”, “senha”);

Mandar e-mail. Desde que o ser humano descobriu a Internet essa é a principal função da rede. Vamos mandar e-mail, então. Comecemos com algo simples, um e-mail com assunto.

mail(“destinatario@dominio”,

     “Teste de E-mail”,

     “Olá! Mandei e-mail pelo PHP”);

Pronto! Você deve receber uma mensagem mais ou menos assim:

Date: Wed, 31 Oct 2001 11:52:41 -0200

From: voce@dominio

To: destinatario@dominio

Subject: Teste de E-mail



Olá! Mandei e-mail pelo PHP

E isso é só o começo. O quarto parâmetro da função mail() lhe permite fazer coisas como:

// Se você quiser especificar o remetente do seu e-mail, faça-o nesse formato



$headers .= “From: Eu Mesmo <fulano@dominio>\n”;



// Quando o usuário der um “reply” no seu e-mail, a resposta deverá vir para este endereço ao invés do remetente

$headers .= “Return-Path: <fulano@dominio>\n”;  



// Isso é interessante. Se quiser que sua mensagem chegue em HTML, não esqueça de definir esta opção. Mas lembre-se, a

// mensagem DEVE ser escrita em HTML para aparecer em HTML óbvio, né?!)

$headers .= “Content-Type: text/html; charset=iso-8859-1\n”;



// Cópias comuns...

$headers .= “cc: destinatario1@dominio\n”; 



// ... e blind-copies (aquelas mensagens que são recebidas mas seu nome não está entre os destinatários)

$headers .= “bcc: destinatario2@dominio, destinatario3@dominio”; 

Não esqueça de que, para cc e bcc, quando especificar mais de um endereço de e-mail, você deve separá-los por vírgula!

Vamos ver como ficaria se resolvêssemos juntar tudo. Para simplificar nossa vida vamos utilizar o recurso do eval() e ter um template para suas mensagens. Assim, quando tiver que mandar uma resposta padrão, simplesmente usaremos o eval() com o texto, trocando as variáveis do texto. Dessa forma, poderíamos mandar um e-mail desta maneira:

# arquivo mensagem.txt

“Prezado(a) $nome



Muito obrigado por preencher seus dados. Estaremos entrando



em contato com você em alguns dias.



Apareça!”



# meu script de mandar e-mail

define(“MENSAGEM”,addslashes implode(“”,file(“mensagem.txt”)) ));

$MSG = MENSAGEM;

eval(“\$MSG= \”$MSG\”;”);

$minhaMensagem = $MSG;

mail($destinatario,

“Obrigado por se cadastrar”, $minhaMensagem,“From: Seu webmaster amigo <p;webmaster@dominio>\n”. “cc: webmaster@dominio”);

Datas, horas e afins

Em muitos casos temos que trabalhar com datas quando programamos com PHP. Um exemplo disso, e acredito que você já tinha até se esquecido disso, é a questão do cache. Lembra? do gmdate? Pois então. Comecemos com algo simples, como mostrar a data atual.

// Isso vai imprimir 31/10/2001

echo( date(“d/m/Y”) );



// Isso vai imprimir Horas: 17:48:53

echo( date('\H\o\r\a\s: H:i:s') );

A função date() é a mais simples de todas. Notou que tudo o que tivemos que fazer foi especificar o formato da data com as letras d, m e y. Além dessas, a função lhe permite trabalhar com vários formatos. Notou que, no segundo exemplo para escrever a palavra Horas tivemos que “escapar” todas as letras, certo? Bom, é assim mesmo. Como a função date() interpreta os caracteres como formato para visualização, o ideal é você não ficar escrevendo frases dentro dela. Sempre que possível, concatene a função date com um echo() normal.

echo(“Horas: “.date(“H:i:s”));

Outro formato muito utilizado é o chamado UNIX timestamp, a quantidade em segundos passados desde a meia-noite de 1o de Janeiro de 1970 GMT, ou também chamado de epoch. Para obter esse valor podemos utilizar duas funções, o time() e o microtime(). A diferença básica entre as duas é que a segunda nos retorna, além do tempo em segundo, sua parte em milissegundos.

// 31 Oct 2001 17:58:46 -0200

echo( date(“r”) );



// 0.03439600 1004558326 

echo( microtime() );



// 1004558326 

echo( time() );

Como você notou no uso da função date(), apenas obtivemos os dados referentes ao momento atual. Em nenhum instante foi fornecida uma data qualquer que gostaríamos de imprimir com nosso formato personalizado. Não tem problema, pois o segundo parâmetro dessa função serve exatamente para isso. Se fornecermos uma variável em UNIX timestamp, a função date() utilizará esse valor como parâmetro para formatar a data.

Como é extremamente chato ficar calculando os segundos passados até 1o de Janeiro de 1970, o PHP nos fornece a função mktime(), que faz exatamente esse serviço para nós.

// A seqüência de parâmetros da função mktime() é exatamente essa.
//Portanto, você deverá seguir essa seqüência para gerar um timestamp qualquer

$hora = 18;

$minuto = 10;

$segundo = 00;

$mes = 12;

$dia = 06;

$ano = 1977;



$ts = mktime($hora,$minuto,$segundo,$mes,$dia,$ano);



// Mostrará 250290600

echo $ts;

Pronto, agora podemos utilizar esse valor na função date e formatá-lo da forma que melhor entendermos.

Existe outra função para formatação de data considerada muito mais “poderosa” em relação a opções de formatação que a date(). Estamos falando de strftime(), uma função baseada na biblioteca C instalada em seu servidor. Basicamente a strftime() inclui mais opções de formatação para datas que date() e, ao invés de utilizar simplesmente a letra para definir o formato a ser impresso, utiliza também o sinal de porcentagem (“%”). O segundo parâmetro dessa função funciona exatamente como date: recebe um UNIX timestamp.

Uma relação completa de todos os formatos você pode encontrar em www.php.net/manual/en/function.date.php

Trabalhando com respostas do servidor

Todo servidor http gera “respostas” para os navegadores. Respostas estas que indicam para o usuário que uma página não existe (Erro 404), que ela foi movida (Erro 301), que você não tem autorização para visualizá-la (Erro 501) e assim por diante.

Digamos que esteja trabalhando em um sistema e gostaria que, apenas as pessoas cujo IP seja XXX.XXX.XXX.XXX tenham acesso a essa página. Todos os de IP diferentes deverão ter a mensagem de que aquela página não existe.

if( !ereg(“192.168.1.1”,HTTP_SERVER_VARS[“REMOTE_ADDR”] ) )

        header(“HTTP/1.0 404 Not Found”);

No Apache, você pode definir uma determinada página para respostas de erro. Aquelas que sempre aparecem quando você tenta acessar um endereço que não existe, o clássico Erro 404. Então, tire proveito disso! Fique sabendo o que seus usuários estão acessando e corrija a tempo.

No Apache especifique:

ErrorDocument 404 /suapagina.php

E no seu script faça algo assim:

mail(“webmaster@seusite”,

     “página nãoencontrada”,

      $HTTP_REFERER);

Sabe o que vai acontecer!? O senhor webmaster vai receber um e-mail com o endereço da página não encontrada! Dessa forma, é possível controlar e mesmo descobrir quais páginas andam “desaparecendo” no site. Mas cuidado! Se muita gente acessar seu site e muitas páginas sumirem, já sabe o que vai acontecer com a caixa postal do webmaster, né?!

E não acaba por aí! Os servidores http em geral possuem vários códigos de resposta que podem ser utilizados, desde que você saiba o que fazer. Quem tiver mais interesse sobre esses sistemas, acesse a RFC 2616 com a especificação deles:

Autenticando usuários com PHP

Pode-se utilizar o PHP para autenticar nossos usuários pelos mais diferentes recursos: servidores LDAP, NIS, POP, IMAP, FTP, Bancos de Dados, arquivos texto, etc. Simplesmente, uma infinidade de opções.

A autenticação pelo PHP é feita da mesma forma que ocorre com o Apache: uma mensagem é enviada para o browser dizendo que, naquele determinado script, o usuário não possui permissão. Em paralelo, o navegador sabe que, sempre que essa mensagem é enviada, ele precisa mostrar uma janela pedindo usuário e senha. É nesse momento que as coisas mudam.

// Código responsável pelo aparecimento da janela de

// autenticação do usuário

if( !isset($PHP_AUTH_USER) )

{

Header(“WWW-Authenticate: Basic realm=\”Minha Seção\””);

        Header(“HTTP/1.0 401 Unauthorized”);

        exit;

}

else

{

        if( $PHP_AUTH_USER != “usuario” && 

            $PHP_AUTH_PW != “senha” )

        {

                Header(“WWW-Authenticate: Basic realm=\”Minha Seção\””);

                Header(“HTTP/1.0 401 Unauthorized”);

                exit;

        }

}

Essa janela aberta pelo browser nada mais é do que um formulário disfarçado, onde o usuário envia seu login e senha para o servidor e este se encarrega de autenticar os dados. No caso específico do PHP, o campo de login e senha possuem nomes próprios. Nós os chamamos, respectivamente, de $PHP_AUTH_USER e $PHP_AUTH_PW. Depois de autenticado, essas duas variáveis ficam ativas indefinidamente, ou até que você feche seu navegador, ou que defina que essas variáveis não mais podem existir. Em qualquer um desses casos, a janela volta a aparecer sempre que acessar aquele script.

// Como acabar com o acesso à área restrita após ter sido

// autenticado

unset($PHP_AUTH_USER);

unset($PHP_AUTH_PW);

Trabalhando com arquivos remotos

Com o PHP é possível acessar, gravar, apagar, fazer e acontecer também com arquivos remotos. Você pode utilizar várias funções para acessar arquivos remotos. A mais simples delas é o include(). Digamos que você tem uma página e não quer que o usuário saia dela, mas tem outro site cujo conteúdo é legal e você gostaria que ele ficasse dentro do seu. O que fazer se você não quer usar frames? Tente algo assim:

include(“http://outrosite/pagina”);

A página que você referenciou vai, literalmente, ser incluída na sua página. Mas cuidado quando fizer isso, pois toda vez que alguém acessar essa página, o servidor onde está seu script vai fazer uma conexão http e vai baixar a página; todas as vezes. Outras maneiras de acessar arquivos remotos envolvem as funções file() e fpassthru(). Ambas funcionam de forma parecida com o include. O file() lê o arquivo e joga o seu conteúdo, linha-a-linha, para uma posição de um array. O fpasstrhu lê o arquivo e o retorna diretamente na tela, bem parecido com o include.

E não pára por aí. Quem trabalhou com C/C++, deve se lembrar do fopen(). Muito parecido com o homônimo dessas duas linguagens, o fopen() do PHP possui ainda o recurso de abrir e gravar arquivos em servidores remotos http e FTP. Como!? Fácil.

$fp = fopen(“ftp://usuario:senha@servidor/arq.txt”,”w+”);

$fp = fopen(“http://servidor/arq.html”,”r”);

Parece simples demais? Mas é assim mesmo. Existem formas mais elegantes de fazer isso, principalmente se você levar em consideração o fato de que é simples demais mesmo.

E só pra terminar esse papo de leitura de arquivos remotos, tem o virtual(), filho perdido do PHP com o Apache. Muito utilizado por quem programou sites com o mod_include do Apache, esse recurso funciona exatamente da mesma forma. Você especifica uma URL e ele a inclui.

Trabalhando com Internacionalização

Esse é um recurso comum entre sistemas desenvolvidos sob a GNU/GPL: internacionalizar um programa, ou seja, deixá-lo funcional em diferentes línguas.

Como não poderia deixar de ser, em PHP você também pode tirar proveito dessa facilidade através de basicamente duas funções: setlocale() e gettext(). A primeira tem uma característica bem simples, mas muito versátil. Quando chamada com a especificação da linguagem desejada, ela altera padrões como formatação de data, números e dinheiro para o formato adotado pelo país cuja língua você especificou.

A segunda função envolve procedimentos muito mais complexos, portanto abordaremos seu uso em outra ocasião.

// Utilizamos o parâmetro %A no strftime() para imprimir o dia da semana por extenso. 
//Por padrão o PHP utiliza formato americano (“en”) para seus parâmetros.

//

// O echo irá mostrar Thursday

echo strftime(“%A”);



// Mudamos agora os formatos para aquele adotado no Brasil

// (“pt_BR”)

setlocale(“LC_ALL”,”pt_BR”);



// O echo irá mostrar quinta

echo strftime(“%A”);

Da mesma forma, também podemos utilizar os formatos derivados pelo setlocale() para números. Como se sabe, países como os Estados Unidos utilizam para números uma formatação diferente da nossa (eles usam vírgula onde usamos ponto e vice-versa).

Conhecendo melhor o seu PHP

Uma função realmente útil para quem desenvolve em PHP é o phpinfo(). Experimente criar um PHP qualquer e colocá-lo como única função. Você terá todas as informações pertinentes ao PHP instalado em seu servidor mostradas de forma organizada. Entre outros valores mostrados, o phpinfo() retorna as variáveis de ambiente do Apache, opções de compilação do PHP que está sendo rodado, variáveis passadas para a página, opções do php.ini e muitas outras coisas.

phpinfo();

Masaru Hoshi - hoshi@hoshi.com.br