Copyright © 1997 - 2008 para o PHP Documentation Group. Este material pode ser distribuído apenas sob os termos e condições determinadas pela Open Publication Licence, versão 1.0 ou posteriores. Uma cópia da Open Publication License é distribuída com esse manual, e a úlima versão está atualmente disponível em » http://www.opencontent.org/openpub/.
A distribuição de versões substancialmente modificadas deste documento é proíbida sem a permissão explícita dos responsáveis pelo copyright.
A distribuição do trabalho ou de um trabalho derivado em qualquer formato comum de livro (papel) é proibida sem a permissão que pode ser obtida dos responsáveis pelo copyright.
Se você estiver interessado em redistribuir ou republicar este documento, no todo ou em parte, tanto modificao ou não, ou se você tem qualquer questão, basta contatar os responsáveis pelo copyright em » doc-license@lists.php.net. Note que esse endereço tem suas mensagens preservadas em um arquivo público.
A seção Zend Engine 1 é baseada em um material inicialmente cedido pela Zend Technologies.
PHP, que significa "PHP: Hypertext Preprocessor", é uma linguagem de programação de ampla utilização, interpretada, que é especialmente interessante para desenvolvimento para a Web e pode ser mesclada dentro do código HTML. A sintaxe da linguagem lembra C, Java e Perl, e é fácil de aprender. O objetivo principal da linguagem é permitir a desenvolvedores escreverem páginas que serão geradas dinamicamente rapidamente, mas você pode fazer muito mais do que isso com PHP.
Esse manual consiste primeiramente de uma referência de funções, mas ele também contém uma referência da linguagem, explicações sobre as mais importantes características do PHP, e outras informações suplementares.
Você pode fazer o download deste manual em vários formatos em » http://www.php.net/download-docs.php. Mais informações sobre como esse manual é desenvolvido podem ser encontradas no apêndice 'Sobre o manual'. Se você está interessado na história do PHP, veja o apêndice relevante.
Nós enfatizamos as pessoas mais ativas na capa do manual, mas há muitos mais colaboradores que atualmente nos ajudam no trabalho ou proveram uma enorme quantidade de ajuda no passado. Há uma enormidade de pessoas não citadas que ajudam com suas notas nas páginas do manual, que são continuamente inclúidas no corpo do manual, trabalho esse que nós somos muito gratos. A lista a seguir está em ordem alfabética.
Os seguintes colaboradores devem ser reconhecidos pelo impacto que tiveram e/ou continuam a ter pelo acréscimo de material ao manual: Bill Abt, Jouni Ahto, Alexander Aulbach, Daniel Beckham, Stig Bakken, Jesus M. Castagnetto, Ron Chmara, Sean Coates, John Coggeshall, Simone Cortesi, Markus Fischer, Wez Furlong, Sara Golemon, Rui Hirokawa, Brad House, Pierre-Alain Joye, Etienne Kneuss, Moriyoshi Koizumi, Rasmus Lerdorf, Andrew Lindeman, Stanislav Malyshev, Rafael Martinez, Rick McGuire, Yasuo Ohgaki, Derick Rethans, Rob Richards, Sander Roobol, Egon Schmid, Thomas Schoefbeck, Sascha Schumann, Dan Scott, Masahiro Takagi, Michael Wallner, Lars Torben Wilson, Jim Winstead, Jeroen van Wolffelaar e Andrei Zmievski.
Os seguintes colaboradores já fizeram um significativo trabalho editando esse manual: Stig Bakken, Gabor Hojtsy, Hartmut Holzgraefe e Egon Schmid.
Mantenedores mais ativos: Friedhelm Betz, Etienne Kneuss, Nuno Lopes, Hannes Magnusson, Felipe Pena e Maciek Sokolewicz.
Estas pessoas já fizeram um grande esforço cuidando das notas de usuários Mehdi Achour, Daniel Beckham, Friedhelm Betz, Victor Boivie, Jesus M. Castagnetto, Nicolas Chaillan, Ron Chmara, Sean Coates, James Cox, Vincent Gevers, Sara Golemon, Zak Greant, Szabolcs Heilig, Oliver Hinckel, Hartmut Holzgraefe, Rasmus Lerdorf, Matthew Li, Andrew Lindeman, Aidan Lister, Maxim Maletsky, Bobby Matthis, James Moore, Philip Olson, Sebastian Picklum, Derick Rethans, Sander Roobol, Damien Seguy, Jason Sheets, Tom Sommer, Jani Taskinen, Yasuo Ohgaki, Jakub Vrana, Lars Torben Wilson, Jim Winstead, Jared Wyles e Jeroen van Wolffelaar.
PHP (um acrônimo recursivo para "PHP: Hypertext Preprocessor") é uma linguagem de script open source de uso geral, muito utilizada e especialmente guarnecida para o desenvolvimento de aplicações Web embútivel dentro do HTML.
Ótimo, mas o que isso significa?
Exemplo #1 Um exemplo introdutório
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Exemplo</title>
</head>
<body>
<?php
echo "Olá, Eu sou um script PHP!";
?>
</body>
</html>
Ao invés de muitos comandos para mostrar HTML (como visto em C ou Perl),
páginas PHP contém HTML juntamente com códigos que fazem "alguma coisa"
(neste caso, mostra "Olá, Eu sou um script PHP!")
O código PHP é delimitado por tags iniciais e finais
<?php e ?>
que lhe permitem pular pra dentro e pra fora do "modo PHP".
O que distingui o PHP de algo como Javascript no lado do cliente é que o código é executado no servidor, gerando HTML que é então enviado para o cliente. O cliente receberia os resultados da execução desse script, mas não saberia como é o código fonte. Você pode inclusive configurar seu servidor para processar todos os seus arquivos HTML como PHP, e então não haverá nenhum modo dos usuários descobrirem que se você usa essa linguagem ou não.
A melhor coisa em usar PHP está no fato de ele ser extremamente simples para um iniciante, mas oferece muitos recursos para o programador profissional. Não se preocupe em ler as longas listas de funções do PHP. Você pode pular essa parte (por enquanto) e começar a escrever scripts em poucas horas.
Apesar do desenvolvimento do PHP ser focado nos scripts do lado do servidor, você pode fazer muito mais com ele. Veja isso e leia mais na seção O que o PHP pode fazer?, ou diretamente no tutorial introdutório se você estiver interessado em programação web.
Qualquer coisa. O PHP é focado para ser uma linguagem de script do lado do servidor, portanto, você pode fazer qualquer coisa que outro programa CGI pode fazer, como: coletar dados de formulários, gerar páginas com conteúdo dinâmico ou enviar e receber cookies. Mas o PHP pode fazer muito mais.
Esses são os maiores campos onde os scripts PHP podem ser utilizados:
O PHP pode ser utilizado na maioria dos sistemas operacionais, incluindo Linux, várias variantes Unix (incluindo HP-UX, Solaris e OpenBSD), Microsoft Windows, Mac OS X, RISC OS, e provavelmente outros. O PHP também é suportado pela maioria dos servidores web atuais, incluindo Apache, Microsoft Internet Information Server, Personal Web Server, Netscape and iPlanet Servers, Oreilly Website Pro Server, Caudium, Xitami, OmniHTTPd, e muitos outros. O PHP pode ser configurado como módulo para a maioria dos servidores, e para os outros como um CGI comum.
Com o PHP, portanto, você tem a liberdade para escolher o sistema operacional e o servidor web. Do mesmo modo, você pode escolher entre utilizar programação estrutural ou programação orientada a objeto, ou ainda uma mistura deles. Mesmo sem todos os recursos da POO (Programação Orientada a Objetos) implementados no PHP 4, muitas bibliotecas de código e grandes aplicações (incluindo a biblioteca PEAR) são escritas somente em código POO. O PHP 5 corrige as fraquezas da POO do PHP 4, e introduz um modelo de objetos completo.
Com PHP você não está limitado a gerar somente HTML. As habilidades do PHP incluem geração de imagens, arquivos PDF e animações Flash (utilizando libswf ou Ming) criados dinamicamente, on the fly. Você pode facilmente criar qualquer padrão texto, como XHTML e outros arquivos XML. O PHP pode gerar esses padrões e os salvar no sistema de arquivos, em vez de imprimi-los, formando um cache dinâmico de suas informações no lado do servidor.
Talvez a mais forte e mais significativa característica do PHP é seu suporte a uma ampla variedade de banco de dados. Escrever uma página que consulte um banco de dados é incrivelmente simples. Os seguintes bancos de dados são atualmente suportados:
Também foi providenciado uma abstração de banco de dados (chamada PDO) permitindo a você utilizar qualquer banco de dados transparentemente com sua extensão. Adicionalmente, o PHP suporta ODBC (Open Database Connection, ou Padrão Aberto de Conexão com Bancos de Dados), permitindo que você utilize qualquer outro banco de dados que suporte esse padrão mundial.
- Adabas D
- dBase
- Empress
- FilePro (read-only)
- Hyperwave
- IBM DB2
- Informix
- Ingres
- InterBase
- FrontBase
- mSQL
- Direct MS-SQL
- MySQL
- ODBC
- Oracle (OCI7 and OCI8)
- Ovrimos
- PostgreSQL
- SQLite
- Solid
- Sybase
- Velocis
- Unix dbm
O PHP também tem suporte para comunicação com outros serviços utilizando protocolos como LDAP, IMAP, SNMP, NNTP, POP3, HTTP, COM (em Windows) e incontáveis outros. Você pode abrir sockets de rede e interagir diretamente com qualquer protocolo. O PHP também suporta o intercâmbio de dados complexos WDDX, utilizado em virtualmente todas as linguagens de programação para web. Falando de comunicação, o PHP implementa a instanciação de objetos Java e os utiliza transparentemente como objetos PHP. Você ainda pode usar sua extensão CORBA para acessar objetos remotos.
O PHP é extremamente útil em recursos de processamento de texto, do POSIX Estendido ou expressões regulares Perl até como interpretador para documentos XML. No processamento de XML, o PHP 4 suporta os padrões SAX e DOM, além de você também poder utilizar a extensão XSL para transformar documentos XML. O PHP 5 padroniza toda a extensão XML a partir da base sólida da libxml2, além de estender os recursos com o acréscimo ao SimpleXML e XMLReader.
Por último mas longe de terminar, temos também outras extensões interessantes: funções para o search engine mnoGoSearch, funções para Gateway IRC, vários utilitários de compressão (gzip, bz2, zip), calendário e conversões de datas, tradução...
Como você pode ver, esta página não é suficiente para descrever todos os recursos e benefícios que o PHP pode oferecer. Leia nas seções sobre a Instalação do PHP, e veja a referência das funções para detalhes das extensões mencionadas aqui.
Aqui nós iremos mostrar o básico do básico do PHP em um curto tutorial. Este texto fala somente sobre a criação de páginas dinâmicas com o PHP, visto que o PHP pode criar mais do que somente webpages. Veja a seção entitulada O que o PHP pode fazer para mais informações.
Fazer páginas com PHP é o mesmo que criar páginas HTML e você pode criá-las e editá-las da mesma maneira que faz com suas páginas HTML normal.
Neste tutorial nós presumimos que seu servidor tem suporte ao PHP ativado e que todos os arquivos terminam com a extensão .php são tratados pelo PHP. Na maioria dos servidores esta é a extensão padrão para os arquivos PHP, mas pergunte ao seu administrador só para ter certeza. Se o seu servidor suporta PHP então você não precisa fazer mais nada. Apenas crie seus arquivos .php e coloque-os no seu diretório web e o servidor irá com um passe de mágica mostrar suas páginas PHP. Não há nenhuma necessidade de compilação para qualquer ferramenta extra. Pense nesses arquivos PHP como se eles fossem páginas HTML com algumas tags à mais que deixaram você fazer coisas mais interessantes do que somente páginas HTML estáticas.
Digamos que você quer salvar sua preciosa conexão e desenvolver tudo localmente. Neste caso, você precisará instalar um servidor web, como o » Apache, e claro o » PHP. Você também irá querer instalar uma base de dados, como por exemplo o » MySQL. Você pode instalá-los separadamente ou pelo jeito mais simples que é » usar os pacotes pré-configurados. que irão instalar automaticamente todas as coisas com apenas alguns cliques. É super fácil configurar um servidor web com suporte ao PHP em qualquer sistema operacional, incluindo Linux e Windows. No Linux, você deve procurar o » rpmfind que é muito útil na localização de pacotes RPM.
Crie um novo arquivo chamado ola.php e coloque-o em seu diretório root do seu servidor web (DOCUMENT_ROOT) com o seguinte conteúdo:
Exemplo #1 Nosso primeiro script PHP: ola.php
<html>
<head>
<title>PHP Teste</title>
</head>
<body>
<?php echo "<p>Olá Mundo</p>"; ?>
</body>
</html>
Use o seu navegador para acessar o arquivo pelo endereço de seu servidor web, ao final do endereço coloque o arquivo "/ola.php" como referência. Quando o desenvolvimento é local você usará uma url como esta http://localhost/ola.php ou http://127.0.0.1/ola.php mas dependendo da configuração do seu servidor web. Entretanto isto está fora do escopo deste tutorial, veja também as diretivas DocumentRoot e ServerName dos arquivos de configuração do seu servidor web. (no Apache o nome do arquivo é httpd.conf). Se tudo foi configurado corretamente, o arquivo irá ser interpretado pelo PHP e irá mostrar a seguinte mensagem de saída no seu navegador:
<html> <head> <title>PHP Teste</title> </head> <body> <p>Olá Mundo</p> </body> </html>
Note que isto não é como em um script CGI. O arquivo não precisa ser executável ou especial em nenhum aspecto. Pense nesse arquivo como um arquivo HTML normal mas com a diferença que ele pode conter algumas tags especiais à mais que permitem à você fazer coisas mais interessantes do que somente páginas HTML estáticas.
Este exemplo é extremamente simples e você realmente não precisa usar o PHP para criar uma página como esta. Tudo o que ele faz é mostrar uma mensagem Olá Mundo usando a declaração echo() do PHP.
Se você tentar rodar este exemplo e ele não mostrar nenhuma mensagem de saída, ou aparecer uma caixa de diálogo pedindo para você salvar o arquivo, ou você ver o arquivo em formato de texto, há uma grande chance do seu servidor não ter o PHP habilitado. Peça ao seu administrar para habilitar o PHP para você usando o capítulo de Instalação do manual. Se você está desenvolvendo localmente, também leia o capítulo indicado acima para ter certeza de que configurou tudo corretamente. Se os problemas continuarem à persistir, não hesite em usar uma das várias formas de » ajuda que o PHP pode lhe oferecer.
O objetivo do exemplo é mostrar o formato especial das tags do PHP. Neste exemplo nós usamos <?php para indicar que à partir daquele ponto começa um código PHP. Então nós colocamos uma declaração de fechamento para indicar que o script PHP acabou, usando a tag ?>. Você pode usar o PHP em qualquer parte do seu código HTML, e também pode usar várias tags de abertura e fechamento no mesmo arquivo. Para mais detalhes, leia a seção do manual que fala da sintaxe básica do PHP.
Nota: Uma Nota sobre os Editores de Texto Há muitos editores de textos e Integrated Development Enviroments (IDEs) que você pode usar para criar, editar e gerenciar arquivos PHP. Uma lista parcial destas ferramentas pode ser vista na » Lista de Editores para PHP. Se você gostaria de recomendar algum editor, por favor visite o endereço acima e pergunte à gerenciador do site para adicionar o seu editor à lista. Ter um editor que colore as sintaxes das tags pode ser muito útil.
Nota: Uma Nota sobre os Processadores Word Processadores Word como o StarOffice Write, Microsoft Word e Abiword não são boas escolhas para editar arquivos PHP. Se você deseja usar um desses para testar seus scripts, você precisa verificar se você está salvando os arquivos como TEXTO PLANO ou o PHP não irá ser capaz de ler e executar o seu script.
Nota: Uma Nota sobre o Bloco de Notas do Windows Se você está escrevendo seus scripts PHP usando o Bloco de Notas do Windows, você precisará verificar que os arquivos estão sendo salvos com a extensão .php. (O Bloco de Notas do Windows adiciona automaticamente a extensão .txt aos arquivos à não ser que você siga um dos passos a seguir para previnir isto). Quando a caixa de diálogo Salvar estiver aberta e você for digitar o nome do seu arquivo, coloque o nome do arquivo entre aspas (i.e. "ola.php"). Uma alternativa, é você clicar na lista drop-down 'Documentos de Texto' na caixa de diálogo salvar e alterar para "Todos os tipos de arquivos". Você agora pode digitar o nome do seu arquivo sem usar as aspas.
Agora que você criou com sucesso um script simples em PHP, é hora de criar o mais famoso dos scripts PHP! Uma chamada à função phpinfo() e você verá todas as informações sobre seu sistema e configurações disponíveis como a de Variáveis Pré-definidas, módulos carregados pelo PHP, e as opções de configuração. Tire algum tempo para ver e rever estas importantes informações.
Vamos fazer alguma coisa um pouco mais útil agora. Nós iremos checar qual é o tipo de navegador que o visitante está utilizando para ver a nossa página. De fato, para fazer isto nós teremos que checar qual é o valor da string agente que o navegador envia como parte de sua requisição HTTP. Esta informação é armazenada em uma variável. Variáveis sempre começam com um símbolo de cifrão no PHP. A variável que nos interessa no momento é a $_SERVER["HTTP_USER_AGENT"].
Nota: Nota sobre as Auto-Globais do PHP $_SERVER é uma variável especial reservada do PHP que contém todas as informações sobre o servidor web. Ela é conhecida como uma Auto-Global (ou Superglobal). Veja a página do manual relacionada as Auto-globais para mais informações. Estas variáveis especiais foram introduzidas no PHP » 4.1.0. Antes desta versão, nós usávamos os velhos arrays $HTTP_*_VARS, como o $HTTP_SERVER_VARS. Entretanto, este estilo antingo foi removido, porém ainda existem. (Veja a nota sobre códigos antigos.)
Para chamar esta variável, nós podemos fazer isto:
Exemplo #1 Imprimindo a variável (Elemento Array)
<?php echo $_SERVER["HTTP_USER_AGENT"]; ?>
Um exemplo de saída deste script poderia ser:
Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)
Há muitos tipos de variáveis disponíveis no PHP. No exemplo acima nós escrevemos um elemento Array. Arrays podem ser muito úteis.
$_SERVER é somente uma variável que é automaticamente disponibilizada para você pelo PHP. Uma lista de Variáveis Reservadas pode ser vista na seção Variáveis Reservadas do manual ou você pode pegar uma lista completa delas criando um arquivo como este:
Exemplo #2 Exibindo todas as variáveis pré-definidas usando a função phpinfo()
<?php phpinfo(); ?>
Se você carregar este arquivo no seu navegador você irá ver uma página com todas as informações sobre o PHP junto com uma lista de todos os tipos de variáveis disponíveis para você.
Você pode colocar mútiplas declarações PHP dentro da tag PHP e criar pequenos blocos de códigos que faem muito mais do que um simples echo. Por exemplo, se você quer checar se o navegador é o Internet Explorer faça algo como isso:
Exemplo #3 Exemplo usando controles de declarações e funções
<?php
if (strstr($_SERVER["HTTP_USER_AGENT"], "MSIE")) {
echo "Você está usando o Internet Explorer<br />";
}
?>
Um exemplo de Saída seria:
Você está usando o Internet Explorer<br />
Aqui nós mostraremos alguns novos conceitos. Nós temos a declaração if. SE você é familiar com a sintaxe básica usada pela linguagem C isto parecerá ser lógico para você. Se você não conhece a linguagem C ou alguma outra linguagem onde a sintaxe usada acima é usada, você provavelmente precisará de um livro introdutório sobre o PHP, dê uma lida nos primeiros capítulos do livro, ou leia a parte sobre a Referência da Linguagem no manual. Você pode encontrar uma lista de livros sobre PHP em at » http://www.php.net/books.php.
O segundo conceito que iremos abordar é a chamada à função strstr(). A função strstr() é trazida junto com o PHP, ela faz uma busca em uma palavra por uma outra palavra. Neste caso nós procuramos pela palavra "MSIE" dentro de $_SERVER["HTTP_USER_AGENT"]. Se a palavra for encontrada, a função returna TRUE e se ela não for encontrada a função retorna FALSE. Se o retorno for TRUE, a declaração if ocorre e o código dentro dela é executado. Caso contrário, o código não é executado. Sinta-se à vontade para criar exemplos similares com o if, else, e outras funções como a strtoupper() e strlen(). Cada uma delas está no manual com seus respectivos exemplos.
Nós podemos avançar agora e mostrar à você como alternar entre os modos PHP mesmo que você esteja executando blocos de códigos:
Exemplo #4 Mesclando entre os modos PHP e HTML
<?php
if (strstr($_SERVER["HTTP_USER_AGENT"], "MSIE")) {
?>
<h3>strstr retorna verdadeiro</h3>
<center><b>Você está usando o Internet Explorer</b></center>
<?php
} else {
?>
<h3>strstr retorna falso</h3>
<center><b>Você não está usando o Internet Explorer</b></center>
<?php
}
?>
Um exemplo de saída deste script poderia ser:
<h3>strstr retorna verdadeiro</h3> <center><b>Você está usando o Internet Explorer</b></center>
Ao invés de usar a declaração echo do PHP para imprimir a saída dos dados, nós saímos do modo do PHP e usamos o HTML normal. O importante à notar aqui é que a lógica do script continua intacta. Somente alguns blocos HTML será enviados de acordo com o que a declaração strstr() retornar, ou seja TRUE ou FALSE. Em outras palavras, se a palavra MSIE for encontrada ou não.
Uma das características mais fortes do PHP é o jeito como ele trata formulários HTML. O conceito básico que é importante entender é que qualquer elemento de formulário em um formulário irá automaticamente ficar disponível para você usá-los em seus scripts PHP. Por favor leia a seção Variáveis externas do PHP para mais informaçõess exemplos de como usar formulários com PHP. Aqui vai um exemplo:
Exemplo #1 Um simples formulário HTML
<form action="acao.php" method="POST"> Seu nome <input type="text" name="nome" /> Sua idade: <input type="text" name="idade" /> <input type="submit"> </form>
Não há nada de especial neste formulário. É um formulário HTML comum sem nenhuma tag especial de qualquer tipo. Quando o usuário preencer este formulário e clicar no botão enviar, a página action.php é chamada. Neste arquivo nós teremos algo como este:
Exemplo #2 Imprimindo dados de nosso formulário
Oi <?php echo $_POST["nome"]; ?>.
Você tem <?php echo $_POST["idade"]; ?> anos.
Um exemplo de saída deste script seria:
Oi Thomas. Você tem 18 anos.
É óbvio o que este script faz. Não há nada de mais nele. As variáveis $_POST["nome"] e $_POST["idade"] são automaticamente criadas para você pelo PHP. Antigamente nós usávamos a auto-global $_SERVER, agora nós simplesmente usamos a auto-global $_POST que contém todos os dados vindos do POST. Se você usar o método GET então nossas informações residirão na auto-global $_GET. Você também pode usar a auto-global $_REQUEST se você não se importa com o tipo de dados que vêm do seu formulário. Esta auto-global contém uma mescla de GET, POST, COOKIE e FILE. Veja também a função import_request_variables().
Agora que o PHP cresceu e é uma linguagem de script popular, há muitos recursos por ai que fazem uma listagem de códigos que você pode reusar em seus próprios scripts. Para a maioria dos desenvolvedores da linguagem PHP tentaram manter a compatibilidade, para que um script escrito em uma versão antiga do PHP, pude-se (deveria) rodar sem nenhuma alteração em uma versão mais nova do PHP, em prática algumas alterações serão geralmente necessárias.
Duas das coisas mais importantes recentemente alteradas que afetam um código antigo é:
Com o que você sabe agora você deverá estar apto à entender a maioria do manual e também os vários exemplos de scripts disponíveis no arquivo de exemplos. Você também pode encontrar outros exemplos nos sites do php.net e nos links da seção: » http://www.php.net/links.php.
Antes de começar a instalar o PHP, primeiro você deve saber o que você deseja fazer com ele. Existem três principais formas de se usar o PHP, como descrito na seção O que o PHP pode fazer? do manual:
Para a primeira forma, e mais comum, você precisa de três coisas: o prório PHP, um servidor web e um cliente (browser) web. Você provavelmente já tem um browser, e dependendo da configuração do seu sistema operacional, vocêo pode tambem ter um servidor web (Ex.: Apache no Linux e MacOS X; IIS no Windows). Você também pode alugar um host em uma companhia qualquer. Dessa maneira, você não precisa configurar nada por conta própria, apenas escrever os seus scripts PHP, enviar (upload) para o servidor que você alugou, e ver os resultados no seu browser.
No caso de você instalar o servidor e o PHP por contra própria, você tem duas escolhas para o método de conexão do PHP com o servidor. Para muitos servidores o PHP tem uma interface direta de módulo (também chamada de SAPI). Entre esses servidores estão Apache, Microsoft Internet Information Server, Netscape e iPlanet. Muitos outros servidores têm suporte para ISAPI, a interface de módulo da Microsoft (OmniHTTPd por exemplo). Se o PHP não tiver suporte de módulo para o seu servidor web, você também pode usá-lo como processador CGI ou FastCGI. Isso significar configurar seu servidor para usar executáveis CGI do PHP para processar todas as requisições à arquivos PHP no servidor.
Se você também estiver interessado em usar o PHP para criar scripts em linha de comandos (Ex.: criar scripts que geram imagens enquanto estão offline, ou processar arquivos de texto dependendo de alguns argumentos que você passar ao script), você pode precisar do executável de linha de comando. Para mais informações, leia a seção sobre criando aplicações de linha de comando com o PHP. Nesse caso, vocêo não precisa de servidor nem de um browser.
Com o PHP, você também pode criar aplicações para desktop com interface gráfica (GUI) usando a extenção PHP-GTK. Isso é uma abordagem completamente diferente da criação de páginas web, já que a saída não é em HTML, mas o manuseio de janelas e objetos dentro delas. Para mais informações sobre PHP-GTK, por favor » visite o site dedicado à essa extensão. PHP-GTK não é inclusa na distribuição oficial do PHP.
Por enquanto, essa seção trata da instalação do PHP em servidores web no Unix e Windows como módulos dos servidores e executáveis CGI. Você também pode encontrar inforamação sobre executáveis de linha de comando nas seções seguintes.
O código fonte do PHP e distribuições binárias para Windows podem ser encontradas em » http://www.php.net/downloads.php. Nós recomentandos que você escolha um » mirror mais próximo de vocêo para baixar as distribuições.
Essa seção é um guia geral para configuração e instalação do PHP em sistemas Unix. Verifique se existe uma seção específica para usa plataforma ou servidor web antes de começar o processo.
Como nosso manual destaca na seção Considerações Gerais sobre Instalação, nós estamos lidando principalmente com configurações web do PHP nessa seção, embora cobriremos instalação do PHP para uso em linha de comando também.
Existem várias maneiras de instalar o PHP para a plataforma Unix, ou com um processo de compilar e configurar, ou atráves de vários métodos pré-empacotados. Essa documentação é focada principalmente no processo de compilação e configuração do PHP. Muitos sistemas baseados no Unix tem alguma forma de sistema de instalação de pacotes. Isso pode ajudar na instalação de uma configuração padrão, mas se você precisar ter uma série de características diferentes (como um servidor seguro, ou um driver de banco de dados diferente), você pode precisar montar o PHP e/ou servidor web. Se você não estiver familiarizado com o processo de montar e compilar seu próprio software, vale a pena checar se alguém já montou um pacote do PHP com as características que você precisa.
Pré-requisitos de software e de conhecimento para compilar:
O processo inicial de configuração de instalação do PHP é controlado pelo uso de opções de linha de comando do script configure. Você pode pegar a lista de todas as opções disponíveis junto com uma pequena explicação executando o comando ./configure --help. Nosso manual documenta as diferentes opções separadamente. Você encontrará as opções principais no apêndice, enquanto as opções específicas das diferentes extensões são descritas nas páginas de referência.
Quando o PHP é configurado, você está pronto para montá-lo como módulo e/ou executável. O comando make deve tomar conta disso. Se ele falhar e você não conseguir descobrir a razão, veja a Seção de Problemas.
Essa seção contem notas e dicas específicas para a instação do Apache e do PHP em plataformas Unix. Também temos instruções e notas para o Apache 2 em uma página separada.
Você pode selecionar argumentos para adicionar ao configure na linha 10 abaixo através da Lista completa de opções do configure e das opções específicas das extensões em seus respectivos lugares no manual. Os números de versões foram omitidos aqui, para assegurar que as instruções não estejam incorretas. Você deverá trocar o 'xxx' aqui com os valores corretos dos seus arquivos.
Exemplo #1 Instruções de Instalação (Apache Versão de Módulo Compartilhado) para PHP
1. gunzip apache_xxx.tar.gz 2. tar -xvf apache_xxx.tar 3. gunzip php-xxx.tar.gz 4. tar -xvf php-xxx.tar 5. cd apache_xxx 6. ./configure --prefix=/www --enable-module=so 7. make 8. make install 9. cd ../php-xxx 10. Agora, configure o seu PHP. É aqui que você personaliza seu PHP com várias opções, como quais extensões serão habilitadas. Execute o comando ./configure --help para uma lista das opções disponíveis. No nosso exemplo nós faremos uma simples configuração com Apache 1 e suporte ao MySQL. Seu caminho para o arquivo apxs pode ser diferente do exemplo. ./configure --with-mysql --with-apxs=/www/bin/apxs 11. make 12. make install Se você decidir mudar as opções de seu configure depois da instalação você precisará somente repetir os últimos 3 passos. Você somente precisará reiniciar o Apache para o novo módulo funcionar. Não será necessário recompilar o Apache. Note que, por padrão, 'make install' também instalará PEAR, além de várias ferramentas do PHP como phpize, instalar o CLI do PHP e mais. 13. Configurando seu arquivo php.ini: cp php.ini-dist /usr/local/lib/php.ini Você pode editar o seu arquivo .ini para configurar as opções do PHP. Se você preferir que este arquivo fique em outro lugar, use a opção --with-config-file-path=/caminho no passo 10. Se ao invés de escolher o arquivo php.ini-dist, você escolher o arquivo php.ini-recommended, leia a lista de mudanças dentro do mesmo, uma vez que elas afetam a maneira como o PHP se comporta. 14. Edite o seu arquivo httpd.conf para carregar o módulo do PHP. O caminho no lado direito do comando LoadModule deve apontar para para o caminho do módulo PHP no seu sistema. O comando make install acima já deve ter adicionado estas linhas, mas tenha certeza de que as linhas abaixo foram adicionadas ao arquivo. Para o PHP 4: LoadModule php4_module libexec/libphp4.so Para o PHP 5: LoadModule php5_module libexec/libphp5.so 15. Em seguida, na seção AddModule do arquivo httpd.conf, em algum lugar abaixo de ClearModuleList, adicione isto: Para o PHP 4: AddModule mod_php4.c Para o PHP 5: AddModule mod_php5.c 16. Diga ao Apache para avaliar certas extensões como PHP. Por exemplo, vamos fazer o Apache interpretar a extensão .php como um script PHP. Você poderia ter qualquer extensão(ões) avaliadas como PHP simplesmente adicionando-as, com cada uma separada por um espaço. Vamos adicionar .phtml para demonstrar. AddType application/x-httpd-php .php .phtml Também é comum configurar a extensão .phps para mostrar o código-fonte do script PHP com highlight, isso pode ser feito com: AddType application/x-httpd-php-source .phps 17. Use seu procedimento normal para iniciar o servidor Apache. (Você deve parar e reiniciar o servidor, não somente fazer um reinício enviando um sinal HUP ou USR1.)
Outra maneira é instalar o PHP como um objeto estático:
Exemplo #2 Instruções de Instalação (Instalação como módulo estático do Apache) para o PHP
1. gunzip -c apache_1.3.x.tar.gz | tar xf - 2. cd apache_1.3.x 3. ./configure 4. cd .. 5. gunzip -c php-5.x.y.tar.gz | tar xf - 6. cd php-5.x.y 7. ./configure --with-mysql --with-apache=../apache_1.3.x 8. make 9. make install 10. cd ../apache_1.3.x 11. ./configure --prefix=/www --activate-module=src/modules/php5/libphp5.a (A linha acima está correta! Sim, sabemos que libphp4.a não existe nesse estágio. E nem deveria. Ele será criado.) 12. make (você deve agora ter um binário httpd que você pode copiar para o diretório bin do Apache. Se for sua primeira instalação então você precisa executar "make install" também) 13. cd ../php-5.x.y 14. cp php.ini-dist /usr/local/lib/php.ini 15. Você pode editar o arquivo /usr/local/lib/php.ini para editar as opçso do PHP. Edite o seu arquivo httpd.conf ou srm.conf e adicione: AddType application/x-httpd-php .php
Nota: Substitua php-5 por php-4 e php5 por php4 no PHP 4.
Dependendo da sua instalação do Apache e das variações Unix, existem inúmeras maneiras possíveis de parar e reiniciar o servidor. Abaixo estão algumas linhas típicas usadas para reiniciar e o servidor, para instalações de versões de apache/unix. Você deve trocar /caminho/para/ pelo caminho destas aplicações nos seus sistemas.
Exemplo #3 Exemplo de comandos para reinicialização do Servidor Apache
1. Várias distribuições Linux e variantes do SysV: /etc/rc.d/init.d/httpd restart 2. Usando os scripts apachectl: /path/to/apachectl stop /path/to/apachectl start 3. httpdctl and httpsdctl (Usando OpenSSL), igual ao apachectl: /path/to/httpsdctl stop /path/to/httpsdctl start 4. Usando mod_ssl, ou outro servidor SSL, você pode querer iniciar ou reiniciar manualmente: /path/to/apachectl stop /path/to/apachectl startssl
As localizações dos binários apachectl e http(s)dctl geralmente variam. Se o seu sistema tem os comandos locate ou whereis ou which, estem podem lhe ajudar a encontrar os programas de controle do servidor.
Exemplos diferentes de compilação do PHP para apache estão a seguir:
./configure --with-apxs --with-pgsql
Isso criará uma biblioteca compartilhada libphp5.so (ou libphp4.so no PHP 4) que é carregada pelo Apache ao adicionar uma linha LoadModule no arquivo httpd.conf do Apache. O suporte ao PostgreSQL é embutido nessa biblioteca.
./configure --with-apxs --with-pgsql=shared
Isto irá criar uma biblioteca compartilhada libphp4.so para o Apache, mas isto também criará uma biblioteca compartilhada pgsql.so que é carregada com o PHP tanto ao usar a diretiva de extensão no arquivo php.ini ou então carregando ela explícitamente no script usando a função dl().
./configure --with-apache=/path/to/apache_source --with-pgsql
Isto irá criar uma biblioteca libmodphp5.a, o arquivo mod_php5.c e vários arquivos dependentes e copiará eles para o diretório src/modules/php5 na árvore de diretório do código fonte do Apache. Então você compilará o Apache usando a opção --activate-module=src/modules/php5/libphp5.a e o sistema de compilação do Apache irá criar o arquivo libphp5.a e fará um link estático dentro do binário httpd (substitua php5 por php4 no PHP 4). O suporte ao PostgreSQL estará incluído diretamente neste binário httpd, então o resultado final aqui será um único arquivo binário httpd que incluirá tudo do Apache e tudo do PHP.
./configure --with-apache=/path/to/apache_source --with-pgsql=shared
Mesmo que o anterior, exceto em vez de incluir o suporte ao PostgreSQL diretamente no binário httpd você terá uma biblioteca compartilhada pgsql.so que você poderá carregar com o PHP tanto do arquivo php.ini ou diretamente usando a função dl().
Quanto estiver decidindo compilar o PHP com maneiras diferentes, você deverá considerar as vantages e disvantagens de cada método. Complilando como uma biblioteca compartilhada significará que você poderá compilar o apache separadamente, e não terá que recompilar tudo quando quiser adicionar ou mudar o seu PHP. compilando o PHP dentro do apache (método estático) significará que o PHP irá carregar e rodar rapidamente. Para maiores informações, veja a página web do Apache que fala sobre » Suporte a Objetos Dinâmicos Compartilhados.
Nota: O arquivo httpd.conf padrão do Apache atualmente já contém uma seção que se parece com isso:
A menos que você mude isto para "Group nogroup" ou algo assim ("Group daemon" é também muito comum) o PHP não estará apto a abrir arquivos.User nobody Group "#-1"
Nota: Tenha certeza de especificar a versão instalada do apxs quando usar a opção --with-apxs=/caminho/para/apxs. Você NÂO deverá usar a versão do apxs que está nos fontes do apache e sim a que está atualmente instalada no seu sistema.
Essa seção contém notas e dicas específicas para a instalação do Apache 2.0 com o PHP em sistemas Unix.
Nós não recomendamos a utilização de um threaded MPM em produção com o Apache2. Use ao invés prefork MPM, ou use Apache1. para informações sobre o motivo, leia este faq sobre usando Apache2 com um threaded MPM
Recomendamos a » Documentação do Apache para obter um entendimento básico do servidor Apache 2.0.
Nota: Notas de compatibilidade do PHP e Apache 2.0.x As seguintes versões do PHP são compatíveis com a versão mais recente do Apache 2.0.x:
Essas versões do PHP são compatíveis com Apache 2.0.40 ou superior.
- PHP 4.3.0 ou superior, disponível em » http://www.php.net/downloads.php.
- A última versão estável de desenvolvimento. Pegue o código fonte » http://snaps.php.net/php5-latest.tar.gz ou baixe os binários para o Windows » http://snaps.php.net/win32/php5-win32-latest.zip.
- Uma versão pre-release disponível para download em » http://qa.php.net/.
- Você sempre tem a opção de obter o PHP através da conta » anônima do CVS.
Suporte a SAPI do Apache 2.0 começou no PHP 4.2.0. PHP 4.2.3 funciona com Apache 2.0.39, não use qualquer outra versão de Apache com PHP 4.2.3. No entando, a configuração recomendada é usar o 4.3.0 ou superior com a versão mais recente do Apache2.
Todas as versões mencionadas do PHP ainda funcionarão com Apache 1.3.x.
Baixe a versão mais recente do » Apache 2.0 e uma versão adequada do PHP dos lugares mencionados acima. Esse guia rápido cobre apenas o básico para para começar a usar o Apache 2.0 e o PHP. Para mais informação, leia a » Documentação do Apache Os número de versão foram omitidos para assegurar que as instruções não estejam incorretas. Você precisará substituir o 'NN' com os valores corretos dos seus arquivos.
Exemplo #1 Instruções de Instalação (Versão de Módulo Compartilhado do Apache 2)
1. gzip -d httpd-2_0_NN.tar.gz 2. tar xvf httpd-2_0_NN.tar 3. gunzip php-NN.tar.gz 4. tar -xvf php-NN.tar 5. cd httpd-2_0_NN 6. ./configure --enable-so 7. make 8. make install Agora você tem o Apache 2.0.NN disponível no diretório /usr/local/apache2, configurado com suporte a módulo compartilhado e o prefork MPM padrão. Para testar a instalação use o procedimento normal para iniciar o servidor Apache, ex.: /usr/local/apache2/bin/apachectl start e pare o servidor para ir para a configuração do PHP: /usr/local/apache2/bin/apachectl stop. 9. cd ../php-NN 10. Agora, configure o seu PHP. É aqui que você personaliza seu PHP com várias opções, como quais extensões serão habilitadas. Execute o comando ./configure --help para uma lista das opções disponíveis. No nosso exemplo nós faremos uma simples configuração com Apache 2 e suporte ao MySQL. Seu caminho para o arquivo apxs pode ser diferente do exemplo. De fato, o binário pode até ser chamado de apxs2 no seu sistema. ./configure --with-apxs2=/usr/local/apache2/bin/apxs --with-mysql 11. make 12. make install Se você decidir mudar as opções de seu configure depois da instalação você precisará somente repetir os últimos 3 passos. Você somente precisará reiniciar o Apache para o novo módulo funcionar. Não será necessário recompilar o Apache. Note que, por padrão, 'make install' também instalará PEAR, além de várias ferramentas do PHP como phpize, instalar o CLI do PHP e mais. 13. Configurando seu arquivo php.ini: cp php.ini-dist /usr/local/lib/php.ini Você pode editar o seu arquivo .ini para configurar as opções do PHP. Se você preferir que este arquivo fique em outro lugar, use a opção --with-config-file-path=/caminho no passo 10. Se ao invés de escolher o arquivo php.ini-dist, você escolher o arquivo php.ini-recommended, leia a lista de mudanças dentro do mesmo, uma vez que elas afetam a maneira como o PHP se comporta. 14. Edite o seu arquivo httpd.conf para carregar o módulo do PHP. O caminho no lado direito do comando LoadModule deve apontar para para o caminho do módulo PHP no seu sistema. O comando make install acima já deve ter adicionado estas linhas, mas tenha certeza de que as linhas abaixo foram adicionadas ao arquivo. Para o PHP 4: LoadModule php4_module libexec/libphp4.so Para o PHP 5: LoadModule php5_module libexec/libphp5.so 15. Diga ao Apache para avaliar certas extensões como PHP. Por exemplo, vamos fazer o Apache interpretar a extensão .php como um script PHP. Você poderia ter qualquer extensão(ões) avaliadas como PHP simplesmente adicionando-as, com cada uma separada por um espaço. Vamos adicionar .phtml para demonstrar. AddType application/x-httpd-php .php .phtml Também é comum configurar a extensão .phps para mostrar o código-fonte do script PHP com highlight, isso pode ser feito com: AddType application/x-httpd-php-source .phps 16. Use seu procedimento normal para iniciar o servidor Apache ex.: /usr/local/apache2/bin/apachectl start
Seguindo os passos acima você terá rodando o Apache 2.0 com suporte para o PHP como um módulo SAPI. Claro que existem muitas outras opções de configuração disponível para ambos, Apache e o PHP. Para mais informações use o comando ./configure --help na árvore de arquivos fontes correspondente. Caso você desejar compilar uma versão multithreaded do Apache 2.0, você deve sobrescrever o Módulo-MPM padrão prefork ou com o módulo worker ou com o perchild. Para fazer isso, acrescente ao comando configure no passo 6 acima a opção --with-mpm=worker ou --with-mpm=perchild. Tome cuidado com as consequências e entenda o que está fazendo. Para mais informações, leia a documentação do Apache sobre os » Módulos-MPM.
Nota: Se você quiser usar negociação de conteúdo, leia o FAQ relacionado à MultiViews.
Nota: Para compilar uma versão multithreaded do Apache, seu sistema deve suportar threads. Isso também implica compilar o PHP com o Zend Thread Safety (ZTS) experimental. Portanto, nem todas as extensões podem estar disponíveis. A configuração recomendada para compilar o Apache é com o Módulo-MPM prefork padrão.
This section contains notes and hints specific to Lighttpd 1.4 installs of PHP on Unix systems.
Please use the » Lighttpd trac to learn how to install Lighttpd properly before continuing.
Fastcgi is the preferred SAPI to connect PHP and Lighttpd. Fastcgi is automagically enabled in php-cgi in PHP5.3, but for older versions configure php with --enable-fastcgi. To confirm that PHP has fastcgi enabled, php -v should contain PHP 5.2.5 (cgi-fcgi) Before PHP 5.2.3, fastcgi was enabled on the php binary (there was no php-cgi).
To configure Lighttpd to connect to php and spawn fastcgi processes, edit lighttpd.conf. Sockets are preferred to connect to fastcgi processes on the local system.
Exemplo #1 Partial lighttpd.conf
server.modules += ( "mod_fastcgi" ) fastcgi.server = ( ".php" => (( "socket" => "/tmp/php.socket", "bin-path" => "/usr/local/bin/php-cgi", "bin-environment" => ( "PHP_FCGI_CHILDREN" => "16", "PHP_FCGI_MAX_REQUESTS" => "10000" ) "min-procs" => 1, "max-procs" => 1, "idle-timeout" => 20 )) )
The bin-path directive allows lighttpd to spawn fastcgi processes dynamically. PHP will spawn children according to the PHP_FCGI_CHILDREN environment variable. The "bin-environment" directive sets the environment for the spawned processes. PHP will kill a child process after the number of requests specified by PHP_FCGI_MAX_REQUESTS is reached. The directives "min-procs" and "max-procs" should generally be avoided with PHP. PHP manages its own children and opcode caches like APC will only share among children managed by PHP. If "min-procs" is set to something greater than 1, the total number of php responders will be multiplied PHP_FCGI_CHILDREN (2 min-procs * 16 children gives 32 responders).
Lighttpd provides a program called spawn-fcgi to ease the process of spawning fastcgi processes easier.
It is possible to spawn processes without spawn-fcgi, though a bit of heavy-lifting is required. Setting the PHP_FCGI_CHILDREN environment var controls how many children PHP will spawn to handle incoming requests. Setting PHP_FCGI_MAX_REQUESTS will determine how long (in requests) each child will live. Here's a simple bash script to help spawn php responders.
Exemplo #2 Spawning FastCGI Responders
#!/bin/sh # Location of the php-cgi binary PHP=/usr/local/bin/php-cgi # PID File location PHP_PID=/tmp/php.pid # Binding to an address #FCGI_BIND_ADDRESS=10.0.1.1:10000 # Binding to a domain socket FCGI_BIND_ADDRESS=/tmp/php.sock PHP_FCGI_CHILDREN=16 PHP_FCGI_MAX_REQUESTS=10000 env -i PHP_FCGI_CHILDREN=$PHP_FCGI_CHILDREN \ PHP_FCGI_MAX_REQUESTS=$PHP_FCGI_MAX_REQUESTS \ $PHP -b $FCGI_BIND_ADDRESS & echo $! > "$PHP_PID"
Fastcgi instances can be spawned on multiple remote machines in order to scale applications.
Exemplo #3 Connecting to remote php-fastcgi instances
fastcgi.server = ( ".php" => (( "host" => "10.0.0.2", "port" => 1030 ), ( "host" => "10.0.0.3", "port" => 1030 )) )
O PHP pode ser compilado como um módulo do Pike para o » servidor web Caudium. Siga as instruções abaixo para instalar o PHP 4 para o Caudium.
Exemplo #1 Instruções de Instalação para o Caudium
1. Verifique que você tem o Caudium instalado antes de tentar instalar o PHP 4. Para que o PHP funcione corretamente, você precisará do Pike 7.0.268 ou superior. Nesse exemplo, presumiremos que o Caudium foi instalado no diretório /opt/caudium/server/. 2. Mude para o diretório php-x.y.z (onde x.y.z é o número da versão). 3. ./configure --with-caudium=/opt/caudium/server 4. make 5. make install 6. Reinicie o Caudium se ele estiver sendo executado. 7. Entre na interface gráfica de configuração e vá no servidor virtual (virtual server) onde você adicionará suporte ao PHP 4. 8. Clique em Adicionar Módulo (Add Module) e localize e depois adicione o módulo PHP 4 Script Support. 9. Se a documentação disser que o 'O interpretador do PHP não está disponível', verifique que você reiniciou o servidor. Se você verificou, procure em /opt/caudium/logs/debug/default.1 por algum erro relacionado à <filename>PHP4.so</filename>. Também certifique-se que o arquivo <filename>caudium/server/lib/[pike-version]/PHP4.so</filename> está presente. 10. Configure o módulo do PHP se necessário.
Você pode, é claro, compilar o módulo do Caudium com suporte para as várias extensões disponíveis no PHP 4. Veja as páginas de referência por opções específicas para a extensão que você deseja.
Nota: Quando compilar o PHP 4 com suporte ao MySQL, você deve verificar que o código normal de cliente MySQL é usado. Caso contrário, pode haver conflitos se seu Pike já tiver suporte ao MySQL. Você faz isso especificando um diretório de instalação do MySQL com a opção --with-mysql.
Para compilar o PHP como módulo fhttpd, responda "yes" para "Build as an fhttpd module?" (a opção do script configure --with-fhttpd=DIR deve ser usada) e especifique o diretório base dos fontes do fhttpd. O diretório padrão é /usr/local/src/fhttpd. Se você estiver rodando fhttpd, compilar o PHP como um módulo lhe dará melhor performance, mais controle e capacidade de execução remota.
Nota: Suporte para fhttpd não está mais disponível a partir do PHP 4.3.0.
Essa seção contem notas e dicas específicas para instação do PHP nos servidores un Java System Web Server, Sun ONE Web Server, iPlanet e Netscape no Solaris.
A partir do PHP 4.3.3, você pode usar scripts PHP com o módulo NSAPI para gerar listagem de diretórios e páginas de erro personalizadas. Funções adicionais para compatibilidade com o Apache também estão disponíveis. Para suporte nos webservers atuais, leia a nota sobre sub-requisições.
Você pode achar mais informações sobre como instalar o PHP para o Servidor Netscape Enterprise (NES) aqui: » http://benoit.noss.free.fr/php/install-php4.html
Para compilar o PHP com servidores web Sun JSWS/Sun ONE WS/iPlanet/Netscape, entre o diretório apropriado de instalação para a opção --with-nsapi=[DIR] O diretório padrão é, normalmente /opt/netscape/suitespot/. Por favor, leia também /php-xxx-version/sapi/nsapi/nsapi-readme.txt.
Instale os seguintes pacotes de » http://www.sunfreeware.com/ ou outro site de download:
export PATH
.
gunzip php-x.x.x.tar.gz
(se você tiver uma distribuição .gz,
caso contrário vá para o passo 4).
tar xvf php-x.x.x.tar
cd ../php-x.x.x
Para o passo seguinte, assegure-se de que /opt/netscape/suitespot/ é onde o seu servidor Netscape está instalado. Caso contrário, mude o comando abaixo para o caminho correto e execute:
./configure --with-mysql=/usr/local/mysql \ --with-nsapi=/opt/netscape/suitespot/ \ --enable-libgcc
Depois de fazer a instalação básica e ler o arquivo readme apropriado, você pode precisar executar alguns passos extras de configuração.
Primeiramente, você pode preciasr adicionar alguns caminhos para a váriavel de ambiente LD_LIBRARY_PATH para que o servidor ache as bibliotecas compartilhadas. A melhor maneira de fazer isso é no script de inicialização do ser servidor web. Esse script normalmente está localizado em: /caminho/para/servidor/https-nome_do_servidor/start. Você pode precisar também de editar os arquivos de configuração que estão localizados em: /caminho/para/servidor/https-nome_do_servidor/config/.
Adicione a seguinte linha no arquivo mime.types (você pode fazer isso pelo servidor de administração):
type=magnus-internal/x-httpd-php exts=php
Edite o arquivo magnus.conf (para servidores >= 6) ou o arquivo obj.conf (para servidores < 6) e adicione a seguinte biblioteca compartilhada que pode variar dependendo do seu sistema, ela se parecererá com /opt/netscape/suitespot/bin/libphp4.so. Você deve colocar as seguintes linhas após mime types init.
Init fn="load-modules" funcs="php4_init,php4_execute,php4_auth_trans" shlib="/opt/netscape/suitespot/bin/libphp4.so" Init fn="php4_init" LateInit="yes" errorString="Failed to initialize PHP!" [php_ini="/path/to/php.ini"]
Configure o objeto padrão no arquivo obj.conf (para classes de servidor virtuais [versão 6.0+] no arquivo vserver.obj.conf):
<Object name="default"> . . . .#NOTA Essa linha deve acontecer após todos as linhas 'ObjectType' e antes de todas as linas 'AddLog' Service fn="php4_execute" type="magnus-internal/x-httpd-php" [inikey=value inikey=value ...] . . </Object>
Isso só é necessários se você quiser configurar um diretório que apenas consiste de scripts PHP (assim como um diretório cgi-bin):
<Object name="x-httpd-php"> ObjectType fn="force-type" type="magnus-internal/x-httpd-php" Service fn=php4_execute [inikey=value inikey=value ...] </Object>
Configuração de autenticação: autenticação do PHP não pode ser usada com qualquer outra autenticação. TODA AUTENTICAÇÃO E PASSADA PARA O SEU SCRIPT PHP. Para configurar autenticação via PHP para o servidor todo, adicione a seguinte linha para o seu objeto padrão:
<Object name="default"> AuthTrans fn=php4_auth_trans . . . </Object>
Para usar autenticação via PHP em apenas um diretório, adicione o seguinte:
<Object ppath="d:\path\to\authenticated\dir\*"> AuthTrans fn=php4_auth_trans </Object>
Nota: O tamanho da pilha que o PHP usa depende da configuração do servidor web. Se você tiver problemas com scripts PHP muito grandes, é recomendado aumentar o tamanho da pilha com o Admin Server (na seção "MAGNUS EDITOR").
É importante ter em mente quando escrever scripts PHP que os servidores web Sun JSWS/Sun ONE WS/iPlanet/Netscape são multithreaded. Por isso, todas as requisições estão rodando no mesmo espaço de processo (o espaço do servidor web em si) e esse espaço só tem um ambiente. Se você quiser usar variáveis CGI como PATH_INFO, HTTP_HOST etc, não é correto tentar fazer da maneira como PHP antigo faz, com a função getenv() ou de maneira similar (registrando globais ao ambiente, $_ENV). Você só pegaria o ambiente do servidor web sem qualquer variáveis CGI válidas.
Nota: Por que existem variáveis CGI inválidas no ambiente?
Resposta: Isso é porque você iniciou o processo do servidor do admin server que roda o script de iniciação do mesmo, você queria iniciar como um script CGI (um script CGI dentro do admin server!). Isso é porque o ambiente do servidor web iniciado tem algumas variáveis CGI de ambiente nele. Você pode testar isso iniciando o servidor web sem ser do admin server. Use a linha de comando como usuário root e inicie-o manualmente - você verá que não exite nenhuma variável CGI de ambiente.
Simplesmente mudando seus scripts para pegar variáveis CGI é a maneira correta para o PHP 4.x usando o superglobal $_SERVER. Se você tiver scripts velhos que usam $HTTP_HOST, etc., você deve ligar register_globals no arquivo php.ini e mudar a ordem das variáveis também (importante: remova "E" de lá, porque voe não precisa do ambiente aqui):
variables_order = "GPCS" register_globals = On
Você pode usar o PHP para gerar as páginas de erro para "404 Not Found" ou similares. Adicione a seguinte linha no objeto do arquivo obj.conf para cada página de erro que você quiser sobrescrever:
Error fn="php4_execute" code=XXX script="/path/to/script.php" [inikey=value inikey=value...]
Outra possibilidade é criar uma listagem do diretório auto-gerada. Apenas crie um script PHP que mostra uma listagem do diretório e substitua o padrão correspondente Service line for type="magnus-internal/directory" no arquivo obj.conf pelo seguinte:
Service fn="php4_execute" type="magnus-internal/directory" script="/path/to/script.php" [inikey=value inikey=value...]
O módulo NSAPI agora suporta a função nsapi_virtual() (sinônima (alias): virtual()) para fazer sub-requisições no servidor web e inserir o resultado na página web. Essa função usa algumas funcionalidades não documentadas da biblioteca NSAPI. No Unix, o módulo procura automaticamente para as funções necessárias e as usa se estiverem disponíveis. Se não, nsapi_virtual() é desabilitada.
Nota: Mas esteja avisado: Suporte para nsapi_virtual() é EXPERIMENTAL!!!
O padrão é compilar o PHP como um programa CGI. Isso cria um interpretador de linha de comando, que pode ser usado para processamento de CGI, ou para criação de scripts não relacionados com a web. Se você estiver executando um servidor web que suporta o PHP como módulo, você deve geralmente usar essa opção por razões de performance. No entanto, a versão CGI permite que usuários executem diferentes páginas com PHP usando diferentes ids de usuário.
Um servidor dispoto em modo CGI está aberto para várias vulnerabilidades possíveis. Por favor, leia nossa seção de segurança CGI para aprender em como se defender de tais ataques.
A partir do PHP 4.3.0, alguns acréscimos importentes aconteceram ao PHP. Um novo SAPI chamado CLI também existe e ele tem o mesmo nome que o binário CGI. O que é instalado no diretório {PREFIX}/bin/php depende das opções usadas com o comando configure e é descrito com mais detalhes na seção do manual chamada Usando o PHP da linha de comando. Para mais detalhes, por favor, leia essa seção do manual.
Se você compilou o PHP como um programa CGI, você pode testá-lo usando o comando make test. É sempre uma boa idéia testar os software que você compila. Dessa maneira, você pode achar um problema com o PHP na sua plataforma cedo, ao invés de ter de lidar com isso mais tarde.
Algumas variáveis de ambientes fornecidas pelo servidor não são definidas na atual » especificação CGI/1.1. Apenas as seguintes variáveis são definidas lá: AUTH_TYPE, CONTENT_LENGTH, CONTENT_TYPE, GATEWAY_INTERFACE, PATH_INFO, PATH_TRANSLATED, QUERY_STRING, REMOTE_ADDR, REMOTE_HOST, REMOTE_IDENT, REMOTE_USER, REQUEST_METHOD, SCRIPT_NAME, SERVER_NAME, SERVER_PORT, SERVER_PROTOCOL, e SERVER_SOFTWARE. Todo o resto deve ser tratado como 'vendor extensions'.
Esta sessão contém notas e avisos especificos sobre a instalação do PHP em sistemas HP-UX.
Existem duas opções principais para instalar o PHP em sistemas HP-UX systems. Ou compila-lo, ou instalar um binário pré-compilado.
Pacotes oficiais pré-compilados podem ser encontrados aqui: » http://software.hp.com/
Até que esta sessão do manual seja rescrita, a documentação sobre compilar o PHP (e as extensões relacionadas) em sistemas HP-UX foi removida. Por enquanto, considere ler o seguinte recurso externo: » Construindo o Apache e o PHP em HP-UX 11.11
Essa seção contêm notas e dicas específicas para a instalação do PHP no » OpenBSD 3.6.
Usando pacotes binários para instalar o PHP no OpenBSD é o método recomendado e o mais simples. O pacote núcleo foi separado dos vários módulos, e cada um pode ser instalado e removido independentemente dos outros. Os arquivos necessários podem ser encontrados no CD do OpenBSD ou no FTP do site.
O pacote principal que você precisa instalar é o php4-core-4.3.8.tgz, que contem o engine básico (mais gettext e iconv). Depois, olhe os pacotes com módulos, como o php4-mysql-4.3.8.tgz ou php4-imap-4.3.8.tgz. Você precisa usar o comando phpxs para ativar e desativar esses módulos no seu arquivo php.ini.
Exemplo #1 Exemplo de instalação de pacote no OpenBSD
# pkg_add php4-core-4.3.8.tgz # /usr/local/sbin/phpxs -s # cp /usr/local/share/doc/php4/php.ini-recommended /var/www/conf/php.ini (adiciona o módulo mysql) # pkg_add php4-mysql-4.3.8.tgz # /usr/local/sbin/phpxs -a mysql (adiciona o módulo imap) # pkg_add php4-imap-4.3.8.tgz # /usr/local/sbin/phpxs -a imap (remove o módulo mysql para teste) # pkg_delete php4-mysql-4.3.8 # /usr/local/sbin/phpxs -r mysql (instala as bibliotecas do PEAR) # pkg_add php4-pear-4.3.8.tgz
Leia o manual de » packages(7) para mais informações sobre pacotes binários no OpenBSD.
Você também pode compilar o PHP dos fontes usando a » árvore ports. No entanto, isso só é recomendado para usuários familiarizado com OpenBSD. O port do PHP 4 é dividido em dois sub-diretórios: núcleo e extensões. O diretório de extensões gera sub-pacotes para todos os módulos suportados pelo PHP. Se você achar que não quer criar alguns dos módulos, use o comando no_* FLAVOR. Por exemplo, se você quiser que o módulo imap seja ignorado, atribua à FLAVOR o valor no_imap.
Releases mais antigas do OpenBSD usam o sistema de FLAVORS para compilar um PHP estaticamente linkado. Já que é difícil gerar pacotes binários usando esse método, ele é depreciado agora. Você pode ainda usar as árvores de port velhas e estáveis se assim desejar, mas eles não tem suporte pelo time do OpenBSD. Se você tiver algum comentário sobre isso, o atual responsável pela manutenção do port é Anil Madhavapeddy (avsm at openbsd dot org).
Essa seção contêm notas e dicas específicas para a instalação do PHP em sistemas Solaris.
Instalações do Solaris frequentemente não possuem compiladores C e suas ferramentas relacionadas. Leia esse FAQ para informação sobre porque usar versões GNU para algumas dessas ferramentas é necessário. Os softwares necessários são os seguintes:
Você pode simplificar o processo de instalação no Solaris usando pkgadd para instalar a maioria dos componentes necessários.
Essa seção contem notas e dicas específicas para a instalação do PHP no » Debian GNU/Linux.
Embora você possa apenas baixar o fonte do PHP e compilar por conta própria, usar o sistema de pacotes do Debian e o método mais simples e mais limpo de instalar o PHP. Se você não está familiarizado com compilar software no Linux, essa é maneira de se instalar.
A primeira decisão que você precisa fazer é se você quer instalar o Apache 1.3.x ou o Apache 2.x. Os pacotes correspondentes do PHP são, respectivamente, libapache-mod-php* e libapache2-mod-php*. Os passos abaixo usarão o Apache 1.3.x. Por favor, perceba que, até o fechamento desse documento, não há nenhum pacote oficial do Debian para o PHP 5. Então, o procedimento instalará o PHP4.
O PHP está disponível no Debian como CGI ou CLI também, pelos pacotes php4-cgi e php4-cli. Se você precisar deles, só terá que reproduzia os passos a seguir com o pacote desejado. Outro pacote especial que você pode querer instalar é o php4-pear. Ele contem um instalação PEAR mínima e a ferramenta de linha de comando pear.
Se você precisa de pacotes do PHP mais recentes que os do Debian stable ou se alguns módulos do PHP não se encontram no repositório oficial do Debian, talvez você deva procurar em » http://www.apt-get.org/. Um dos resultados encontrados deve ser » Dotdeb. Esse repositório não-oficial é mantido por » Guillaume Plessis e contem pacotes Debian das versões mais recentes do PHP 4 e 5. Para usá-lo, apenas adiciona as seguintes linhas ao seu arquivo /etc/apt/sources.lists e execute apt-get update :
Exemplo #1 Adicionando o repositório Dotdeb
deb http://packages.dotdeb.org stable all deb-src http://packages.dotdeb.org stable all
A última coisa a ser considade é se sua lista de pacotes está atualizada. Se você não atualizou recentemente, você precisa executar apt-get update antes de qualquer coisa. Dessa forma, você estará usando a versão estável mais recente dos pacotes do Apache e do PHP.
Agora que está tudo no lugar, você pode usar o seguinte exemplo para instalar o Apache e o PHP:
Exemplo #2 Exemplo de Instalação no Debian com o Apache 1.3
# apt-get install libapache-mod-php4
O APT instalará o módulo do PHP 4 para o Apache 1.3 automaticamente, e todas as suas dependências e então ativá-lo. Se o programa não pedir para reiniciar o Apache durante a instalação, você terá que fazê-lo manualmente:
Exemplo #3 Parando e iniciando o Apache depois que o PHP estiver instalado
# /etc/init.d/apache stop # /etc/init.d/apache start
Na seção anterior, o PHP foi instalado apenas com os módulos principais. Isso pode não ser o que você quer e você discobrirá em breve que você precisa de mais módulos ativados, como MySQL, cURL, GD, etc.
Quando você compila o PHP do fonte, você precisa ativar os módulos através do comando configure. Com o APT, você só precisa instalar os pacotes adicionais. Todos eles tem o nome 'php4-*' (ou 'php5-*' se você instalou o PHP 5 de um repositório não-oficial).
Exemplo #4 Pegando a lista de pacotes adicionais do PHP
# dpkg -l 'php4-*'
Como você pode ver na saída do comando, existem vários módulos do PHP que você pode instalar (tirando os pacotes especiais php4-cgi, php4-cli ou php4-pear). Olhe com bastante atenção e escolha os que você precisar. Se você escolher um módulo e você não tiver as bibliotecas necessárias, o APT instalará todas as dependências automaticamente para você.
Se você escolher adicionar os módulos do MySQL, cURL e GD, o comando parecerá com esse:
Exemplo #5 Instalar o PHP com MySQL, cURL e GD
# apt-get install php4-mysql php4-curl php4-gd
O APT editará o seu arquivo php.ini (/etc/php4/apache/php.ini, /etc/php4/cgi/php.ini, etc) para dar suporte aos módulos novos.
Exemplo #6 Essas linhas ativam o MySQL, cURL e GD no PHP
extension=mysql.so extension=curl.so extension=gd.so
Você só terá que parar/iniciar o Apache como antes para ativar os módulos.
Exemplo #7 Essa linha ativa o PHP 4 no Apache
# Include /etc/apache/conf.d/
Essa seção contem notas e dicas específicas para instalação do PHP no Mac OS X. Existem duas versões do Mac OS X um pouquinho diferentes entre si, Cliente e Servidor, nosso manual trata da instalação do PHP em ambos os sistemas. Note que o PHP não está disponível para MacOS 9 e versões anteriores.
Existem algumas versões do PHP empacotadas e pré-compiladas para o Mac OS X. Isso pode ajudar na instalação de uma configuração padrão, mas se você precisar ter algumas características diferentes (como um servidor seguro, ou um driver de banco de dados diferente), você pode precisar compilar o PHP e/ou seu servidor web por conta própria. Se você não estiver familiarizado com o procedimento de compilar seu próprio software, vale a pena checar se alguém já fez um pacote do PHP com as características que você precisa.
Os seguintes recursos oferecem pacotes de fácil instalação e binários pré-compilados para usar o PHP no Mac OS:
PHP vem junto com Mac OS X desde a versão 10.0.0. Habilitar o PHP no servidor web padrão requer apenas descomentar algumas linhas no arquivo de configuração do Apache (httpd.conf) enquanto que a versão CGI e/ou CLI estão disponíveis automaticamente (facilmente acessíveis pelo programa Terminal).
Habilitar o PHP usando as instruções abaixo tem como objetivo configurar rapidamente um ambiente de desenvolvimento local. É altamente recomendado sempre atualizar o PHP para a versão mais nova. Como qualquer software ativo, novas versões são criadas para consertar bugs e adicionar funcionalidades e o PHP não é diferente. As seguintes instruções são direcionadas para iniciantes, os detalhes fornecidos permitem que uma configuração padrão funcionar. Todos os usuários são encorajados à compilar ou instalar uma versão nova do pacote.
O tipo de instalação padrão é usando mod_php, e habilitar o pacote mod_php no Mac OS X para o servidor Apache (o servidor web padrão, que é acessível via Preferências de Sistema) envolte os seguintes passos:
Nota: Uma maneira de modificar o arquivo é usando um editor de texto baseado em Unix no Terminal, por exemplo nano, e, como o dono do arquivo é o root, nós usaremos o comando sudo para abrí-lo. Digite o seguinte comando na aplicação de Terminal (você precisará digitar a sua senha): sudo nano /etc/httpd/httpd.conf Comandos importantes do nano: ^w (busca), ^o (salvar), e ^x (sair) onde ^ representa a tecla Ctrl.
Com um editor de texto, descomente as linhas (removendo os #) que parecem com as linhas abaixo (essas duas linhas normalmente não estão juntas, localize ambas no arquivo):
# LoadModule php4_module libexec/httpd/libphp4.so # AddModule mod_php4.c
Certifique-se que as extensões desejadas serão avalidadas como códigos PHP (exemplos: .php .html e .inc)
Como a seguinte instrução já existe no httpd.conf (a partir do Mac Panther), uma vez que o PHP for habilitado, os arquivos .php serão automaticamente avaliados como códigos PHP.
<IfModule mod_php4.c> # If php is turned on, we respect .php and .phps files. AddType application/x-httpd-php .php AddType application/x-httpd-php-source .phps # Since most users will want index.php to work we # also automatically enable index.php <IfModule mod_dir.c> DirectoryIndex index.html index.php </IfModule> </IfModule>
A função phpinfo() mostrará informação sobre o PHP. Considere criar um arquivo no DocumentRoot com o seguinte código PHP:
<?php phpinfo(); ?>
A versão CLI (ou CGI em versões mais antigas) tem nome php e provavelmente está em /usr/bin/php. Abra um terminal, leia a seção sobre linha de comando do manual desse binário. Uma chamada para phpinfo() também mostrará do PHP, e execute php -v para verificar a versão do PHP essa informação.
Expanda o arquiv tar, e execute o programa configure do Apache dessa maneira (modifique para conformar com suas necessidades).
./configure --exec-prefix=/usr \ --localstatedir=/var \ --mandir=/usr/share/man \ --libexecdir=/System/Library/Apache/Modules \ --iconsdir=/System/Library/Apache/Icons \ --includedir=/System/Library/Frameworks/Apache.framework/Versions/1.3/Headers \ --enable-shared=max \ --enable-module=most \ --target=apache
Se você quiser que o compilador faça alguma otimização, você pode também querer adicionar essa linha:
setenv OPTIM=-O2
Depois, vá para o diretório onde os fontes do PHP 4 estão e rode o configure.
./configure --prefix=/usr \
--sysconfdir=/etc \
--localstatedir=/var \
--mandir=/usr/share/man \
--with-xml \
--with-apache=/src/apache_1.3.12
Agora, reconfigure o Apache para montar junto com o PHP 4.
./configure --exec-prefix=/usr \ --localstatedir=/var \ --mandir=/usr/share/man \ --libexecdir=/System/Library/Apache/Modules \ --iconsdir=/System/Library/Apache/Icons \ --includedir=/System/Library/Frameworks/Apache.framework/Versions/1.3/Headers \ --enable-shared=max \ --enable-module=most \ --target=apache \ --activate-module=src/modules/php4/libphp4.a
cp php.ini-dist /usr/local/bin/php.ini
ou (se você não tiver um diretório local)
cp php.ini-dist /usr/bin/php.ini
.
As instruções seguintes ajudarão você a instalar o módulo PHP para o servidor web Apache incluso no MacOS X. Essa versão inclui suporte para os bancos de dados MySQL e PostgreSQL. Essas instruções foram providas por » Marc Liyanage.
Tenha cuidado quando for fazer isso, vocêo pode estragar seu servidor Apache!
Faça isso para instalar:
wget http://www.diax.ch/users/liyanage/software/macosx/libphp4.so.gz
,
e espere o download terminar.
gunzip libphp4.so.gz
.
sudo apxs -i -a -n php4 libphp4.so
Agora digite sudo open -a TextEdit /etc/httpd/httpd.conf
.
TextEdit abrirá o arquivo de configuração do servidor web. Localize Locate essas
duas linhas perto do final do arquivo: (Use o comando Localizar (Find))
#AddType application/x-httpd-php .php #AddType application/x-httpd-php-source .phps
sudo apachectl graceful
e reinicie
o servidor web.
PHP deve estar funcionando. Você pode testar colocando um arquivo no seu diretório Sites chamado test.php. No arquivo, escreva essa linha: <?php phpinfo() ?>.
Agora abra 127.0.0.1/~your_username/test.php no seu navegador. Você deve ver uma tabela de status com informação sobre o módulo PHP.
Essa seção aplica-se ao Windows 98/Me e Windows NT/2000/XP/2003. O PHP não funcionará em plataformas 16 bit como o Windows 3.1 e algumas vezes nos referimos às plataformas Windows suportadas como Win32. Windows 95 não é mais suportado a partir do PHP 4.3.0.
Existem duas maneiras principais de instalar o PHP para o Windows: ou manualmente ou usando o instalador.
Se você tiver o Microsoft Visual Studio, você pode também compilar o PHP a partir do código-fonte original.
Uma vez que você tiver o PHP instalado no seu sistema Windows, você pode também querer carregar várias extensões para adicionar funcionalidades.
Existem vários instaladores completos na Internet, mas nenhum deles é apoioado pelo PHP.net, nós acreditamos que usando um dos pacotes oficial para Windows de » http://www.php.net/downloads.php seja a melhor maneira de ter seu sistema seguro e otimizado.
O Instalador do PHP para Windows para versões recentes do PHP é feito usando a tecnologia MSI através do Wix Toolkit (» http://wix.sourceforge.net/). Ele instala e configura o PHP e todas as extensões PECL integradas, assim como configura muitos dos web servers mais populares, como IIS, Apache, e Xitami.
Primeiro, instale seu servidor HTTP (web) predileto no seu sistema e verifique que ele funciona. Então prossiga com um dos seguintes tipos de instação.
Execute o instalador MSI e siga as instruções fornecidas pelo programa. Ele primeiro perguntará qual Web Server você deseja configurar, assim como qualquer detalhe de configuração necessário.
Depois você deve selecionar quais funcionalidades e extensões você deseja instalar e habilitar. Para cada item disponível, você pode selecionar "Será instalado no disco local" no menu para determinar quais funcionalidades serão instaladas. Selcionado "Funcionalidade inteira será instalada no disco local", você poderá instalar todas as sub-funcionalidades vinculadas à funcionalidade (por exemplo, selecionar essa opção na extensão "PDO" você instalará todos os drivers PDO).
Não é recomendado instalar todas as extensões, já que muitas dependem de extensões externas ao PHP para funcionarem corretamente. Ao invés, use o Installation Repair Mode (Modo de Reparo) que pode ser acionado através da opção Add/Remove Programs (Adicionar/Remover Programas) do painel de controle para habilitar ou desabilitar extensões após a instalação.
O instalador então instala o PHP para ser usado no Windows e o arquivo php.ini, e configura certos servidores web para usá-lo. O instalador configura, atualmente, o IIS, Apache, Xitami e Sambar; se você estiver usando um servidor web diferente, você precisa configurá-lo manualmente.
O instalador também suporta um modo silencioso, que é útil para administradores de sistema implantarem o PHP facilmente. Para usar o modo silencioso:
msiexec.exe /i php-VERSION-win32-install.msi /q
Você pode controlar o diretório de instalação passando ele como parâmetro de linha de comando. Por exemplo, para instalar em e:\php:
msiexec.exe /i php-VERSION-win32-install.msi /q INSTALLDIR=e:\php
Você pode especificar quais funcionalidades instalar. Por exemplo, para instalar a extensão mysqli e o executável CGI:
msiexec.exe /i php-VERSION-win32-install.msi /q ADDLOCAL=cgi,ext_php_mysqli
A lista atual de funcionalidades para instalação é a seguinte:
MainExecutable - php.exe executable ScriptExecutable - php-win.exe executable ext_php_* - the various extensions ( for example: ext_php_mysql for MySQL ) apache13 - Apache 1.3 module apache20 - Apache 2.0 module apache22 - Apache 2,2 module apacheCGI - Apache CGI executable iis4ISAPI - IIS ISAPI module iis4CGI - IIS CGI executable NSAPI - Sun/iPlanet/Netscape server module Xitami - Xitami CGI executable Sambar - Sambar Server ISAPI module CGI - php-cgi.exe executable PEAR - PEAR installer Manual - PHP Manual in CHM Format
Para mais informações sobre instalando usando instaladores MSI a partir da linha de comando, visite » http://msdn.microsoft.com/en-us/library/aa367988.aspx
Para fazer atualização, execute o instalador ou graficamente, ou a partir da linha de comando normalmente. O instalador lerá as opções atuais instalação, remover a instalação velha e reinstalará o PHP com as mesmas opções de antes. É recomendado que você use esse método para manter o PHP atualizado ao invés substituir manualmente os arquivos no diretório de instalação.
O Instalador do PHP para o Windows está disponível na página de downloads em » http://www.php.net/downloads.php. Ele instala a versão CGI do PHP e para IIS, PWS e Xitami, ele configura o servidor web também. O instalador não inclui qualquer extensão extra ao PHP (php_*.dll) uma vez que você só encontrará essas no pacote Zip para o Windows e nos downloads de PECL.
Nota: Embora o instalador para o Windows seja uma maneira fácil de fazer o PHP funcionar, ele é restrito em muitos aspectos já que, por exemplo, a instalação automática de extensões não é suportada. Uso do instalador não é o método preferido para instalar o PHP.
Primeiro, instale o servidor HTTP (web) de sua preferência no seu sistema e teste se o mesmo funciona.
Execute o instalador e siga as instruções mostradas pelas telas de instalação. Dois tipos de instalação são suportadas - padrão, que provê padrões sensíveis para todas as configurações possíveis, e avançado, que pergunta tudo enquanto instala.
O auxiliar de instalação junta informação suficiente para configura o arquivo php.ini, e configura certos web server para usar o PHP. Um dos servidores web que o instalador não configura é o Apache, então você precisará configurá-lo manualmente.
Uma vez que a instalação tiver completado, o instalador informará a você se você precisa reiniciar seu sistema, reiniciar o servidor ou simplesmente começar a usar o PHP.
Cuidado, que essa configuração do PHP não é segura. Se você quiser ter uma configuração do PHP segura, é melhor usar a instalação manual, e editar cada opção com cuidado. Essa configuração automática te dé uma instalaço do PHP que funciona instantaneamente, mas ela não deve ser usada em servidores online.
Esse guia de instalação ajudará você a instalar manualmente e configurar o PHP com um servidor web no Microsoft Windows. Para começar, você precisará baixar o zip com a distribuição binária da página de downloads em » http://www.php.net/downloads.php.
Embora existam muitos kits de instalação "completos", e nós também distribuímos um instalador do PHP para o Microsoft Windows, nós recomendamos que você se dê ao trabalho de instalar o PHP manualmente uma vez que isso lhe permitirá um melhor entendimento do sistema, e permite que você instale extensões do PHP facilmente quando precisar.
Nota: Atualizar uma versão instalado do PHP Edições anteriores do manual sugeriam mover vários arquivo ini e DLL para o seu diretório SYSTEM (ex.: C:\WINDOWS) e, embora isso simplifique o processo de instalação, torna a atualização difícil. Nós aconselhamos que você remova esses arquivos (como php.ini e DLLs relacionadas ao PHP da pasta SYSTEM do Windows) antes de continuar com uma instalação nova do PHP. Assegure-se de fazer um backup desses arquivos já que você pode corromper o sistema inteiro. O arquivo php.ini da versão anterior a que você quer instalar pode ser útil na versão nova. E, como você aprenderá a seguir, o método preferido para instalar o PHP é manter todos os arquivos relacionados ao PHP em um diretório e disponibilizar esse diretório no PATH do seu sistema.
Nota: Requerimentos MDAC Se você usa o Microsoft Windows 98/NT4, baixe a última versão do Microsoft Data Access Components (MDAC) para sua plataforma. MDAC está disponível em » http://msdn.microsoft.com/data/. Esse requerimento existe porque ODBC é compilado nos binários distribuídos para o Windows.
Os passos a seguite devem ser completados em todas as instalações antes de qualquer instruções específicas ao servidor sejam feitas:
Extraia o arquivo da distribuição no diretório de sua escolha. Se você estiver instalando o PHP 4, extraia em C:\, uma vez que o arquivo zip expande para uma pasta de nome parecido com php-4.3.7-Win32. Se você estiver instalando o PHP 5, extraia em C:\php já que o arquivo zip não expande como no PHP 4. Você pode escolher uma localização diferente, desde que não tenha espaços no caminho (como C:\Program Files\PHP) já que alguns servidores web irão travar se tiver.
A estrutura de diretório extraida do zip é diferente para as versões 4 e 5 e se parecem com as seguintes:
Exemplo #1 Estrutura de diretório para o PHP 4
c:\php | +--cli | | | |-php.exe -- executável CLI - Só para uso na linha de comando. | +--dlls -- DLLs de suporte, necessárias para algumas extensões | | | |-expat.dll | | | |-fdftk.dll | | | |-... | +--extensions -- DLLs de extensões para o PHP | | | |-php_bz2.dll | | | |-php_cpdf.dll | | | |-.. | +--mibs -- arquivos de suporte para SNMP | +--openssl -- arquivos de suporte para Openssl | +--pdf-related -- arquivos de suporte para PDF | +--sapi -- DLLs de SAPI (suporte a módulo de servidor) | | | |-php4apache.dll | | | |-php4apache2.dll | | | |-.. | +--PEAR -- cópia inicial do PEAR | | |-go-pear.bat -- script de configuração do PEAR | |-.. | |-php.exe -- executável CGI | |-.. | |-php.ini-dist -- configurações padrão do php.ini | |-php.ini-recommended -- configurações recomendadas do php.ini | |-php4ts.dll -- DLL núcleo do PHP | |-...
Ou:
Exemplo #2 Estrutura de diretório para o PHP 5
c:\php | +--dev | | | |-php5ts.lib | +--ext -- DLLs de extensões para o PHP | | | |-php_bz2.dll | | | |-php_cpdf.dll | | | |-.. | +--extras | | | +--mibs -- arquivos de suporte para SNMP | | | +--openssl -- arquivos de suporte para Openssl | | | +--pdf-related -- arquivos de suporte para PDF | | | |-mime.magic | +--pear -- cópia inicial do PEAR | | |-go-pear.bat -- script de configuração do PEAR | |-fdftk.dll | |-.. | |-php-cgi.exe -- executável CGI | |-php-win.exe -- executa scripts sem um prompt de comando aberto | |-php.exe -- CLI executável - Só para uso em linha de comando | |-.. | |-php.ini-dist -- configurações padrão do php.ini | |-php.ini-recommended -- configurações recomendadas do php.ini | |-php5activescript.dll | |-php5apache.dll | |-php5apache2.dll | |-.. | |-php5ts.dll -- DLL núcleo do PHP | |-...
Note as diferenças e similaridades. Tanto o PHP 4 quanto o 5 tem um executável CGI, um executável CLI, e módulos do servidor, mas eles estão localizados em pastas diferentes e/ou tem nomes diferentes. Enquanto no PHP 4 os módulos do servidor estão na pasta sapi, no PHP 5 não há tal diretório e, ao invés disso, eles estão na pasta principal do PHP. As DLLs de suporte para as extensões do PHP 5 também não estão em um diretório separado.
Nota: No PHP 4, você deve mover todos os arquivos localizados nas pastas dll e sapi para a pasta principal (ex.: C:\php).
Aqui está uma lista dos módulos de servidor liberados com o PHP 4 e PHP 5:
sapi/php4activescript.dll (php5activescript.dll) - ActiveScript engine, permitindo imbutir PHP em aplicações Windows.
sapi/php4apache.dll (php5apache.dll) - Módulo do Apache 1.3.x.
sapi/php4apache2.dll (php5apache2.dll) - Módulo do Apache 2.0.x.
sapi/php5apache2_2.dll - Módulo do Apache 2.2.x.
sapi/php4isapi.dll (php5isapi.dll) - Módulo do ISAPI para servidores que suportam ISAPI como IIS 4.0/PWS 4.0 ou superior.
sapi/php4nsapi.dll (php5nsapi.dll) - Módulo dos servidores Sun/iPlanet/Netscape.
sapi/php4pi3web.dll (não tem equivalente no PHP 5) - Módulo do servidor Pi3Web.
Módulos de servidor tem performance significativamente melhor e funcionalidades adiconais comparados com o binário CGI. A versão CLI é desenhada para permitir usar o PHP para scripts de linha de comando. Mais informação sobre CLI disponível no capítulo sobre usando PHP da linha de comando.
Os módulos SAPI foram melhorados significativamente a partir do release 4.1, no entanto, em sistemas mais antigos, você pode encontrar erros de servidor e outros módulos do servidor podem falhar, como ASP.
Os binários CGI e CLI, e os módulos de servidor web todos necessitam do arquivo php4ts.dll (php5ts.dll) para funcionar corretamente. Você tem que assegurar que esse arquivo pode se encontrado pela sua instalação do PHP. A ordem de busca para essa DLL é como segue:
O mesmo diretório onde o arquivo php.exe é chamado, ou no caso de usar um módulo SAPI, o diretório do servidor web (ex.: C:\Program Files\Apache Group\Apache2\bin).
Qualquer diretório no na sua variável de ambiente PATH do Windows.
Para disponibilizar php4ts.dll / php5ts.dll você tem três opções: copiar o arquivo para o diretório system do Windows, copiar o arquivo para o diretório do servidor web, ou adicionar o diretório do PHP, C:\php no PATH. Para melhor manutenção, nós aconselhamos que você siga a última opção, adicione C:\php ao PATH, porque é mais simples atualizar o PHP no futuro. Leia mais sobre como adicionar o diretório ao PATH no FAQ correspondente (e então, não esqueça de reiniciar o computador - fazer o logoff não é suficiente).
O próximo passo é montar um arquivo de configuração para o PHP, php.ini. Existem dois arquivos ini distribuídos no arquivo zip, php.ini-dist e php.ini-recommended. Nós aconselhamos que você use php.ini-recommended, porque nós otimizamos as configurações padrões nesse arquivo para performance e segurança. Leia esse arquivo bem documentador cuidadosamente porque ele tem diferenças em relação a php.ini-dist que afetarão drasticamente sua configuração. Alguns exemplos são display_errors está off e magic_quotes_gpc está off. Além de ler isso, estude as configurações ini e configure cada elemento manualmente. Se você quiser alcança o máximo de segurança, então essa é a maneira que você deve fazer, embora o PHP funcione bem com os arquivos padrões. Copie o seu arquivo ini preferido para um diretódio que o PHP possa encontrar e renomei para php.ini. PHP procura pelo arquivo php.ini nas localidades descritas nessa Configuração em tempo de execução seção.
Se você estiver executando o Apache 2, a opção mais simples é usar a diretiva PHPIniDir (leia a página instalação no Apache 2). Caso contrário, sua melhor opção é criar a variável de ambiente PHPRC. Esse processo é explicado no seguinte FAQ.
Nota: Se você estiver usando NTFS no Windows NT, 2000, XP ou 2003, assegure-se que o usuário executando o servidor web tem permissões de leitura ao seu arquivo php.ini (ex.: faça com que seja lido por Everyone (Todos) ).
Os passos a seguir são opcionais:
Edite seu no arquivo php.ini. Se você planeja usar OmniHTTPd, não faça o passo a seguir. Edite o doc_root para apontar para o document_root do servidor web. Por exemplo:
doc_root = c:\inetpub\wwwroot // para IIS/PWS doc_root = c:\apache\htdocs // para Apache
O PHP agora está configurado no seu sistema. O próximo passo é escolher um servidor web, e habilitá-lo para executar o PHP. Escolha um servidor web da tabela de conteúdos.
Essa seção contem notas específicas para a instalação do ActiveScript.
ActiveScript é um SAPI exclusivo do Windows que permite usar scripts PHP em qualquer host compatível com ActiveScript, como Windows Script Host, ASP/ASP.NET, Windows Script Components ou Microsoft Scriptlet Control.
A partir do PHP 5.0.1, ActiveScript foi transferido para o repositório do » PECL. A DLL para esta extensão PECL deve ser copiada da pagina de » Downloads do PHP ou de » http://pecl4win.php.net/
Nota: Você deve ler os passos da instalação manual antes!
Depois de instalar o PHP, você deve baixar o DLL do ActiveScript (php5activescript.dll) e colocá-lo na pasta principal do PHP (ex.: C:\php).
Depois de ter todos os arquivos necessários, você deve registrar a DLL no seu sistema. Para isso, abra um Prompt de Comando (localizado no seu Menu Iniciar). Então vá ao diretório do PHP digitando algo como cd C:\php. Para registrar a DLL apenas digite regsvr32 php5activescript.dll.
Para testar se o ActiveScript está funcionando, crie um arquivo novo, chamado test.wsf (a extensão é muito importante) e digite:
<job xml:id="test">
<script language="PHPScript">
$WScript->Echo("Alô Mundo!");
</script>
</job>
Nota: No PHP 4, o engine foi chamado de 'ActivePHP', então se você estiver usando PHP 4, você deve substituir 'PHPScript' por 'ActivePHP' no exemplo acima.
Nota: ActiveScript não usa o arquivo php.ini padrão. Ao invés disso, ele procurará apenas no mesmo diretório do .exe que o carregou. Você deve criar um arquivo php-activescript.ini e colocá-lo nessa pasta, se você quiser acrescentar extensões, etc.
Essa seção contêm notas e dicas específicas para o IIS (Microsoft Internet Information Server).
Um servidor dispoto em modo CGI está aberto para várias vulnerabilidades possíveis. Por favor, leia nossa seção de segurança CGI para aprender em como se defender de tais ataques.
O PHP pode ser instalado como binário CGI, ou como módulo ISAPI. Em ambos os casos, você precisa iniciar o Microsoft Management Console (pode aparecer como 'Internet Services Manager', ou no seu Windows NT 4.0 Option Pack ou no Control Panel=>Administrative Tools no Windows 2000/XP). Então clique no botão direito no seu ícone Web server (Provavelmente aparecerá como 'Default Web Server'), e selecione 'Properties'.
Se você quiser usar o binário CGI, faça o seguinte:
Para usuar o módulo ISAPI, faça o seguinte:
Com o IIS 6 (2003 Server), abra o IIS Manager, vá até Web Service Extensions, selecione "Add a new Web service extension", digite um nome como PHP, clique no botão Add e coloque no campo valor coloque ou o arquivo ISAPI (php4isapi.dll ou php5isapi.dll) ou do CGI (php.exe ou php-cgi.exe) e selecione a opção "Set extension status to Allowed" e clique OK.
Para usar index.php como página padrão de conteúdo, faça o seguinte: Na aba Documents, escolha Add. Digite index.php e clique OK. Ajuste a ordem clicando em Move Up ou Move Down. Isso é similar a configurar DirectoryIndex no Apache.
Os passos acima devem ser repetidos para cada extensão que será associada com scripts PHP. .php é a mais comum embora .php3 pode ser necessária para código legado.
Se ocorrer 100% de uso de CPU depois de um tempo, desligue a configuração do IIS Cache ISAPI Application.
PWS 4 não tem suporte a ISAPI, somente o CGI deve ser usado.
O método recomendado para configurar o PHP nesses servidores é usar o arquivo REG incluso na distribuição (pws-php4cgi.reg na pasta SAPI para o PHP 4, ou pws-php5cgi.reg na pasta principal para o PHP 5). Você pode querer editar o arquivo e assegurar-se que o diretório das extensões e do PHP estão corretos. Ou você pode seguir os passos abaixo para fazer manualmente.
Esses passos involvem trabalhar diretamente com o registro do Windows. Um erro aqui pode deixar seu sistema em um estado instável. Nós recomendamos que você faça um backup do seu registro primeiro. O time de desenvolvimento do PHP não será responsável se você danificar seu registro.
Os passos a seguir não afetam a instalação do servidor web e só se aplicam se você quiser que seus scripts sejam executados quando eles forem chamados da linha de comando (ex. run C:\myscripts\test.php) ou clicando duas vezes neles na janela de visualização de diretório. Você pode pular esses passos já que você pode preferir que os arquivos PHP sejam carregados em um editor de texto quando você clicar duas vezes neles.
Usuários do PWS e do IIS 3 agora tem um sistema totalmente operacional. Usuários do IIS 3 pode usar uma » ferramenta legal de Steven Genusa para configurar os mapas dos seus scripts.
Essa seção contem notas e dicas específicas para instalação do Apache 1.3.x com o PHP nos sistemas Microsoft Windows. Também há instruções e notas para o Apache 2 em uma página separada.
Nota: Por favor, leia os passos da instalação manual primeiro!
Existem duas maneiras de configurar o PHP para funcionar com o Apache 1.3.x no Windows. Uma é usar o binário CGI (php.exe para o PHP 4 e php-cgi.exe para o PHP 5), e a outra é usar o DLL do módulo do Apache. Em ambos os casos você precisa editar o arquivo httpd.conf para configurar o Apache para funcionar com o PHP e, então, reiniciar o servidor.
Vale a pena notar que agora o módulo SAPI tornou-se mais estável no Windows, nós recomendamos o seu uso ao invés do binário CGI, uma vez que é mais transparente e seguro.
Embora existam algumas pequenas variações de configuração do PHP com o Apache, elas são simples o suficiente para ser usado por iniciantes. Por favor, consulte a Documentação do Apache para mais diretivas de configuração.
Depois de mudar o arquivo de configuração, lembre-se de reiniciar o servidor, por exemplo, executando NET STOP APACHE seguido de NET START APACHE, se você rodar o Apache como um Windows Service, ou user os atalhos normais.
Nota: Lembre-se que quando acrescentando valores de caminhos nos arquivos de configuração do Apache para Windows, todas as contrabarras como em c:\directory\file.ext precisam ser convertidas para barras, como em c:/directory/file.ext. Uma barra ao final também é necessária para diretórios.
Você deve adicionar as seguintes linhas para o seu arquivo httpd.conf:
Exemplo #1 PHP como um módulo do Apache 1.3.x
Presume-se que o PHP esteja instalado em c:\php. Ajuste o caminho se não for o seu caso.
Para o PHP 4:
# Adicione ao fim da seção LoadModule # Não se esqueça de copiar esse arquivo do diretório sapi LoadModule php4_module "c:/php/php4apache.dll" # Adicione ao fim da seção AddModule AddModule mod_php4.c
Para o PHP 5:
# Adicione ao fim da seção LoadModule LoadModule php5_module "c:/php/php5apache.dll" # Adicione ao fim da seção AddModule AddModule mod_php5.c
Para ambos:
# Adicione essa linha dentro das tags condicionais <IfModule mod_mime.c> AddType application/x-httpd-php .php # Para arquivos .phps com highlight de sintaxe adicione também AddType application/x-httpd-php-source .phps
Se você dezipou o pacote PHP para o diretório C:\php\ como descrito na seção Passos da Instalação Manual, você precisa inserir as seguintes linhas ao arquivo de configuração do Apache para configurar o uso do binário CGI:
Exemplo #2 PHP e Apache 1.3.x como CGI
ScriptAlias /php/ "c:/php/" AddType application/x-httpd-php .php # Para o PHP 4 Action application/x-httpd-php "/php/php.exe" # Para o PHP 5 Action application/x-httpd-php "/php/php-cgi.exe" # especifica o diretório onde o php.ini está SetEnv PHPRC C:/php
Um servidor dispoto em modo CGI está aberto para várias vulnerabilidades possíveis. Por favor, leia nossa seção de segurança CGI para aprender em como se defender de tais ataques.
Se você gostaria de apresentar os códigos-fonte dos PHP com highlight de sintaxe, não exites uma opção conveniente como na versão de módulo. Se você escolheu configura o Apache para usar o PHP como um binário CGI, você precisará usar a função highlight_file(). Para fazer isso, simplesmente crie um script PHP e adicione esse código: <?php highlight_file('some_php_script.php'); ?>.
Essa seção contem notas e dicas específicas para instalação do Apache 2.0.x com o PHP nos sistemas Microsoft Windows.Também há instruções e notas para o Apache 1.3.x em uma página separada.
Nota: Por favor, leia os passos da instalação manual primeiro!
Nota: Suporte a Apache 2.2.x Usuários do Apache 2.2.x devem usar a documentação abaixo exceto que o nome do arquivo da dll apropriada é php5apache2_2.dll e lea só existe a partir do 5.2.0. Veja também » http://snaps.php.net/
Nós não recomendamos a utilização de um threaded MPM em produção com o Apache2. Use ao invés prefork MPM, ou use Apache1. para informações sobre o motivo, leia este faq sobre usando Apache2 com um threaded MPM
Encorajamos que você olhe a » Documentação do Apache para entender o básico do Servidor Apache 2.0.x. Também considere ler as » notas específicas para o Windows para o Apache 2.0.x antes de continuar.
Nota: Notas de compatibilidade do PHP e Apache 2.0.x As seguintes versões do PHP são compatíveis com a versão mais recente do Apache 2.0.x:
Essas versões do PHP são compatíveis com Apache 2.0.40 ou superior.
- PHP 4.3.0 ou superior, disponível em » http://www.php.net/downloads.php.
- A última versão estável de desenvolvimento. Pegue o código fonte » http://snaps.php.net/php5-latest.tar.gz ou baixe os binários para o Windows » http://snaps.php.net/win32/php5-win32-latest.zip.
- Uma versão pre-release disponível para download em » http://qa.php.net/.
- Você sempre tem a opção de obter o PHP através da conta » anônima do CVS.
Suporte a SAPI do Apache 2.0 começou no PHP 4.2.0. PHP 4.2.3 funciona com Apache 2.0.39, não use qualquer outra versão de Apache com PHP 4.2.3. No entando, a configuração recomendada é usar o 4.3.0 ou superior com a versão mais recente do Apache2.
Todas as versões mencionadas do PHP ainda funcionarão com Apache 1.3.x.
Apache 2.0.x foi desenhado para rodar no Windows NT 4.0, Windows 2000 ou Windows XP. Até o momento, suporte para Windows 9x está incompleto. Apache 2.0.x não tem planos para funcionar nessas plataformas.
Baixe a versão mais recente do » Apache 2.0.x e uma versão apropriada do PHP. Siga os Passos da Instalação Manual e volte para continuar com a integração do PHP e Apache.
Existem duas maneiras de configurar o PHP para funcionar com Apache 2.0.x no Windows. Uma é usar o binário CGI e a outra é usar o DLL do módulo do Apache. Em ambos os casos você precisa editar o arquivo httpd.conf para configurar o Apache para funcionar com o PHP e, então, reiniciar o servidor.
Nota: Lembre-se que quando acrescentando valores de caminhos nos arquivos de configuração do Apache para Windows, todas as contrabarras como em c:\directory\file.ext precisam ser convertidas para barras, como em c:/directory/file.ext. Uma barra ao final também é necessária para diretórios.
Você precisa inserir essas três linhas para o arquivo httpd.conf de configuração do Apache para configura o binário CGI:
Exemplo #1 PHP e Apache 2.0 como CGI
ScriptAlias /php/ "c:/php/" AddType application/x-httpd-php .php # Para o PHP 4 Action application/x-httpd-php "/php/php.exe" # Para o PHP 5 Action application/x-httpd-php "/php/php-cgi.exe"
Um servidor dispoto em modo CGI está aberto para várias vulnerabilidades possíveis. Por favor, leia nossa seção de segurança CGI para aprender em como se defender de tais ataques.
Você precisa inserir essas duas linhas ao arquivo de configuração de Apache httpd.conf para configurar o módulo PHP para o Apache 2.0:
Exemplo #2 PHP e Apache 2.0 como Módulo
# Para o PHP 4 faça algo assim: LoadModule php4_module "c:/php/php4apache2.dll" # Não esqueça de copiar o arquivo php4apache2.dll do diretório sapi para o principal do PHP! AddType application/x-httpd-php .php # Para o PHP 5 faça algo assim: LoadModule php5_module "c:/php/php5apache2.dll" AddType application/x-httpd-php .php # configure o caminho para o arquivo php.ini PHPIniDir "C:/php"
Nota: Lembre-se de substituir o caminho c:/php/ para o caminho onde você instalou o PHP na sua máquina. Tome o cuidade de usar ou php4apache2.dll ou php5apache2.dll na sua diretiva LoadModule e não php4apache.dll ou php5apache.dll já que essas últimas são feitas para rodar com o Apache 1.3.x.
Nota: Se você quiser negociação de conteúdo, leia o FAQ relacionado.
Não misture sua instalação com arquivos DLL de versões diferentes do PHP. Você só pode escolher usar as DLL's e extensões inclusas na versão do PHP que você baixou.
Essa seção contem notas e dicas específicas para instalação do PHP em servidores Sun Java System Web Server, Sun ONE Web Server, iPlanet e Netscape no Windows.
A partir do PHP 4.3.3 você pode usar seus scripts PHP com o módulo NSAPI para gerar listagens personalizadas de diretórios e páginas de erro. Funções adicionais para compatibilidade com o Apache também estão disponíveis. Para suporte nos servidores web atuais leia a nota sobre subrequests.
Para instalar o PHP como um tratador de CGI, faça o seguinte:
Faça uma associação de arquivo a partir da linha de comando. Digite as duas linhas a seguir:
assoc .php=PHPScript ftype PHPScript=c:\php\php.exe %1 %*
Mais detalhes sobre configuração do PHP como um executável CGI pode ser encontrado aqui: » http://benoit.noss.free.fr/php/install-php.html
Para instalar o PHP com NSAPI, faça o seguinte:
Faça uma associação de arquivo a partir da linha de comando. Digite as duas linhas a seguir:
assoc .php=PHPScript ftype PHPScript=c:\php\php.exe %1 %*
Edite o arquivo magnus.conf (para servidores >= 6) ou obj.conf (para servidores < 6) e adicione o seguinte: Você deve colocar as linhas depois de mime types init.
Init fn="load-modules" funcs="php4_init,php4_execute,php4_auth_trans" shlib="c:/php/sapi/php4nsapi.dll" Init fn="php4_init" LateInit="yes" errorString="Failed to initialise PHP!" [php_ini="c:/path/to/php.ini"]
Configure o objeto padrão no arquivo obj.conf (para classes de servidor virtual [Sun Web Server 6.0+] no arquivo vserver.obj.conf): Na seção <Object name="default">, coloque essa linha necessariamente após todas as linhas do tipo 'ObjectType' e antes das do tipo 'AddLog':
Service fn="php4_execute" type="magnus-internal/x-httpd-php" [inikey=value inikey=value ...]
Isso só é necessário se você quiser configurar um diretório que só consiste de scripts PHP (como em um diretório cgi-bin):
<Object name="x-httpd-php"> ObjectType fn="force-type" type="magnus-internal/x-httpd-php" Service fn=php4_execute [inikey=value inikey=value ...] </Object>
Nota: Mais detalhes sobre configurar o PHP como um filtro NSAPI pode ser achado aqui: » http://benoit.noss.free.fr/php/install-php4.html
Nota: O tamanho de pilha que o PHP usa depende da configuração do servidor web. Se você tiver problemas com scripts muito grandes, é recomendado aumentar esse tamanho com o Administrador do Servidor (na seção "MAGNUS EDITOR").
É importante quando escrevendo scripts PHP levar em conta o fato que Sun JSWS/Sun ONE WS/iPlanet/Netscape são servidores multithreaded. Por isso, todas as requisições estão sendo executadas no mesmo espaço de processo (o espaço do servidor web) e esse espaço só tem um ambiente. Se você quiser usar variáveis CGI como PATH_INFO, HTTP_HOST etc, não é correto tentar pegá-las da maneira do PHP antigo, usando a função getenv() ou uma maneira similar (registrar globais para o ambiente, $_ENV). Você só iria pegar o ambiente do servidor web sem quaisquer variáveis CGI válidas!
Nota: Porque existem variáveis CGI (inválidas) no ambiente?
Resposta: Isso é porque você inicializou o processo do servidor a partir do administrador do servidor que executa o script de inicialização do servidor web, você queria iniciar, como um script CGI (um script CGI dentro do administrador do servidor!). Isso é porque o ambiente do servidor tem algumas variáveis CGI do ambiente nele. Você pode testar isso inicializando o servidor web de outra forma que não pelo administrador do servidor. Use a linha de comando como usuário root e inicialize-o manualmente - você verá que não há variáveis ambientes do tipo CGI.
Simplesmente mude seus scripts para pegar variáveis CGI da maneira correta para o PHP 4.x, usando o array superglobal $_SERVER. Se você tiver scripts mais antigos que usem $HTTP_HOST, etc., você deve ligar a diretiva register_globals no arquivo php.ini e mudar a ordem das variáveis também (importante: remova "E" da diretiva, porque você não precisa das variávies de ambiente aqui):
variables_order = "GPCS" register_globals = On
Você pode usar o PHP para gerar as páginas de erro para "404 Not Found" ou similar. Adicione a seguinte linha ao objeto no arquivo obj.conf para cada página de erro que você queira sobrescrever:
Error fn="php4_execute" code=XXX script="/path/to/script.php" [inikey=value inikey=value...]
Outra possibilidade é gerar listagens de conteúdo de diretório. Apenas crie um script PHP que mostre uma listagem do diretório e substitua o valor padrão da linha Service type="magnus-internal/directory" no arquivo obj.conf com a seguinte:
Service fn="php4_execute" type="magnus-internal/directory" script="/path/to/script.php" [inikey=value inikey=value...]
O módulo NSAPI agora suporta a função nsapi_virtual() (sinônimo (alias): virtual()) para fazer subrequisições no servidor web e inserir o resultado em uma página web. O problema é que essa função usa algumas características não documentadas da biblioteca NSAPI.
No Unix, isso não é um problema, porque o módulo procura automaticamente pelas funções necessárias e usa elas se disponíveis. Se não, nsapi_virtual() é desabilitada.
Limitações de tratamento de DLLs no Windows precisam da detecção automática do arquivo ns-httpdXX.dll mais recente. Isso é testado pelos servidores até a versão 6.1. Se uma versão mais nova do servidor Sun é usado, a detecção falha e nsapi_virtual() é desabilitada.
Se esse for o caso, tente o seguinte: Adicione o seguinte parâmetro para php4_init em magnus.conf/obj.conf:
Init fn=php4_init ... server_lib="ns-httpdXX.dll"
Você pode verificar o status usando a função phpinfo().
Nota: Mas esteja avisado: O suporte para nsapi_virtual() é EXPERIMENTAL!!!
Essa seção contem notas e dicas específicas para o » OmniHTTPd no Windows.
Nota: Você deve ler os passos de instalação do manual antes!
Um servidor dispoto em modo CGI está aberto para várias vulnerabilidades possíveis. Por favor, leia nossa seção de segurança CGI para aprender em como se defender de tais ataques.
Você precisa completar os passos a seguir para fazer o PHP funcionar com OmniHTTPd. A instalação descrita a seguir é para o executável CGI. OmniHTTPd tem suporte à SAPI, mas alguns testes mostraram que não é estável usar o PHP como módulo ISAPI.
Nota: Importante para usuários CGI Leia o faq sobre cgi.force_redirect para detalhes importantes. Essa diretiva precisa ter o valor 0.
Instale o servidor OmniHTTPd.
Clique com o botão direito no ícone azul do OmniHTTPd na barra do sistema e selecione Propriedades (Properties)
Clique em Configurações Globais do Servidor Web (Web Server Global Settings)
Na tab 'External', entre: virtual = .php | actual = c:\php\php.exe (use php-cgi.exe se você estiver instalando o PHP 5), e use o botão Adicionar (Add).
Na tab Mime, entre: virtual = wwwserver/stdcgi | actual = .php, e use o botão Adicionar (Add).
Clique em OK
Repita os passos 2 - 6 para cada extensão que você quiser associar com o PHP.
Nota: Alguns pacotes OmniHTTPd vem com suporte embutido ao PHP. Você pode escolher durante a instalação fazer uma configuração personalizada, e selecionar o componente PHP. Nós recomendamos que você use a versão mais nova dos binários do PHP. Alguns servidores OmniHTTPd vem com o PHP 4 beta, então você deve escolher não instalar o suporte embutido, mas instalar por conta própria. Se o servidor já estiver na sua máquina, use o botão Substituir (Replace) nos passos 4 e 5 para configurar a informação nova e correta.
Essa seção contem notas e dicas específicas para o » Sambar Server para Windows.
Nota: Você deve ler os passos de instalação do manual antes!
Essa lista descreve como instalar o módulo ISAPI para que funcione com o servidor Sambar no Windows.
Ache o arquivo chamado mappings.ini (no diretório de configuração) no diretório de instalação dp Sambar.
Abra o arquivo mappings.ini e adicione a seguinte linha sob [ISAPI]:
Exemplo #1 Configuração ISAPI do Sambar
#para o PHP 4 *.php = c:\php\php4isapi.dll #para o PHP 5 *.php = c:\php\php5isapi.dll
Agora reinicie o servidor Sambar para que as mudanças tenha efeito.
Nota: Se você deseja usar o PHP para se comunicar com recursos que estão guardados em um computador diferente em sua rede, então você precisará alterar a conta de usuário usada pelo Sambar Server Service. A conta padrão usada pelo Sambar Server Service é LocalSystem, que não tem acesso a recursos remotos. A conta pode ser modifica usando a opção Serviços (Services) dentro do das Ferramentas Administrativas (Administation Tools) do Painel de Controle (Control Panel) do Windows.
Essa seção contem notas e dicas específicas para o » Xitami no Windows.
Nota: Você deve ler os passos de instalação manual primeiro!
Essa lista descreve como configura o binário CGI do PHP para funcionar com Xitami no Windows.
Nota: Importante para usuários que instalaram o CGI Leia o faq sobre cgi.force_redirect para detalhes importantes. Essa diretiva precisa ser editada para 0. Se você quiser usar $_SERVER['PHP_SELF'] você tem que habilitar a diretiva cgi.fix_pathinfo.
Um servidor dispoto em modo CGI está aberto para várias vulnerabilidades possíveis. Por favor, leia nossa seção de segurança CGI para aprender em como se defender de tais ataques.
Assegure-se que o servidor web está rodando e aponte o seu browser para o console de administração do Xitami (normalmente http://127.0.0.1/admin), e clique em Configuração (Configuration).
Navegue para os Filtros (Filters), e ponha a extensão que o PHP deve avaliar (ex.: .php) no campo extensões de Arquivo (.xxx).
No comando ou script Filtro (Filter) ponha o caminho e o nome do seu executável CGI, ex.: C:\php\php.exe para o PHP 4, ou C:\php\php-cgi.exe para o PHP 5.
Pressione o ícone Salvar (Save).
Reinicie o servidor para as mudanças terem efeito.
Esse capítulo ensina como compilar PHP a partir dos fontes no Windows, usando as ferramentas da Microsoft. Para compilar o PHP com cygwin, veja o Instalação em sistemas Unix.
Para compilar e montar o PHP, você precisa de um Microsoft Development Environment. Os seguintes ambientes são suportados:
Embora VC6 (Microsoft Visual C++ 6.0) seja usado para executar oficiais compilações do Windows, ele não pode ser obtido do site da Microsoft. Novos usuários procurando compilar o PHP precisa usar Microsoft Visual C++ 2005 Express Edition e seus componentes auxiliares.
Nota: Combinado, estes componentes são muito extenso e requisitará um gigabyte de espaço de disco.
Configurando o Microsoft Visual C++ 2005 Express é melhor contido, e requer a instalação de três pacotes separados e várias mudanças de compatibilidades. Mantenha uma lista de caminhos no qual estes programas estão sendo instalados. Faça download e instale os seguintes programas:
Há vários passos pós-instalação:
Finalmente, quando usando MSVC 2005 Express na linha de comando, várias variáveis de ambiente precisam ser definidas. vsvars32.bat normalmente encontradas em C:\Program Files\Microsoft Visual Studio 8\Common7\Tools (pesquise pelo arquivo caso contrário) contém estas declarações. As variáveis de ambiente PATH, INCLUDE e LIB precisam corresponder aos diretórios bin, include e lib dos dois recentes instalados SDK adicionado para eles.
Nota: O caminho do .NET SDK pode já estar presente no arquivo vsvars32.bat, como esta instalação do próprio SDK no mesmo diretório que o Microsoft Visual C++ 2005 Express.
Para extrair os arquivos baixados, você precisará de uma ferramenta que descompacte arquivos ZIP. O Windows XP e os mais novos já incluem essa funcionalidade embutida.
Antes de você começar, você tem que baixar:
Finalmente, você precisará dos fontes do PHP. Você pode pegar a verão mais recente de desenvolvimento usando » login anônimo ao CVS, um » snapshot ou o release mais novo dos » fontes.
Depois de baixar os pacotes necessários, você tem que extrair eles em um lugar apropriado.
+--C:\work | | | +--bindlib_w32 | | | | | +--arpa | | | | | +--conf | | | | | +--... | | | +--php-5.x.x | | | | | +--build | | | | | +--... | | | | | +--win32 | | | | | +--... | | | +--win32build | | | | | +--bin | | | | | +--include | | | | | +--lib
Se você não estiver usando o » Cygwin, você também deve criar os diretórios C:\usr\local\lib e então copie o arquivo bison.simple de C:\work\win32build\bin para C:\usr\local\lib.
Nota: Se você quiser usar o PEAR e o conviniente instalador em linha de comando, o CLI-SAPI é necessário. Para mais informação sobre PEAR e o instalador leia a documentação no web site do » PEAR.
Você deve compilar a biblioteca resolv.lib. Decida se você quer ter símbolos de depuração disponíveis (bindlib - Win32 Debug) ou não (bindlib - Win32 Release), mas por favor, lembre-se da escolha que você fará, por que a biblioteca com os símbolos só montará com o PHP se o mesmo for montado em modo de depuração. Monte a configuração apropriada:
Esse capítulo explica como compilar o PHP >=5 usando o novo sistema de montagem, que é baseado em CLI e muito similar com o sistema de montagem principal do PHP no Unix.
Nota: Esse sistema de montagem não está disponível no PHP 4. Favor, ler Compilando a partir dos fontes se for o seu caso.
Antes de começar, assegure-se de let Compilando a partir dos fontes e que você compilou todas as bibliotecas necessárias, como » Libxml ou » ICU (necessária para o PHP >= 6).
Primeiro, você deve abrir um Prompt de Comando do Visual Strudio, que pode estar disponível no Menu Iniciar (Start Menu). Um Prompt de Comando comum não deve funcionar, uma vez que provavelmente as variáveis de ambiente necessárias não estão configuradas. Então digite algo como cd C:\work\php-5.x.x para entrar no diretório dos fontes do PHP. Agora se prepare para começar a configurar o PHP.
O segundo passo é executar o arquivo de lote buildconf para criar o script configure, procurando o diretório por arquivos config.w32. Via de regra, esse comando também procurará nos seguintes diretórios: pecl; ..\pecl; pecl\rpc; ..\pecl\rpc. A partir do PHP 5.1.0, vodê pode alterar esse comportamento usando o argumento --add-modules-dir (ex.: cscript /nologo win32/build/buildconf.js --add-modules-dir=../php-gtk2 --add-modules-dir=../pecl).
O terceiro passo é configurar. Para ver a lista de opções de configuração disponíveis, digite cscript /nologo configure.js --help. Depois de escolher as opções que você irá habilitar/desabilitar, digite algo como cscript /nologo configure.js --disable-foo --enable-fun-ext. Usar --enable-foo=shared tentará construir a extensão 'foo' como um módulo compartilhado, carregado dinâmicamente.
O último passo é compilar. Para isso, basta executar o comandocommand nmake. Os arquivos gerados (e.g. .exe e .dll) serão colocado ou nos diretórios Release_TS our Debug_TS (se compilado com Thread safety), ou no diretórios Release ou Debug caso contrário.
É opcional, mas você também pode executar os aplicativos de teste do PHP, executando nmake test. Se você quiser rodar apenas um teste específico, você pode user a variável 'TESTS' (ex.: nmake /D TESTS=ext/sqlite/tests test - só executará testes no sqlite). Para apagar esses arquivos que foram criados durante a compilação, você pode usar o comando nmake clean.
Uma opção de configuração muito útil para montar snapshots é --enable-snapshot-build, que adiciona un novo modo de compilação (nmake build-snap). Isso tenta montar cada extensão disponível (como compartilhada, por padrão), mas ignorará erros de montagem em extensões individuais ou SAPI.
Compilar o PHP usando os arquivos DSW não é suportado a partir do PHP5, já que um sistema mais flexível está disponível. De qualquer forma, você ainda pode usá-los, mas tenha em mente que ele não são testados freqüentemente, então você pode ter problemas de compilação. Para compilar o PHP 4 para Windows, no entanto, essa é a única opção disponível.
O próximo passo é configurar o MVC ++ para prepará-lo para compilar. Rode o Microsoft Visual C++, e do menu selecione Tools => Options. No diálogo que aparecerá, selecione o tab de diretórios. Depois, mude o dropdown para arquivos Executables, Includes, e Library. Suas configurações devem parecer com isso:
A melhor maneira de começar é compilando a versão CGI:
É possível fazer algumas personalizações mínimas para o processo de compilação editando o arquivo main/config.win32.h. Por exemplo, você pode muda a localização padrão do arquivo php.ini, as extensões integradas, e a localização padrão para suas extensões.
Depois, você pode querer montar a versão CLI que é feita para usar o PHP da linha de comando. Os passos são o mesmos para compilar a versão CGI, exceto que você tem que selecionar o arquivo de projeto php4ts_cli - Win32 Debug_TS ou php4ts_cli - Win32 Release_TS. Depois de uma compilação sucedida você encontrará o arquivo php.exe ou no diretório Release_TS\cli\ ou Debug_TS\cli\.
Para montar o módulo SAPI (php4isapi.dll) para integrar o PHP com o Microsoft IIS, modifique o seu arquivo de configuração para php4isapi-whatever-config e construa a dll desejada.
Depois de instalar o PHP e um servidor web no Windows, você provavelmente desejará instalar algumas extensões para ter funcionalidades extras. Você pode escolher quais extensões você quer que o PHP carregue quando é iniciado modificando o arquivo php.ini. Você também pode carregar um módulo dinamicamente no seu script usando dl().
Os DLLs para extensões do PHP são prefixadas com php_.
Many extensions are built into the Windows version of PHP. This means additional DLL files, and the extension directive, are not used to load these extensions. The Windows PHP Extensions table lists extensions that require, or used to require, additional PHP DLL files. Here's a list of built in extensions:
No PHP 4 (atualizado PHP 4.3.11): BCMath, Caledar, COM, Ctype, FTP, MySQL, ODBC, Overload, PCRE, Session, Tokenizer, WDDX, XML e Zlib
No PHP 5 (atualizado PHP 5.0.4), as seguintes mudanças existem. Embutido: DOM, LibXML, Iconv, SimpleXML, SPL e SQLite. E os seguintes não são mais embutidos: MySQL e Overload.
A localização padrão que o PHP procura por extensões é C:\php4\extensions no PHP 4 e C:\php5 no PHP 5. Para mudar esta configuração para refletir sua instalação do PHP, edite o arquivo php.ini:
Você precisará mudar a configuração extension_dirpara apontar o diretório onde suas extensões estão guardadas, ou onde você colocou os arquivos php_*.dll. Por exemplo:
extension_dir = C:\php\extensions
Habilite as extensão(ões) no arquivo php.ini que você quiser descomentando as linhas extension=php_*.dll. Isso é feito removendo o ; na antes da linha com a extensão que você quer carregar.
Exemplo #1 Habilitar a extensão Bzip2 para o PHP-Windows
// Mude a seguinte linha de ... ;extension=php_bz2.dll // ... para extension=php_bz2.dll
Algumas das extensões precisam de DLLs extras para funcionarem. Algumas delas podem ser encontradas no pacote da distribuição, na pasta C:\php\dlls\ no PHP 4 ou na pasta principal no PHP 5, mas algumas, por exemplo o Oracle (php_oci8.dll) requerem DLLs que não estão agregadas ao pacote da distribuição. Se você estiver instalando o PHP 4, copie as DLLs agregadas da pasta C:\php\dlls para a pasta principal C:\php. Não se esqueça de incluir C:\php na variável de ambiente PATH (esse processo é explicado em outra página, nesse FAQ).
Algumas destas dlls não sao embutidas com a distribuição do PHP. Veja a documentação de cada extensão para maiores detalhes. Também leia o manual na sessão entitulada Instalação de extensões PECL para detalhes sobre PECL. Um crestente número de extensões para o PHP são encontradas no PECL, e estas extensões precisam de um download separado.
Nota: Se você estiver executando a versão de módulo do servidor do PHP lembre de reiniciar o servidor web para que as mudanças no arquivo php.ini sejam efetivadas.
A tabela a seguir descreve algumas das extensões disponíveis e requer dlls adicionais.
| Extensão | Descrição | Notas |
|---|---|---|
| php_bz2.dll | Funções de Compressão de bzip2 | Nenhuma |
| php_calendar.dll | Funções de Conversão de Calendar | Integrado desde o PHP 4.0.3 |
| php_crack.dll | Funções de Crack | Nenhuma |
| php_ctype.dll | Família de Funções ctype | Integrado desde o PHP 4.3.0 |
| php_curl.dll | Biblioteca de Funções de Cliente URL - CURL | Requer: libeay32.dll, ssleay32.dll (agregado) |
| php_dba.dll | Camada de Funções de Abstração de Banco de Dados DBA | Nenhuma |
| php_dbase.dll | Funções de dBase | Nenhuma |
| php_dbx.dll | Funções dbx | |
| php_domxml.dll | Funções DOM XML | PHP <= 4.2.0 requer: libxml2.dll (agregado) PHP >= 4.3.0 requer: iconv.dll (agregado) |
| php_dotnet.dll | Funções .NET | PHP <= 4.1.1 |
| php_exif.dll | Funções EXIF | php_mbstring.dll. e, php_exif.dll devem ser carregados depois de php_mbstring.dll no arquivo php.ini. |
| php_fbsql.dll | Funções FrontBase | PHP <= 4.2.0 |
| php_fdf.dll | Funções de Formato de Dados de Formulários (Forms Data Format) FDF. | Requer: fdftk.dll (agregado) |
| php_filepro.dll | Funções de filePro | Acesso apenas de Leitura |
| php_ftp.dll | Funções de FTP | Integrado desde o PHP 4.0.3 |
| php_gd.dll | Funções da biblioteca de imagens GD | Removido no PHP 4.3.2. Note também que funções truecolor functions não estão disponíveis no GD1, ao invés, use php_gd2.dll. |
| php_gd2.dll | Funções da biblioteca de imagens GD | GD2 |
| php_gettext.dll | Funções de Gettext | PHP <= 4.2.0 requer gnu_gettext.dll (agregado), PHP >= 4.2.3 requer libintl-1.dll, iconv.dll (agregado). |
| php_hyperwave.dll | Funções de HyperWave | Nenhuma |
| php_iconv.dll | Conversão de tabela de caracteres ICONV | Requer: iconv-1.3.dll (agregado), PHP >=4.2.1 iconv.dll |
| php_ifx.dll | Funções de Informix | Requer: Informix libraries |
| php_iisfunc.dll | Funções de manuseio de IIS | Nenhuma |
| php_imap.dll | Funções de IMAP POP3 e NNTP | Nenhuma |
| php_ingres.dll | Funções de Ingres II | Requer: Ingres II libraries |
| php_interbase.dll | Funções de InterBase | Requer: gds32.dll (agregado) |
| php_java.dll | Funções de Java | PHP <= 4.0.6 requer: jvm.dll (agregado) |
| php_ldap.dll | Funções de LDAP | PHP <= 4.2.0 requer libsasl.dll (agregado), PHP >= 4.3.0 requer libeay32.dll, ssleay32.dll (agregado) |
| php_mbstring.dll | Funções de Multi-Byte String | Nenhuma |
| php_mcrypt.dll | Funções de Mcrypt Encryption | Requer: libmcrypt.dll |
| php_mhash.dll | Funções de Mhash | PHP >= 4.3.0 requer: libmhash.dll (agregado) |
| php_mime_magic.dll | Funções de Mimetype | Requer: magic.mime (agregado) |
| php_ming.dll | Funções de Ming para Flash | Nenhuma |
| php_msql.dll | Funções de mSQL | Requer: msql.dll (agregado) |
| php_mssql.dll | Funções de MSSQL | Requer: ntwdblib.dll (agregado) |
| php_mysql.dll | Funções de MySQL | PHP >= 5.0.0, requer libmysql.dll (agregado) |
| php_mysqli.dll | Funções de MySQLi | PHP >= 5.0.0, requer libmysql.dll (libmysqli.dll in PHP <= 5.0.2) (agregado) |
| php_oci8.dll | Funções de Oracle 8 | Requer: Oracle 8.1+ client libraries |
| php_openssl.dll | Funções de OpenSSL | Requer: libeay32.dll (agregado) |
| php_overload.dll | Funções de sobrecarga de objetos | Integrado desde o PHP 4.3.0 |
| php_pdf.dll | Funções de PDF | Nenhuma |
| php_pgsql.dll | Funções de PostgreSQL | Nenhuma |
| php_printer.dll | Funções de Impressora | Nenhuma |
| php_shmop.dll | Funções de Memória Compartilhada | Nenhuma |
| php_snmp.dll | Funções de get and walk de SNMP | Apenas no NT! |
| php_soap.dll | Funções de SOAP | PHP >= 5.0.0 |
| php_sockets.dll | Funções de Socket | Nenhuma |
| php_sybase_ct.dll | Funções de Sybase | Requer: bibliotecas de cliente do Sybase |
| php_tidy.dll | Funções de Tidy | PHP >= 5.0.0 |
| php_tokenizer.dll | Funções de Tokenizer | Integrado desde o PHP 4.3.0 |
| php_w32api.dll | Funções de W32api | Nenhuma |
| php_xmlrpc.dll | Funções de XML-RPC | PHP >= 4.2.1 requer: iconv.dll (agregado) |
| php_xslt.dll | Funções de XSLT | PHP <= 4.2.0 requer sablot.dll, expat.dll (agregado). PHP >= 4.2.1 requer sablot.dll, expat.dll, iconv.dll (agregado). |
| php_yaz.dll | Funções do YAZ | Requer: yaz.dll (agregado) |
| php_zip.dll | Funções para Arquivos Zip | Acesso apenas de leitura |
| php_zlib.dll | Funções de compressão de ZLib | Integrado desde o PHP 4.3.0 |
» PECL é um repositório de extensões PHP que estão disponíveis à você pelo sistema de pacote » PEAR. Essa seção do manual é destinada para demonstrar como obter e instalar extensões PECL.
Essas instruções presumem que /your/phpsrcdir/ seja o caminho para o código-fonte do PHP, e extname é o nome da extensão PECL. Ajuste de acordo com suas necessidades. Essas instruções também presumem uma familiaridade com o » comando pear. A informação no manual do PEAR para o comando pear também se aplica ao comando pecl.
Para ser útil, uma extensão deve ser compilada, instalada e carregada. Os métodos descritos abaixo descrevem várias instruções de como compilar e instalar as extensões, mas elas não são carregadas automaticamente. Extensões pode ser carregadas adicionando uma diretiva extension no arquivo php.ini ou pelo uso da função dl().
Quando montar módulos do PHP, é importante ter as versões apropriadas das ferramentas requiridas (autoconf, automake, libtool, etc). Veja as » Instruções para leitura anônima do CVS para detalhes sobre as ferramentas e versões necessárias.
Existem várias opções para baixar extensões PECL, tais como:
$ cvs -d:pserver:cvsread@cvs.php.net:/repository login
$ cvs -d:pserver:cvsread@cvs.php.net:/repository co pecl/extname
Como qualquer outra extensão DLL do PHP, mova as DLLs das extensões no diretório extension_dir e inclua elas no arquivo php.ini. Por exemplo:
extension=php_extname.dll
Depois disso, reinicie o servidor web.
PECL torna fácil criar extensões compartilhadas do PHP. Usando o » comando pecl, faça o seguinte:
$ pecl install extname
Isso baixará o código-fonte de extname, compilará e instalará extname.so no seu extension_dir. extname.so pode, então, ser carregado no arquivo php.ini
Por padrão, o comando pecl não instalará pacotes que estão marcados como alpha ou beta. Se nenhum pacote estável estiver disponível, você pode instalar um pacote beta usando o seguinte comando:
$ pecl install extname-beta
Você também pode instalar uma versão específica, usando essa forma:
$ pecl install extname-0.1
Nota: Depois de habilitada a extensão no php.ini, reiniciar o servidor web é requerido para as modificações funcionarem.
Algumas vezes, usar o instalador pecl não é uma opção. Isso pode acontecer se você estiver atrás de um firewall, ou porque a extensão que você quer instalar não está disponível como um pacote compatível com PECL, por exemplo, extensões ainda sem release no CVS. Se você precisar compilar tal extensão, você pode usar as ferramentas de compilação de baixo nível para realizar a compilação manualmente.
O comando phpize é usado para preparar o ambiente de compilação para uma extensão do PHP. No exemplo seguinte, os fontes para uma extensão estão em um diretório com nome extname:
$ cd extname $ phpize $ ./configure $ make # make install
Uma instalação bem sucedida criará um arquivo extname.so e o colocará no diretório de extensões do PHP. Você precisará ajustar o arquivo php.ini e acidionar uma linha extension=extname.so antes de usar a extensão.
Se o sistema não tiver o comando phpize, e pacotes pré-compilados são usados (como RPM's), certifique-se de instalar a versão devel apropriada do pacote do PHP, uma vez que eles freqüentemente contém o comando phpize assim como os arquivos de cabeçalho para compilar o PHP e suas extensões.
Execute phpize --help para mostra informações de uso adicionais.
Você pode decidir que precisa montar uma extensão PECL estaticamente no seu binário do PHP. Para isso, você precisará colocar os fontes da extensão no diretório php-src/ext/ e dizer para o sistema de montagem do PHP para regenerar o script configure.
$ cd /your/phpsrcdir/ext $ pecl download extname $ gzip -d < extname.tgz | tar -xvf - $ mv extname-x.x.x extname
Isso resultará no seguinte diretório:
/your/phpsrcdir/ext/extname
Daqui, faça o PHP reconstruir o script configure e monte o PHP normalmente:
$ cd /your/phpsrcdir $ rm configure $ ./buildconf --force $ ./configure --help $ ./configure --with-extname --enable-someotherext --with-foobar $ make $ make install
Nota: Para executar o script 'buildconf' você precisa de autoconf 2.13 e automake 1.4+ (versões mais novas do autoconf podem funcionar, mas não são suportadas).
Se --enable-extname ou --with-extname são usadas depende da extensão. Tipicamente, uma extensão que não requer bibliotecas externa usa --enable. Para ter certeza, rode o seguinte comando após buildconf:
$ ./configure --help | grep extname
Alguns problemas são mais comuns que outros. Os mais comuns estão listados no FAQ do PHP, parte desse manual.
Se você ainda estiver sem solução, alguém na lista de e-mail de instalação do PHP pode te ajudar. Você deve checar o histórico de mensagens antes, no caso de alguém já ter respondido outra pessoa que tenha tido o mesmo problema que você. Os históricos estão disponíveis na página de suporta em » http://www.php.net/support.php. Para se inscrever na lista de e-mail de instalação do PHP, envie um e-mail vazio para » php-install-subscribe@lists.php.net. O endereço da lista de e-mail é » php-install@lists.php.net.
Se você quiser pedir ajuda na lista de e-mail, por favor, tente ser preciso e dar os detalhes necessários sobre seu ambiente (qual sistema operacional, que versão do PHP, qual servidor web, se você está executando PHP com CGI ou módulo de servidor, safe mode, etc...), e, de preferência, código suficiente para permitir que outros reproduzam e testem seu problema.
Se você acha que encontrou um bug (falha) no PHP, por favor, relate. Os desenvolvedores do PHP provavelmente não sabem sobre ele, e, a não ser que você o relate, provavelmente ele não será reparado. Você pode relatar bugs usando o sistema de caça-bugs em » http://bugs.php.net/. Por favor, não mande relatos de bug nas listas de e-mail ou e-mails pessoais. O sistema de bugs também é adequado para o envio de requisição de características (features).
Leia o documento » Como relatar um bug antes de enviar qualquer relato de bug!
O arquivo de configuração (php.ini) é lido quando o PHP inicia. Para as versões de módulo de servidor, isso acontece apenas quando o servidor web for inicializado. Para as versões CGI e CLI, isso acontece à cada invocação.
php.ini é procurado nesses lugares (na ordem):
Local específico do módulo SAPI (diretiva PHPIniDir no Apache 2, -c opção de linha de comando quando CGI e CLI, parâmetro php_ini no NSAPI, variável de ambiente PHP_INI_PATH no THTTPD)
A variável de ambiênte PHPRC. Antes do PHP 5.2.0 isto era conferido depois da chave de registro mencionada abaixo.
A partir do PHP 5.2.0, os seguintes locais do registro são procurados em ordem: HKEY_LOCAL_MACHINE\SOFTWARE\PHP\x.y.z\IniFilePath, HKEY_LOCAL_MACHINE\SOFTWARE\PHP\x.y\IniFilePath and HKEY_LOCAL_MACHINE\SOFTWARE\PHP\x\IniFilePath, where x, y e z significam as versôes do PHP maior, menor e release.
HKEY_LOCAL_MACHINE\SOFTWARE\PHP\IniFilePath (Local no registro do Windows)
Diretório de trabalho atual (exceto CLI)
O diretório do servidor web (para módulo SAPI), ou diretório do PHP (caso contrário, no Windows)
Diretório do Windows (C:\windows ou C:\winnt) (para o Windows), ou ou a opção de tempo de compilação --with-config-file-path
Se php-SAPI.ini existe (onde SAPI é o SAPI usado, então o nome de arquivo é, por exemplo, php-cli.ini ou php-apache.ini), é usado ao invés do arquivo php.ini. nome SAPI pode ser determinado pela função php_sapi_name().
Nota: O servidor web Apache muda o diretório para raiz durante a inicialização, causando com que o PHP tente ler o arquivo php.ini da raiz do arquivo de sistema, se ele existir.
As diretivas do arquivo php.ini tratadas por extensões são documentadas respectivamente nas páginas das próprias extensões. A lista de diretivas principais está disponível no apêdice. No entanto, provavelmente nem todas as diretivas do PHP estão documentadas no manual. Para uma lista completa das diretivas disponíveis na sua versão do PHP, por favor leia seu arquivo php.ini. Também há alternativa de baixar a » última versão do arquivo php.ini dos repositórios do CVS, que pode ser de ajuda também.
Exemplo #1 php.ini example
; any text on a line after an unquoted semicolon (;) is ignored
[php] ; section markers (text within square brackets) are also ignored
; Boolean values can be set to either:
; true, on, yes
; or false, off, no, none
register_globals = off
track_errors = yes
; you can enclose strings in double-quotes
include_path = ".:/usr/local/lib/php"
; backslashes are treated the same as any other character
include_path = ".;c:\php\lib"
A partir do PHP 5.1.0, é possível acessar as variáveis .ini dentro dos arquivos .ini. Exemplo:open_basedir = ${open_basedir} ":/new/dir".
Quando usar o PHP como módulo do Apache, você pode mudar as configurações usando diretivas nos arquivos de configuração do Apache (ex.: httpd.conf e .htaccess). Você precisa de privilégios "AllowOverride Options" ou "AllowOverride All" para isso.
Há vários diretivas do Apache que você pode mudar a configuração do PHP de dentro dos arquivos dos arquivos de configuração do Apache. Para uma lista de quais diretivas são PHP_INI_ALL, PHP_INI_PERDIR, or PHP_INI_SYSTEM, olhe no apêndice Lista de diretivas do arquivo php.ini.
php_value
nome
valor
Configura o valor da diretiva especificada. Pode ser usado apenas com diretivas do tipo PHP_INI_ALL e PHP_INI_PERDIR. Para limpar um valor configurado anteriormente, use o valor none.
Nota: Não use
php_valuepara configurar valores booleanos.php_flag(veja abaixo) deve ser usada, ao invés.
php_flag
nome
on|off
Usado para configurar diretivas de configuração booleanas. Pode ser usada apenas com diretivas do tipo PHP_INI_ALL e PHP_INI_PERDIR.
php_admin_value
nome
valor
Configura o valor da diretiva especificada.
Isso não pode ser usado em arquivos .htaccess.
Qualquer tipo diretiva configurada com php_admin_value
não pode ser sobrescrita por diretivas .htaccess.
Para limpar um valor configurado anteriormente, use o valor none.
php_admin_flag
nome
on|off
Usado para configura diretiva de configuração booleana.
Isso não pode ser usado em arquivos .htaccess.
Qualquer tipo diretiva configurada com php_admin_flag
não pode ser sobrescrita por diretivas .htaccess.
Para limpar um valor configurado anteriormente, use o valor none.
Exemplo #1 Exemplo de configuração do Apache
<IfModule mod_php5.c>
php_value include_path ".:/usr/local/lib/php"
php_admin_flag safe_mode on
</IfModule>
<IfModule mod_php4.c>
php_value include_path ".:/usr/local/lib/php"
php_admin_flag safe_mode on
</IfModule>
Constantes PHP não existem fora do PHP. Por exemplo, no arquivo httpd.conf você não pode usar constantes do PHP como E_ALL ou E_NOTICE para configurar a diretiva error_reporting, já que elas não terão significado algum e serão avaliadas como 0. Ao invés, use os valores de bitmask associados. Essas constantes podem ser usados no arquivo php.ini
Quando executar o PHP no Windows, os valores de configuração pode ser modificados para cada diretório, usando o registro do Windows. Os valores de configuração são guardados na chave de registro HKLM\SOFTWARE\PHP\Per Directory Values, nas sub-chaves correspondentes aos caminhos dos diretórios. Por exemplo, valores para o diretório c:\inetpub\wwwroot estariam guardadas na chave HKLM\SOFTWARE\PHP\Per Directory Values\c\inetpub\wwwroot. As configurações para o diretório estariam ativos para qualquer script rodando desse diretório ou qualquer subdiretório dele. Os valores na chave devem ter o nome da diretiva de configuração do PHP e um valor string. Constantes do PHP nos valores não são avaliados. Entretanto, apenas valores de configurações modificáveis no PHP_INI_USER podem ser definidos desta maneira, valores PHP_INI_PERDIR não podem.
Independente de como você execute PHP, você pode mudar certos valore durante a execução de seus scripts através ini_set(). Veja a documentação na página ini_set() para mais informações.
Se você estiver interessado na lista completa de configurações no seu sistema com o valores atuais, você pode executar a função phpinfo() , e revisar a página resultante. Você pode também acessar os valores de configurações de diretivas individuais em tempo de execução usando ini_get() ou get_cfg_var().
Quando o PHP interpreta um arquivo, ele procura pelas tags de abertura e fechamento, as quais indicam para o PHP começar e parar de interpretar o código entre elas. interpretar desta maneira permite ao PHP ser embutido em todos os tipos de documentos diferentes, já que tudo fora o par de tags de abertura e fechamento é ignorado pelo interpretador do PHP. A maioria das vezes você verá o PHP embutido em documentos HTML como neste exemplo.
<p>Isto vai ser ignorado.</p>
<?php echo 'Enquanto isto vai ser interpretado.'; ?>
<p>Isto também vai ser ignorado.</p>
Você também pode usar estruturas mais avançadas:
Exemplo #1 Escapando de modo avançado
<?php
if ($expression) {
?>
<strong>Isto é verdadeiro.</strong>
<?php
} else {
?>
<strong>Isto é falso.</strong>
<?php
}
?>
Existem quatro diferentes pares de tags de abertura e fechamento que podem ser usados com o PHP. Duas dessas, <?php ?> e <script language="php"> </script>, estão sempre disponíveis. As outras duas são tags curtas e tags no estilo ASP, e podem ser ativadas e desativadas a partir do arquivo de configuração php.ini. Assim, enquanto algumas pessoas acham as tags curtas e tags no estilo ASP conveniente, elas são menos portáveis, e geralmente não recomendadas.
Nota: Também note que se você esta embutindo o PHP no XML ou XHTML você irá precisar usar as tags <?php ?> para permanecer cumprindo com os padrões.
Exemplo #2 Abrindo e Fechando as Tags do PHP
1. <?php echo 'se você quer servir documentos XHTML ou XML, faça assim'; ?>
2. <script language="php">
echo 'alguns editores (como FrontPage) não
gostam de instruções de processamento';
</script>
3. <? echo 'esta é a mais simples, uam instrução de processamento SGML'; ?>
<?= expressão ?> Isto é um atalho para "<? echo expressão ?>"
4. <% echo 'Você pode opcionalmente usar tags no estilo ASP'; %>
<%= $variavel; # Isto é um atalho para "<% echo . . ." %>
Enquanto as tags vistas nos exemplos um e dois estão ambas sempre disponíveis, o exemplo um é mais comumente usado, e recomendado, das duas.
Tags curtas (exemplo três) estão disponíveis apenas quando são ativadas pela configuração short_open_tag no arquivo php.ini ou se o PHP foi configurado com a opção --enable-short-tags.
Tags no estilo ASP (exemplo quatro estão disponíveis apenas quando elas estão ativadas atráves da diretiva de configuração asp_tags no arquivo php.ini.
Nota: O uso de tags curtas deve ser evitado ao desenvolver aplicações ou bibliotecas que serão redistribuidas, ou serão usadas em servidores PHP que não estão sobre o seu controle, porque as tags curtas podem não ser suportadas no servidor em questão. Para código portável, redistribuível, tenha certeza de não usar tags curtas.
Como no C ou Perl, o PHP requer que as instruções sejam terminadas com um ponto-e-vírgula ao final de cada comando. A tag de fechamento de um bloco de código PHP automaticamente implica em um ponto-e-vírgula; você não precisa ter um ponto-e-vírgula terminando a última linha de um bloco PHP. A tag de fechamento irá incluir uma nova linha logo após, se estiver presente.
<?php
echo 'Este é um teste';
?>
<?php echo 'Este é um teste' ?>
<?php echo 'Nós omitimos a última tag de fechamento';
Nota: A tag de fechamento de um bloco PHP ao final de um arquivo é opcional, e em alguns casos omiti-la é útil ao usar include() ou require(), assim espaço em branco indesejado não irá aparecer ao final dos arquivos, e você ainda será capaz de adicionar cabeçalhos a resposta após. Também é útil se você usar output buffering, e você não quer ter adicionado espaço em branco ao final de partes geradas por arquivos incluídos.
O PHP suporta comentários no estilo 'C', 'C++' e shell do Unix shell (estilo Perl). Por exemplo:
<?php
echo 'Isto é um teste'; // Estilo de comentário de uma linha em c++
/* Este é um comentário de múltiplas linhas
ainda outra linha de comentário */
echo 'Isto é ainda outro teste';
echo 'Um teste final'; # Este é um comentário de uma linha no estilo shell
?>
Os comentários de estilo "uma linha" apenas comentam até o final da linha ou do bloco PHP de código corrente, o que chegar primeiro. Isto significa que código HTML após // ... ?> ou # ... ?> SERÁ exibido: ?> interompe o modo PHP e retorna para o modo HTML, e // ou # não podem influenciar isto. Se a diretiva de configuração asp_tags estiver ativa, ela funciona da mesma maneira que // %> e # %>. Entretando, a tag </script> não interrompe o modo PHP em um comentário de uma linha.
<h1>Isto é um <?php # echo 'simples';?> exemplo.</h1>
<p>O cabeçalho acima irá dizer 'Isto é um exemplo'.</p>
Comentários no estilo 'C' termina ao primeiro */ encontrado. Tenha certesa de não aninhar comentários no estilo 'C'. É fácil fazer este engano se você esta tentando comentar grandes blocos de código.
<?php
/*
echo 'Isto é um teste'; /* Este comentário irá causar um problema */
*/
?>
O PHP suporta os oitos tipos primitivos.
São quatros tipos básicos:
Dois tipos compostos:
E finalmente dois tipos especiais:
Este manual também introduz alguns pseudo-tipos por razões de legibilidade:
E a pseudo-variável $... .
Algumas referências para o tipo "double" podem aparecer no manual. Considere o tipo double como sendo o float; os dois nomes existem por razões históricas.
O tipo de uma variável geralmente não é definido pelo programador: isto é decidido em tempo de execução pelo PHP, dependendo do contexto no qual a variável é usada.
Nota: Para checar o tipo e valor de uma expressão, utilize a função var_dump(). Para ter uma representação legível de um tipo para debugar, use a função gettype(). Para verificar por um certo tipo, não use gettype(), mas sim as funções is_tipo. Vejamos alguns exemplos:
<?php
$a_bool = TRUE; // um booleano
$a_str = "foo"; // uma string
$a_str2 = 'foo'; // uma string
$an_int = 12; // um inteiro
echo gettype($a_bool); // mostra: boolean
echo gettype($a_str); // mostra: string
// Se ele é um inteiro, incrementa-o com quatro
if (is_int($an_int)) {
$an_int += 4;
}
// Se $bool é uma string, mostre-a
// (não imprime nada)
if (is_string($a_bool)) {
echo "String: $a_bool";
}
?>
Para forçar a conversão de uma variável para um certo tipo, você pode converter (casting) a variável ou usar a função settype() nela.
Note que uma variável pode ser avaliada com valores diferentes em certas situações, dependendo de qual tipo ela é no momento. Para mais informações, veja a seção Manipulação de tipos. A tabela de conversão de tipos também pode ser útil, como mostra exemplos de comparações de vários tipos.
Este é o tipo mais fácil. Um booleano expressa um valor de verdade. Ele pode ser TRUE ou FALSE.
Nota: O tipo booleano foi introduzido no PHP 4.
Para especificar um literal booleano, use as palavras chave TRUE ou FALSE. Ambas são insensitivas ao caso.
<?php
$foo = True; // assimila o valor TRUE para $foo
?>
Usualmente você pode utilizar algum tipo de operador que retorne um valor booleano, e passá-lo para uma estrutura de controle.
<?php
// == é um operador que testa
// igualdade e retorna um booleano
if ($action == "mostrar_versao") {
echo "A versão é 1.23";
}
// isto não é necessário ...
if ($exibir_separadores == TRUE) {
echo "<hr>\n";
}
// ... porque você pode simplesmente escrever isso:
if ($exibir_separadores) {
echo "<hr>\n";
}
?>
Para converter explicitamente um valor para booleano, utilize-se dos modificadores (bool) ou (boolean). Entretanto, na maioria dos casos, você não precisa utilizar o modificador, desde que qualquer valor será convertido automaticamente se um operador, função ou estrutura de controle requerer um argumento booleano.
Veja também Manipulação de tipos.
Quando convertendo para booleano, os seguintes valores são considerados FALSE:
-1 é considerado TRUE, como qualquer valor não zero (negativos ou positivos)!
<?php
var_dump((bool) ""); // bool(false)
var_dump((bool) 1); // bool(true)
var_dump((bool) -2); // bool(true)
var_dump((bool) "foo"); // bool(true)
var_dump((bool) 2.3e5); // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array()); // bool(false)
var_dump((bool) "false"); // bool(true)
?>
Um inteiro é um número do conjunto Z = {..., -2, -1, 0, 1, 2, ...}.
Veja também: Inteiros de tamanho arbitrário / GMP, Números de ponto flutuante e Precisão arbitrária / BCMath.
Inteiros podem ser especificados em notação decimal (base 10), hexadecimal (base 16) ou octal (base 8), opcionalmente precedido de sinal (- ou +).
Para usar a notação octal, você precisa preceder o número com um 0 (zero). Para utilizar a notação hexadecimal, preceda número com 0x.
Exemplo #1 Literais inteiras
<?php
$a = 1234; // número decimal
$a = -123; // um número negativo
$a = 0123; // número octal (equivalente a 83 em decimal)
$a = 0x1A; // número hexadecimal (equivalente a 26 em decimal)
?>
decimal : [1-9][0-9]*
| 0
hexadecimal : 0[xX][0-9a-fA-F]+
octal : 0[0-7]+
integer : [+-]?decimal
| [+-]?hexadecimal
| [+-]?octal
Se um dígito inválido é passado para inteiro octal (i.e. 8 ou 9), o resto do número é ignorado.
Exemplo #2 Octal weirdness
<?php
var_dump(01090); // 010 octal = 8 decimal
?>
Se você especifica um número além dos limites do tipo inteiro, ele será interpretado como um ponto flutuante. Assim, se você realizar uma operação que resulte em um número além dos limites do tipo inteiro, um ponto flutuante será retornado também.
<?php
$ numero_grande = 2147483647;
var_dump($numero_grande);
// saida: int(2147483647)
$numero_grande = 2147483648;
var_dump($numero_grande);
// saida: float(2147483648)
// it's true also for hexadecimal specified integers between 2^31 and 2^32-1:
var_dump( 0xffffffff );
// output: float(4294967295)
// this doesn't go for hexadecimal specified integers above 2^32-1:
var_dump( 0x100000000 );
// output: int(2147483647)
$milhao = 1000000;
$numero_grande = 50000 * $milhao;
var_dump($numero_grande);
// saida: float(50000000000)
?>
Infelizmente, há um bug no PHP que faz que ele nem sempre trabalhe corretamente quando há números negativos envolvidos. Por exemplo, quando você faz -50000 * $milhao, o resultado será -429496728. Entretanto, quando ambos os operadores são positivos, isso não ocorre.
Isto foi resolvido no PHP 4.1.0.
Não há operador de divisão inteira no PHP. 1/2 retorna o ponto flutuante 0.5. Você pode moldar (cast) o valor para inteiro para sempre truncar o número, ou você pode usar a função round().
<?php
var_dump(25/7); // float(3.5714285714286)
var_dump((int) (25/7)); // int(3)
var_dump(round(25/7)); // float(4)
?>
Para converter explicitamente um valor para inteiro, utilize-se dos modificadores (int) ou (integer). Entretanto, na maioria dos casos, você não precisa utilizar o modificador, desde que qualquer valor será automaticamente convertido se um operador, função ou estrutura de controle requerer um argumento inteiro. Você também pode converter o valor de um inteiro com a função intval().
Veja também Manipulação de tipos.
FALSE será retornado como 0 (zero), e TRUE como 1 (um).
Quando convertendo de números de ponto flutuante para inteiros, o número será truncado.
Se o número convertido estiver além dos limites de um inteiro (usualmente +/- 2.15e+9 = 2^31), o resultado é indefinido, mesmo porque o ponto flutuante não tem a mesma precisão para fornecer um resultado inteiro exato. Não se preocupe, pois nenhum aviso será emitido neste caso!
Nunca modifique uma fração desconhecida para inteiro, porque isto pode fornecer resultados inesperados as vezes.
<?php
echo (int) ( (0.1+0.7) * 10 ); // imprime 7!
?>
O comportamento da conversão de um inteiro é indefinido de outros tipos. Atualmente, o comportamento é o mesmo como se primeiro o valor fosse convertido para booleano. Entretanto, não confie neste comportamento, pois ele pode mudar sem aviso.
Números de ponto flutuante (AKA "floats", "doubles" ou "números reais") podem ser especificados utilizando qualquer uma das sintaxes seguintes:
<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
?>
LNUM [0-9]+
DNUM ([0-9]*[\.]{LNUM}) | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM ( ({LNUM} | {DNUM}) [eE][+-]? {LNUM})
É sabido que frações simples como 0.1 ou 0.7 não podem ser convertidos em sua representação binária interna sem uma pequena perda de precisão. Isto pode causar erros confusos: por exemplo, floor((0.1+0.7)*10) irá retornar 7 em vez do esperado 8, como resultado da representação interna realmente ser algo como 7.9999999999....
Isto está relacionado ao fato de que é impossível expressar, exatamente, algumas frações em notação decimal com um número finito de dígitos. Por exemplo, 1/3 na forma decimal se torna 0.3333333. . ..
Então, nunca confie em resultados com números de ponto flutuante até a última casa e nunca compare números de ponto flutuante em igualdades. Se você realmente precisar de alta precisão, você pode utilizar as funções matemáticas de precisão arbitrária ou as funções relacionadas ao gmp.
Para informações em como e quando strings são convertidas para floats, veja a seção entitulada Conversão de Strings para números. Para valores de outros tipos, a conversão é a mesma se o valor puder ser convertido para inteiro e então para float. Veja a seção Convertendo para inteiro para mais informações. No PHP 5, aviso é emitido se você tentar converter objeto para float.
Uma string é uma série de caracteres. No PHP, um caracter é o mesmo que um byte, ou seja, há exatamente 256 caracteres diferentes possíveis. Isto implica que o PHP não tem suporte nativo ao Unicode. Veja utf8_encode() e utf8_decode() para suporte ao Unicode.
Nota: Não há nenhum problema nas strings se tornarem muito grandes. Não há nenhum limite para o tamanho de strings imposta pelo PHP, então não há razão para se preocupar com strings longas.
Uma string literal pode ser especificada de três formas diferentes.
A maneira mais simples para especificar uma string é delimitá-la entre apóstrofos (o caracter ').
Para especificar um apóstrofo. você precisará "escapá-la" com uma contra barra (\), como em muitas outras linguagens. Se uma contra barra precisa ocorrer antes de um apóstrofo ou no final da string, você precisa duplicá-la. Note que se você tentar escapar qualquer outro caracter, a contra barra também será impressa! Então geralmente não é necessário escapar a própria contra barra.
Nota: No PHP 3, um aviso com nível E_NOTICE será emitido quando isto acontecer.
Nota: Diferentemente das duas outras sintaxes, variables e seqüências de escape para caracteres especiais não serão substituídas quando elas ocorrerem dentro de strings delimitadas por apóstrofes.
<?php
echo 'isto é uma string comum';
echo 'Você pode incluir novas linhas em strings,
dessa maneira que estará
tudo bem';
// Imprime: Arnold disse uma vez: "I\'ll be back"
echo 'Arnold once said: "I\'ll be back"';
// Imprime: Você tem certeza em apagar C:\*.*?
echo 'Você tem certeza em apagar C:\\*.*?';
// Imprime: Você tem certeza em apagar C:\*.*?
echo 'Você tem certeza em apagar C:\*.*?';
// Imprime: Isto não será substituido: \n uma nova linha
echo 'Isto não será substituido: \n uma nova linha';
// Imprime: Variaveis $também não $expandem
echo 'Variaveis $também não $expandem';
?>
Se a string é delimitada entre aspas ("), o PHP entende mais seqüências de escape para caracteres especiais:
| Seqüência | Significado |
|---|---|
| \n | fim de linha (linefeed ou LF ou 0x0A (10) em ASCII) |
| \r | retorno de carro (carriage return ou CR ou 0x0D (13) em ASCII) |
| \t | TAB horizontal (HT ou 0x09 (9) em ASCII) |
| \v | TAB vertical (VT ou 0x0B (11) em ASCII) (desde o PHP 5.2.5) |
| \f | form feed (FF ou 0x0C (12) em ASCII) (desde o PHP 5.2.5) |
| \\ | contra barra ou barra invertida |
| \$ | sinal de cifrão |
| \" | aspas |
| \[0-7]{1,3} | a seqüência de caracteres batendo a expressão regular dos caracteres em notação octal |
| \x[0-9A-Fa-f]{1,2} | a seqüência de caracteres batendo a expressão regular de um caracter em notação hexadecimal |
Novamente se você tentar escapar qualquer outro caracter, a contra barra será impressa também! Antes do PHP 5.1.1, contra barra em \{$var} não era exibida.
Mas o mais importante recurso de strings delimitadas por aspas está no fato de que nome de variáveis serão substituídos. Veja interpretação de strings para detalhes.
Outra maneira para delimitar strings é utilizando a sintaxe heredoc ("<<<"). É informado um identificador (seguido por nova linha) depois de <<<, então a string, e então o mesmo identificador para fechar a delimitação.
O identificador de fechamento precisa começar na primeira coluna da linha. Além, o identificador utilizado precisa seguir as mesmas regras de nomeação que qualquer outro rótulo no PHP: só pode conter caracteres alfanuméricos e sublinhados, e precisa começar com um caracter não numérico ou sublinhado.
É muito importante verificar que a linha do identificador de fechamento não contenha nenhum outro caracter, exceto, possivelmente um ponto e vírgula (;). O que significa que o identificador não pode ser indentado, e que não pode haver nenhum espaço ou tabulações antes ou depois do ponto e vírgula. É também importante perceber que o primeiro caracter antes do identificador de fechamento precisa ser um caracter de nova linha como esperada por seu sistema operacional. Por exemplo, \r em sistemas Macintosh. Fechando delimitador (possivelmente seguido por um ponto e vírgula) precisa ser seguido por newline também.
Se essa regra for quebrada e o identificador de fechamento não estiver perfeito, então ele não será considerado como identificador de fechamento e o PHP irá continuar procurando por um. Se, neste caso, um identificador de fechamento apropriado não for encontrado, então um erro de interpretação (parse) será lançado na linha final do script.
Não é permitido usar sintaxe heredoc na inicialização de membros da classe. Ao inves, use outra sintaxe para strings.
Exemplo #1 Exemplo inválido
<?php
class foo {
public $bar = <<<EOT
bar
EOT;
}
?>
Textos heredoc se comportam como strings delimitadas por aspas, com apenas uma diferença. Você não precisa escapar apóstrofos e aspas em seus heredocs, mas você ainda pode continuar utilizando os códigos de escape listados acima. Variáveis são substituídas, mas o mesmo cuidado precisa ser tomado quando expressando variáveis complexas dentro de heredocs assim como nas strings.
Exemplo #2 Exemplo de delimitação de strings heredoc
<?php
$str = <<<EOD
Exemplo de uma string
distribuída em várias linhas
utilizando a sintaxe heredoc.
EOD;
/* Exemplo mais complexo, com variáveis */
class foo
{
var $foo;
var $bar;
function foo()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}
$foo = new foo();
$name = 'Meu nome';
echo <<<EOT
Meu nome é "$name". Eu estou imprimindo $foo->foo.
Agora, eu estou imprimindo {$foo->bar[1]}.
Isto deve imprimir um 'A' maiúsculo: \x41
EOT;
?>
Nota: O suporte a heredoc foi acrescentado no PHP 4.
Quando uma string é especificada dentro de aspas ou heredoc, variáveis são interpretadas dentro delas.
Há dois tipos de sintaxe: um simples e um complexo . A sintaxe simples é a mais comum e conveniente, provendo uma maneira de interpretar uma variável, um valor de array ou uma propriedade de object.
A sintaxe completa foi introduzida no PHP 4, e pode ser reconhecida por chaves ({}) envolvendo a expressão.
Se um sinal de cifrão ($) é encontrado, o interpretador tentará obter tantos identificadores quanto possíveis para formar um nome de variável válido. Envolva o nome da variável com chaves se você deseja explicitamente especificar o fim do nome.
<?php
$cerveja = 'Heineken';
echo "O sabor das '$cerveja's é otimo"; // funciona, "'" é um caracter inválido para nome de variáveis
echo "Ele bebeu algumas $cervejas"; // não funciona, 's' é um caracter válido para nome de variáveis
echo "Ele bebeu algumas ${cerveja}s"; // funciona
echo "Ele bebeu algumas {$cerveja}s"; // funciona
?>
Similarmente, você também pode interpretar um índice de array ou uma propriedade de objeto. Com índices de arrays, o colchete de fechamento (]) marca o final do índice. Para propriedades de objetos se aplicam as mesmas regras das variáveis comuns, embora não exista um truque para as propriedades de objetos como para as variáveis.
<?php
// Esses exemplos são específicos para utilização de arrays dentro de strings
// Quando fora de strings, sempre delimite suas chaves de array strings
// e nao use {colchetes} fora das strings tambem.
// Vamos ver todos os erros
error_reporting(E_ALL);
$fruits = array('morango' => 'vermelho', 'banana' => 'amarelo');
// Funciona, mas note que funciona de maneira diferente fora dos delimitadores de strings
echo "A banana é $fruits[banana].";
// Funciona
echo "A banana é {$fruits['banana']}.";
// Funciona, mas o PHP procura por uma constante chamada 'banana' antes,
// como descrito a seguir
echo "A banana é {$fruits[banana]}.";
// Nao funciona, use colchetes. Isto lanca um parse error.
echo "A banana é $fruits['banana'].";
// Funciona
echo "A banana é " . $fruits['banana'] . ".";
// Funciona
echo "Este quadrado tem $square->width metros de lado.";
// Nao funciona. Para uma solução, veja a sintaxe complexa.
echo "Este quadrado tem $square->width00 centímetros de lado.";
?>
Para qualquer coisa mais complexa, você precisa utilizar a sintaxe complexa.
Isto não é chamado sintaxe complexa porque a sintaxe em si é complexa, mas porque você pode incluir expressões complexas desta maneira.
De fato, você pode incluir qualquer valor no que esteja no espaço de nomes dentro de strings com esta sintaxe. Você simplesmente escreve a expressão da mesma maneira que faria fora da string, e então incluí-la entre chaves. Desde que você não pode escapar '{', esta sintaxe somente será reconhecida quando o $ é imediatamente seguido de um {. (Utilize "{\$" para obter um literal "{$"). Alguns exemplos para tornar isso mais claro:
<?php
// Vamos ver todos os erros
error_reporting(E_ALL);
$bom = 'fantastico';
// Não funciona, imprimindo: Isto é { fantastico}
echo "Isto é { $bom}";
// Funciona, imprimindo: Isto é fantástico
echo "Isto é {$bom}";
echo "Isto é ${bom}";
// Funciona
echo "Este quadrado tem {$square->width}00 centímetros de lado.";
// Funciona
echo "Isto funciona: {$arr[4][3]}";
// Isto está errado pela mesma razao que $foo[bar] é errado
// fora de uma string. Em outras palavras, isto ainda funciona MAS
// porque o PHP primeiro procura pro uma constante nomeada foo, e ele
// lancara um erro do tipo E_NOTICE (undefined constant).
echo "Isto é errado: {$arr[foo][3]}";
// Funciona. Quanto mexendo com arrays multi dimensionais, sempre use
// colchetes em volta dos arrays quando detro de strings
echo "Isto funciona: {$arr['foo'][3]}";
// Funciona
echo "Isto funciona: " . $arr['foo'][3];
echo "Você pode escrever também {$obj->values[3]->name}";
echo "Este é o valor da variável chamada $name: {${$name}}";
echo "Este é o valor da variável usando o valor retornado da getName(): {${getName()}}";
echo "Este é o valor da variável usando o valor retornado da \$object->getName(): {${$object->getName()}}";
?>
Nota: Chamada de funções e métodos dentro de {$ } funcionam desde o PHP 5.
Nota: Analisando variáveis dentros de strings usa mais memória que concatenação de strings. Quando escrevendo um script PHP no qual uso de memória é fundamental, considere usar o operador de concatenação (.), pois é melhor que analisar a string.
Caracteres nas strings podem ser acessados e modificados apenas especificando o deslocamento baseado em zero do caracter desejado depois da string dentro de colchetes, como um array, $str[42] então pense na string como um array de caracteres.
Nota: Elas podem também ser acessada usando colchetes, como $str{42} para o mesmo propósito. Contudo, usar colchete é preferível porque {chaves} é obsoleto no PHP 6.
Exemplo #3 Alguns exemplos com strings
<?php
// Pega o primeiro caracter da string
$str = 'Isto é um teste.';
$first = $str[0];
// Pega o terceiro caracter da string
$third = $str[2];
// Pega o último caracter da string
$str = 'Isto ainda é um teste.';
$last = $str[strlen($str)-1];
// Modifica o ultimo caracter da string
$str = 'Olhe o mal';
$str[strlen($str)-1] = 'r';
// Método alternativo usando {} obsoleto no PHP 6
$third = $str{2};
?>
Nota: Acessando por [] ou {} variáveis de outro tipo é retornado NULL sem emitir aviso.
Strings podem ser concatenados utilizando o operador '.' (ponto). Note que o operador '+' (adição) não funciona para isso. Veja operadores de string para mais informações.
Há uma grande quantidade de funções úteis para modificação de strings.
Veja a seção de funções de string para funções gerais e funções de expressões regulares para busca e substituição avançada.(em dois sabores: Perl e POSIX estendido).
Há também funções para strings URL e funções para criptografia e descriptografia de strings (mcrypt e mhash).
Finalmente, se você ainda não encontrar o que está procurando, veja também as funções de tipos de caracteres.
Você pode converter um valor para string utilizando o molde (string), ou a função strval(). Conversão para string é automaticamente realizada no escopo de uma expressão para você onde uma string é necessária. Isto acontece quando você usa as funções echo() ou print(), ou quando você compara o valor de uma variável com uma string. Lendo as seções do manual sobre Tipos e Conversão de Tipos tornará o que se segue um pouco mais claro. Veja também settype().
O valor boolean TRUE é convertido para a string "1", o valor FALSE é representado como "" (string vazia). Desta forma, você pode converter livremente entre os tipos booleano e string.
Um integer ou número de ponto flutuante (float) é convertido para a representação string do número em dígitos arábicos (incluindo a parte expoente para números de ponto flutuante). Números de ponto flutuante podem ser convertidos usando a notação exponencial (4.1E+6).
Nota: O caractere de ponto decimal é definido no locale do script (categoria LC_NUMERIC). Veja setlocale().
Arrays são sempre convertidos para a string "Array", então você não pode exportar o conteúdo de um array com echo() ou print() para ver o que há dentro dela. Para ver um elemento, você precisa fazer algo como echo $arr['foo']. Veja abaixo dicas de como exportar/ver todo seu conteúdo.
Objetos no PHP 4 são sempre convertidos para a string "Object". Se você quiser imprimir os valores das variáveis membro de um object por razão de debug, leia os parágrafos abaixo. Se você quiser encontrar o nome da classe do qual o objeto é uma instância, use get_class(). No PHP 5, o método __toString() é usado se aplicável.
Recursos são sempre convertidos para strings na estrutura "Resource id #1" onde 1 é o número único do resource assimilado pelo PHP na execução. Se você quiser obter o tipo do recurso, utilize get_resource_type().
NULL é sempre convertido para uma string vazia.
Como você viu acima, imprimir arrays, objetos ou recursos não fornece qualquer informação útil sobre os seus próprios valores. Veja as funções print_r() e var_dump() para melhores maneiras de imprimir valores para debug.
Você também pode converter valores PHP para strings para armazená-los permanentemente. Este método é chamado serialização, e pode ser feito com a função serialize(). Você também pode serializar valores PHP para estruturas XML , se você ativou o suporte a WDDX na configuração do seu PHP.
Quando uma string é avaliada como um valor numérico, o valor resultante e o tipo é determinado como segue.
A string será avaliada como um ponto flutuante se conter qualquer um dos caracteres '.', 'e', ou 'E'. Em outros casos, ela será avaliada como um inteiro.
O valor é obtido da porção inicial da string. Se a string começa com dados numéricos válidos, esse será o valor utilizado. Em outro caso, o valor será 0 (zero). Dados numéricos válidos são: um sinal opcional, seguido por um ou mais dígitos (opcionalmente contendo um ponto decimal), seguido de um expoente, também opcional. O expoente é um 'e' ou 'E' seguido de um ou mais dígitos.
<?php
$foo = 1 + "10.5"; // $foo é float (11.5)
$foo = 1 + "-1.3e3"; // $foo é float (-1299)
$foo = 1 + "bob-1.3e3"; // $foo é integer (1)
$foo = 1 + "bob3"; // $foo é integer (1)
$foo = 1 + "10 Small Pigs"; // $foo é integer (11)
$foo = 4 + "10.2 Little Piggies"; // $foo é float (14.2)
$foo = "10.0 pigs " + 1; // $foo é float (11)
$foo = "10.0 pigs " + 1.0; // $foo é float (11)
?>
Para mais informações sobre esta conversão, veja página do manual UNIX de strtod(3).
Se você deseja testar qualquer um dos exemplo dessa seção, você pode copiar e colar os exemplos e inserir as linhas seguintes para ver por si mesmo como isso funciona.
<?php
echo "\$foo==$foo; tipo " . gettype ($foo) . "<br />\n";
?>
Não espere obter o código de um caracter por convertê-lo para inteiro (como você teria em C, por exemplo). Use as funções ord() e chr() para converter entre código de caracteres e os próprios caracteres.
Um array no PHP é atualmente um mapa ordenado. Um mapa é um tipo que relaciona valores para chaves. Este tipo é otimizado de várias maneiras, então você pode usá-lo como um array real, ou uma lista (vetor), hashtable (que é uma implementação de mapa), dicionário, coleção, pilha, fila e provavelmente mais. Como você pode ter outro array PHP como um valor, você pode facilmente simular árvores.
A explicação dessas estruturas estão além do escopo desse manual, mas você pode encontrar exemplos para cada uma dessas estruturas a seguir. Para mais informações sobre estruturas, refira-se a literatura externa sobre esses tópicos.
Um array pode ser criado com o construtor de linguagem array(). Ele pega um certo número de pares separados por vírgula chave => valor .
array( chave => valor , ... ) // chave pode ser tanto string ou um integer // valor pode ser qualquer coisa
<?php
$arr = array("foo" => "bar", 12 => true);
echo $arr["foo"]; // bar
echo $arr[12]; // 1
?>
A chave pode ser tanto um integer ou uma string. Se a chave é uma representação padrão de um integer, ele será interpretado assim (por exemplo, "8" será interpretado como 8, enquanto "08" será interpretado como "08"). Flotas em key são truncados para integer. Não há diferença entre arrais indexados e associativos em PHP, apenas um tipo de array, que pode ter índices inteiros ou string.
O valor pode ser qualquer tipo PHP:
<?php
$arr = array("somearray" => array(6 => 5, 13 => 9, "a" => 42));
echo $arr["somearray"][6]; // 5
echo $arr["somearray"][13]; // 9
echo $arr["somearray"]["a"]; // 42
?>
Se omitir a chave quando fornece um novo item, o maior índice inteiro é obtido, e a nova chave será esse máximo + 1. Se você especificar uma chave que já possui um valor assimilada a ela, então o valor é sobrescrito.
<?php
// Esse array é como ...
array(5 => 43, 32, 56, "b" => 12);
// ... este array
array(5 => 43, 6 => 32, 7 => 56, "b" => 12);
?>
A partir do PHP 4.3.0, o comportamento da geração de índice descrito acima foi modificado. Agora, se você aumentar um array em que o maior índice atual for negativo, então a próxima chave criada será zero (0). Antes, o novo índice seria o maior índice existente mais 1, do mesmo jeito que os índices positivos.
Utilizar TRUE como chave será interpretado como o integer 1 na chave. Utilizando FALSE como chave será avaliado como o integer 0. Usar NULL como chave é interpretado como uma string vazia. Usar uma string vazia como chave irá criar (ou sobrescerver) uma chave com uma string vazia e seu valor, e isto não é o mesmo que usar colchetes vazios.
Você não pode usar arrays ou objetos como chaves. Fazendo isso resultará em um alerta: Illegal offset type.
Você pode também modificar um array existente explicitamente assimilando valores nele.
Isto é feito apenas assimilando valores para o array enquanto especificando a chave em colchetes. Você pode omitir a chave, colocando um par vazio de colchetes ("[]").
$arr[chave] = valor; $arr[] = valor; // chave tanto um integer ou string // valor pode ser qualquer coisaSe $arr não existir ainda, ele será criado. Então isto é um meio alternativo para especificar um array. Para mudar um certo valor, apenas assimile um novo valor para um elemento especificado por sua chave. Se você quiser remover um par chave/valor, você precisa aplicar unset() nele.
<?php
$arr = array(5 => 1, 12 => 2);
$arr[] = 56; // Isto é o mesmo que $arr[13] = 56;
// nesse ponto do script
$arr["x"] = 42; // Isto acrescenta um novo elemento
// para o array com a chave "x"
unset($arr[5]); // Isto remove um elemento do array
unset($arr); // E isto apaga todo o array
?>
Nota: Como mencionado acima, não informar a chave dentro dos colchetes, então o maior índice inteiro é obtido, e a nova chave será esse máximo + 1. Se nenhum índice inteiro existir ainda, a chave será 0 (zero). Se você especificar uma chave que já possui um valor assimilada a ela, então o valor é sobrescrito.
AvisoA partir do PHP 4.3.0, o comportamento da geração de índice descrito acima foi modificado. Agora, se você aumentar um array em que o maior índice atual for negativo, então a próxima chave criada será zero (0). Antes, o novo índice seria o maior índice existente mais 1, do mesmo jeito que os índices positivos.
Note que a chave inteira maior utilizada para isso não precisa necessariamente existir no array. Ele pode ter existido no array desde a última vez que o array foi indexado. Veja o seguinte exemplo:
<?php
// Criando um array normal
$array = array(1, 2, 3, 4, 5);
print_r($array);
// Agora apagando todos os itens, mas deixando o array intacto:
foreach ($array as $i => $value) {
unset($array[$i]);
}
print_r($array);
// Acrescentando um item (note que a chabe é 5, em vez de zero
// como voce pode ter esperado).
$array[] = 6;
print_r($array);
// Reindexando:
$array = array_values($array);
$array[] = 7;
print_r($array);
?>O exemplo acima irá imprimir:
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 ) Array ( ) Array ( [5] => 6 ) Array ( [0] => 6 [1] => 7 )
Há uma série de funções muito úteis para trabalhar com arrays. Veja a seção sobre arrays.
Nota: A função unset() permite apagar chaves de um array. Esteja avisado que o array NÃO vai ser reindexado. Se você somente usa "índices inteiros comuns" (começando do zero, aumentando um a um), você pode conseguir reindexar o aaray utilizando array_values().
<?php
$a = array( 1 => 'um', 2 => 'dois', 3 => 'três' );
unset( $a[2] );
/* irá produzir um array que pode ser definido como
$a = array( 1=>'um', 3=>'três');
e NÃO
$a = array( 1 => 'um', 2 => 'três');
*/
$b = array_values($a);
// Agora $b é o array(1 => 'um', 2 =>'três')
?>
foreach existe especificamente para lidar com arrays. Ele provém uma maneira fácil de percorrer qualquer array.
Você sempre deve usar delimitadores em volta um índice de um array associativo. Por exemplo, utilizar $foo['bar'] e não $foo[bar]. Mas porque $foo[bar] está errado? Afinal de contas, você vê essa sintaxe nos scripts antigos:
<?php
$foo[bar] = 'inimigo';
echo $foo[bar];
// etc
?>
Nota: Isto não significa que você sempre deve delimitar as chaves nos arrays. Você não deve delimitar chaves que sejam constantes ou variáveis, porque isso vai impedir o PHP de interpretá-las.
O exemplo acima irá imprimir:<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);
// Arrays simples:
$array = array(1, 2);
$count = count($array);
for ($i = 0; $i < $count; $i++) {
echo "\nVerificando $i: \n";
echo "Ruim: " . $array['$i'] . "\n";
echo "Bom: " . $array[$i] . "\n";
echo "Ruim: {$array['$i']}\n";
echo "Bom: {$array[$i]}\n";
}
?>
Verificando 0: Notice: Undefined index: $i in /path/to/script.html on line 9 Ruim: Bom: 1 Notice: Undefined index: $i in /path/to/script.html on line 11 Ruim: Bom: 1 Verificando 1: Notice: Undefined index: $i in /path/to/script.html on line 9 Ruim: Bom: 2 Notice: Undefined index: $i in /path/to/script.html on line 11 Ruim: Bom: 2
Mais exemplos para demonstrar esse fato:
<?php
// Vamos ver todos os erros
error_reporting(E_ALL);
$arr = array('fruta' => 'maçã', 'legume' => 'cenoura');
// Correto
print $arr['fruta']; // maçã
print $arr['legume']; // cenoura
// Errado. Isto funciona mas lança um erro PHP do
// nível E_NOTICE porque é utilizada uma constante indefinida (fruta)
//
// Repare: Quando utiliza-se a constrante indefinida fruta, o PHP assume 'fruta'
print $arr[fruta]; // maçã
// Agora vamos definir uma constante para demonstrar o que pode acontecer. Nós
// vamos assimilar o valor 'legume' para a constante de nome fruta
define('fruta', 'legume');
// Observe a diferenca agora
print $arr['fruit']; // maçã
print $arr[fruit]; // cenoura
// O exemplo seguinte é normal dentro de uma string. Constantes não são
// observadas dentro de strings e por isso nenhum E-NOTICE não é lançado aqui
print "Olá $arr[fruta]"; // Olá maçã
// Com uma exceção: chaves envolvendo arrays dentro de strings
// ativam a checagem de constantes, como em
print "Olá {$arr[fruta]}"; // Hello cenoura
print "Olá {$arr['fruta']}"; // Hello maçã
// E isso não funciona, resultando em um erro de interpretação do tipo:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Isso se aplica ao uso de superglobais em strings
print "Olá $arr['fruta']";
print "Olá $_GET['foo']";
// Nesse caso, use concatenacao
print "Olá " . $arr['fruta']; // Olá maçã
?>
Quando você ativa error_reporting() para mostrar erros de nível E_NOTICE (como configurando-a para E_ALL) você vê esses erros. Por padrão, error_reporting esté configurada para não mostrar esse nível de erro.
Como explicado na seção sintaxe, a chave precisa estar entre colchetes ('[' e ']'). Isto significa que você pode escrever coisas como isso:
<?php
echo $arr[algumafuncao($bar)];
?>
<?php
$error_descriptions[E_ERROR] = "Um erro fatal ocorreu";
$error_descriptions[E_WARNING] = "O PHP emitiu um alarme";
$error_descriptions[E_NOTICE] = "Apenas um aviso informal";
?>
<?php
$error_descriptions[1] = "Um erro fatal ocorreu";
$error_descriptions[2] = "O PHP emitiu um alarme";
$error_descriptions[8] = "Apenas um aviso informal";
?>
Como nós mostramos nos exemplos anteriores, $foo[bar] funciona mas está errado. Funciona porque bar, na sintaxe onde é utilizada é esperada como uma expressão constante. Entretanto, nesse caso não existe constante com o nome bar. O PHP, hoje, assume que você quer bar literalmente, como a string "bar", mas que você esqueceu de escrever os delimitadores.
Se em algum ponto do futuro, o time do PHP quiser acrescentar outra constante ou palavra chave, ou você mesmo introduzir outra constante na sua aplicação, você terá problemas. Por exemplo, se você já não pode utilizar as palavras empty e default dessa maneira, desde que elas são palavras reservadas especiais.
Nota: Só para fixar, dentro de uma string delimitada por aspas, é válido não englobar índices de arrays com apóstrofos, de forma que "$foo[bar]" é válido. Veja os exemplos anteriores para detalhes bem como na seção sobre interpretação de variáveis em strings.
Para qualquer dos tipos: integer, float, string, boolean e resource, se você converte um valor para um array, você obtêm um array com um elemento (de índice 0) contendo o valor escalar informado.
Se você converte um tipo object para um array, você obtêm as propriedades (variáveis membro) do objeto com elementos do array. As chaves serão o nome das variáveis membro com pequenas notáveis exceções: variáveis privada tem o nome da classe prefixado no nome da variável; variáveis protegidas tem um '*' prefixando o nome da variável. Estes prefixos tem null bytes em ambos os lados. Isto pode resultado em algum comportamente inesperado.
<?php
class A {
private $A; // This will become '\0A\0A'
}
class B extends A {
private $A; // This will become '\0B\0A'
public $AA; // This will become 'AA'
}
var_dump((array) new B());
?>
Se você converter um valor NULL para um array, você terá um array vazio.
É possível comparar arrays através de array_diff() e operadorores de array.
O tipo array do PHP é muito versátil, por isso temos aqui alguns exemplos para mostrar todo o poder dos arrays.
<?php
// isto
$a = array( 'cor' => 'vermelha',
'sabor' => 'doce',
'forma' => 'redonda',
'nome' => 'maçã',
4 // a chave será 0
);
// isto é equivalente a acima
$a['cor'] = 'vermelha';
$a['sabor'] = 'doce';
$a['forma'] = 'redonda';
$a['nome'] = 'maçã';
$a[] = 4; // a chave será 0
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// o mesmo de array( 0 => 'a' , 1 => 'b' , 2 => 'c' ),
// ou simplesmente array('a', 'b', 'c')
?>
Exemplo #1 Utilizando array()
<?php
// Array como (propriedade-)mapa
$map = array( 'versao' => 4,
'OS' => 'Linux',
'lang' => 'inglês',
'short_tags' => true
);
// apenas chaves numéricas
$array = array( 7,
8,
0,
156,
-10
);
// que é o mesmo que array( 0 => 7, 1 => 8, ...)
$switching = array( 10, // chave = 0
5 => 6,
3 => 7,
'a' => 4,
11, // chave = 6 (o índice máximo era 5)
'8' => 2, // chave = 8 (inteiro!)
'02' => 77, // chave = '02'
0 => 12 // o valor 10 será sobrescrito por 12
);
// array vazio
$empty = array();
?>
Exemplo #2 Coleção
<?php
$cores = array('vermelho', 'azul', 'verde', 'amarelo');
foreach ($cores as $cor) {
echo "Você gosta de $cor?\n";
}
?>
O exemplo acima irá imprimir:
Você gosta de vermelho? Você gosta de azul? Você gosta de verde? Você gosta de amarelo?
Mudando diretamente valores de array é possível desde o PHP 5, passando-os como referência. Em versões anteriores precisava de um workaround:
Exemplo #3 Coleção
<?php
// PHP 5
foreach ($colors as &$color) {
$color = strtoupper($color);
}
unset($color); /* ensure that following writes to
$color will not modify the last array element */
// Workaround for older versions
foreach ($colors as $key => $color) {
$colors[$key] = strtoupper($color);
}
print_r($colors);
?>
O exemplo acima irá imprimir:
Array ( [0] => RED [1] => BLUE [2] => GREEN [3] => YELLOW )
Este exemplo cria um array na base 1.
Exemplo #4 Array baseado em 1
<?php
$primeiroquarto = array(1 => 'Janeiro', 'Fevereiro', 'Março');
print_r($primeiroquarto);
?>
O exemplo acima irá imprimir:
Array ( [1] => 'Janeiro' [2] => 'Fevereiro' [3] => 'Março' )
Exemplo #5 Preenchendo um array real
<?php
// preenchendo um array com todos os itens de um diretório
$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
$files[] = $file;
}
closedir($handle);
?>
Arrays são ordenados. Você pode mudar sua ordem utilizando vários funções de ordenação. Veja as funções de arrays para mais informações. Você pode contar o número de itens de um array com a função count().
Exemplo #6 Ordenando arrays
<?php
sort($files);
print_r($files);
?>
Porque o valor de um array pode ser qualquer coisa, isto pode ser outro array. Isto pode criar arrays recursivos e multidimensionais.
Exemplo #7 Arrays recursivos e multidimensionais
<?php
$fruits = array ( "frutas" => array ( "a" => "laranja",
"b" => "banana",
"c" => "maçã",
),
"numeros" => array ( 1,
2,
3,
4,
5,
6
),
"buracos" => array ( "primeiro",
5 => "segundo",
"terceiro",
),
);
// Alguns exemplo de enderecos dos valores do array acima
echo $fruits["buracos"][5]; // prints "segundo"
echo $fruits["frutas"]["a"]; // prints "laranja"
unset($fruits["buracos"][0]); // remove "primeiro"
// Criando um novo array multidimensional
$sucos["maca"]["verde"] = "bom";
?>
Você precisa estar ciente que a atribuição sempre envolve cópia de valor. Também significa que o ponteiro interno do array usado por current() e funções similares são resetados. Você precisa utilizar o operador de referência para copiar um array por referência.
<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 é modificado,
// $arr1 continua sendo apenas array(2, 3)
$arr3 = &$arr1;
$arr3[] = 4; // agora $arr1 e $arr3 sao os mesmos
?>
Para inicializar um objeto, você usa a instrução new, criando uma instância do objeto em uma variável.
<?php
class foo
{
function do_foo()
{
echo "Fazendo foo.";
}
}
$bar = new foo;
$bar->do_foo();
?>
Para uma explicação completa, consulte a seção Classes e Objetos.
Se um objeto é convertido para objeto, ele não é modificado. Se um valor de um outro tipo é convertido para objeto, uma nova instância da stdClass é criada. Se o valor é NULL, a nova instância estará vazia. Arrays convertem para um objeto com propriedades chamadas pelas chaves do array e com os respectivos valores. Para qualquer outro valor, uma variável membro chamada scalar irá conter o valor.
<?php
$obj = (object) 'ciao';
echo $obj->scalar; // exibe 'ciao'
?>
Recurso é uma variável especial, mantendo uma referência de recurso externo. Recursos são criados e utilizados por funções especiais. Veja o apêndice para uma lista de todas essas funções e seus tipos correspondentes.
Nota: O tipo resource foi incluído no PHP 4.
Veja também get_resource_type().
Como os tipos resource sustentam manipuladores especiais para arquivos abertos, conexões de bancos de dados, pinceis de desenho e coisas assim, você não pode converter nenhum valor para o tipo resource.
Através do sistema de contagem de referências introduzido com o engine da Zend no PHP 4, é automaticamente detectado quando um recurso não mais é referenciado (assim como o Java). Quando isto acontece, todos os recursos em uso por esse resource são liberados pelo coletor de lixo. Por essa razão, é raramente necessário liberar memória manualmente utilizando alguma função free_result.
Nota: Conexões persistentes de bancos são especiais. Eles não são destruídos pelo coletor de lixo. Veja também conexões permanentes.
O valor especial NULL representa que a variável não tem valor. NULL é o único valor possível do tipo NULL.
Nota: O tipo NULL foi incluído no PHP 4.
A variável é considerada NULL se
ela foi assimilada com a constante NULL.
ela ainda não recebeu nenhum valor ainda.
ela foi apagada com unset().
mixed indica que um parâmetro pode aceitar vários (mas não necessariamente todos) os tipos
gettype(), por exemplo, aceita todos os tipos do PHP, enquanto str_replace() somente aceita strings e arrays.
Algumas funções como call_user_func() ou usort() aceitam callback de funções definidas por usuário como parâmetro. Funções de callback não podem ser somente simples funções, mas também métodos de objetos incluindo métodos estáticos de classes.
Uma função PHP é simplesmente passado pelo seu nome como uma string. Você pode passar qualquer função nativa ou definida por usuário. Note que construtores da linguagem como array(), echo(), empty(), eval(), exit(), isset(), list(), print() ou unset() não podem ser chamados usando um callback.
A method of an instantiated object is passed as an array containing an object as the element with index 0 and a method name as the element with index 1.
Static class methods can also be passed without instantiating an object of that class by passing the class name instead of an object as the element with index 0.
Apart from common user-defined function, create_function() can be used to create an anonymous callback function.
Exemplo #1 Exemplo de funções callback
<?php
// Exemplo simples de callback
function my_callback_function() {
echo 'Olá Mundo!';
}
call_user_func('my_callback_function');
// Exemplo de método callback
class MyClass {
static function myCallbackMethod() {
echo 'Olá Mundo!';
}
}
// Type 1: Simple callback
call_user_func('my_callback_function');
// Type 2: Static class method call
call_user_func(array('MyClass', 'myCallbackMethod'));
// Type 3: Chamada de método de objeto
$obj = new MyClass();
call_user_func(array(&$obj, 'myCallbackMethod'));
// Type 4: Static class method call (As of PHP 5.2.3)
call_user_func('MyClass::myCallbackMethod');
// Type 5: Relative static class method call (As of PHP 5.3.0)
class A {
public static function who() {
echo "A\n";
}
}
class B extends A {
public static function who() {
echo "B\n";
}
}
call_user_func(array('B', 'parent::who')); // A
?>
Nota: No PHP 4, vocÊ irá ter que usar a referência para criar um callback que aponta para o objeto atual, e não uma cópia dele. Para mais detalhes, veja Referências explicadas.
void no tipo de retorno indica que não há valor a ser retornado. void na lista de parâmetros indica que a função não aceita parâmetros.
$... no protótipo de uma função significa e assim por diante. O nome desta variável é usado quando a função suporta infinito número de argumentos.
O PHP não requer (ou suporta) a definição de tipo explícita na declaração de variáveis: o tipo de uma variável é determinado pelo contexto em que a variável é utilizada. Isto significa que, se você atribuir um valor string para a variável $var , $var se torna uma string. Se você então atribuir um valor inteiro para $var , ela se torna um inteiro.
Um exemplo da conversão automática do PHP é o operador de adição '+'. Se qualquer um dos operadores for float, então todos os operadores são avaliados como floats, e o resultado será um float. De outra forma, se os operadores forem interpretados como integers então o resultado será um integer. Note que isso não muda os tipos dos operadores: apenas muda em como esses operadores são avaliados.
<?php
$foo = "0"; // $foo é string (ASCII 48)
$foo += 2; // $foo é agora um interio (2)
$foo = $foo + 1.3; // $foo é agora um float (3.3)
$foo = 5 + "10 pequenos porcos"; // $foo é inteiro (15)
$foo = 5 + "10 minúsculos porcos"; // $foo é inteiro (15)
?>
Se os últimos dois exemplos lhe parecerem estranhos, veja Conversão de strings para números.
Para forçar uma variável para ser avaliada como um certo tipo, veja a seção Moldando o tipo (casting). Se você deseja mudar o tipo de uma variável, veja settype().
Para testar qualquer um dos exemplo desta seção, você pode usar a função var_dump().
Nota: O comportamento de uma conversão automática para array é atualmente indefinida.
Também, pelo PHP suporta indexação em strings via índice usando a mesma sintaxe de array, o seguinte exemplo é válido para todas versões do PHP:
Veja a seção entitulada Acessando caracteres da string para mais informações.<?php
$a = 'car'; // $a is a string
$a[0] = 'b'; // $a is still a string
echo $a; // bar
?>
A conversão de tipos no PHP funciona como no C: o nome de um tipo desejado é escrito entre parênteses antes da variável em que se deseja a moldagem.
<?php
$foo = 10; // $foo é um inteiro
$bar = (boolean) $foo; // $bar é um booleano
?>
As moldagens permitidas são:
(binary) e o prefixo b é foram adicionado no PHP 5.2.1
Note que tabulações e espaços são permitidos dentro dos parênteses, então o seguinte são funcionalmente equivalentes:
<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
?>
Convertendo uma string literal e variáveis para strings binárias:
<?php
$binary = (binary)$string;
$binary = b"binary string";
?>
Nota: Em vez de converter uma variável para string, você também pode englobar a variável entre aspas duplas.
<?php
$foo = 10; // $foo é um interio
$str = "$foo"; // $str é uma string
$fst = (string) $foo; // $fst tambem é uma string
// Isto imprimirah "eles são o mesmo"
if ($fst === $str) {
echo "eles são o mesmo";
}
?>
Pode não ser tão óbvio o que exatamente ocorre quando se converte entre certos tipos. Para mais informações, veja essas seções:
As variáveis no PHP são representadas por um cifrão ($) seguido pelo nome da variável. Os nomes de variável no PHP fazem distinção entre maiúsculas e minúsculas.
Os nomes de variável seguem as mesmas regras como outros rótulos no PHP. Um nome de variável válido se inicia com uma letra ou sublinhado, seguido de qualquer número de letras, algarismos ou sublinhados. Em uma expressão regular isto poderia ser representado desta forma: '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
Nota: Para nosso propósito, as letras a-z, A-Z e os caracteres ASCII de 127 a 255 (0x7f-0xff).
Nota: $this é uma variável especial que não pode ser atribuída.
Veja também o Guia de nomenclatura em espaço de usuário.
Para informação sobre funções relacionadas a variáveis, veja a Referência de funções para variáveis.
<?php
$var = 'Bob';
$Var = 'Joe';
echo "$var, $Var"; // exibe "Bob, Joe"
$4site = 'not yet'; // inválido; começa com um número
$_4site = 'not yet'; // válido; começa com um sublinhado
$täyte = 'mansikka'; // válido; 'ä' é um caracter ASCII (extendido) 228
?>
Por padrão, as variáveis são sempre atribuídas por valor. Isto significa que quando você atribui uma expressão a uma variável, o valor da expressão original é copiado integralmente para a variável de destino. Isto significa também que, após atribuir o valor de uma variável a outra, a alteração de uma destas variáveis não afetará a outra. Para maiores informações sobre este tipo de atribuição, veja o capítulo em Expressões.
O PHP oferece um outro meio de atribuir valores a variáveis: atribuição por referência. Isto significa que a nova variável simplesmente referencia (em outras palavras, "torna-se um apelido para" ou "aponta para") a variável original. Alterações na nova variável afetam a original e vice versa.
Para atribuir por referência, simplesmente adicione um e-comercial (&) na frente do nome da variável que estiver sendo atribuída (variável de origem) Por exemplo, o trecho de código abaixo imprime 'My name is Bob' duas vezes:
<?php
$foo = 'Bob'; // Atribui o valor 'Bob' a variável $foo
$bar = &$foo; // Referecia $foo através de $bar.
$bar = "My name is $bar"; // Altera $bar...
echo $bar;
echo $foo; // $foo é alterada também.
?>
Uma observação importante a se fazer: somente variáveis nomeadas podem ser atribuídas por referência.
<?php
$foo = 25;
$bar = &$foo; // Esta atribuição é válida.
$bar = &(24 * 7); // Inválido; referencia uma expressão sem nome.
function test()
{
return 25;
}
$bar = &test(); // Inválido.
?>
Não é necessário variáveis inicializadas no PHP, contudo é uma ótima prática. Variáveis não inicializadas tem um valor padrão do tipo dela - FALSE, zero, string vazia ou um array vazio.
Exemplo #1 Valores padrões de variáveis não inicializadas
<?php
echo ($unset_bool ? "true" : "false"); // false
$unset_int += 25; // 0 + 25 => 25
echo $unset_string . "abc"; // "" . "abc" => "abc"
$unset_array[3] = "def"; // array() + array(3 => "def") => array(3 => "def")
?>
Confiar no valor padrão de uma variável não inicializada é problemático no caso de incluir um arquivo em outro que usa variável com mesmo nome. E também um principal risco de segurança com register_globals estando on. Erros E_NOTICE são emitidos no caso de ter variáveis não inicializadas, contudo não no caso de adicionar elementos para um array não inicializado. O construtor da linguagem isset() pode ser usado para detectar se uma variável não foi inicializada.
O PHP oferece um grande número de variáveis pré-definidas para qualquer script que ele execute. Muitas destas variáveis, entretanto, não podem ser completamente documentadas uma vez dependem de diversos fatores, como o servidor no qual scripts são executados, a versão e configuração deste servidor e outros. Algumas destas variáveis não estarão disponíveis quando o PHP for executado na linha de comando. Para uma lista destas variáveis, veja a seção Variáveis reservadas.
No PHP 4.2.0 e posteriores, o valor default da diretiva register_globals é off. Esta é a maior modificação no PHP. Tendo register_globals off afeta o conjunto de variáveis pré-definidas disponíveis no escopo global. POr exemplo, para ler DOCUMENT_ROOT você usará $_SERVER['DOCUMENT_ROOT'] em vez de $DOCUMENT_ROOT, ou $_GET['id'] da URL http://www.example.com/test.php?id=3 em vez de $id, or $_ENV['HOME'] em vez de $HOME.
Para informações relacionadas desta modificação, veja detalhes da diretiva register_globals, no capítulo de segurança em Usando register_globals , assim como o detalhamento de lançamento das versões do PHP » 4.1.0 e » 4.2.0.
Utilizar as Variáveis Pré-definidas do PHP, como os arrays superglobais, é muito mais preferível.
Desde a versão 4.1.0, o PHP fornece um conjunto adicional de arrays predefinidos contendo as variáveis do servidor web (se aplicável), as variáveis ambiente e as entradas do usuário. Esses novos arrays são especiais pelo motivo que são automaticamente globais (significa que são automaticamente disponíveis em qualquer escopo. Por causa disso, são também conhecidas como 'superglobais' (Não há um mecanismo no PHP para superglobais definidas pelo usuário) As superglobais são listadas abaixo. Entretanto, para uma explicação de seu conteúdo e detalhes sobre as variáveis pré-definidas do PHP e sua natureza, veja a seção Variáveis Pré-definidas. Veja também que todas as outras variáveis pré-definidas antigas ($HTTP_*_VARS) ainda existem. A partir do PHP 5.0.0, os grandes arrays de variáveis pré-definidas podem ser desativadas através da diretiva register_long_arrays .
Nota: Variáveis variáveis Superglobais não podem ser utilizadas como variáveis variáveis dentro de funções ou métodos de classe.
Nota: Mesmo que superglobal e HTTP_*_VARS existam; elas não são idênticas, então modificando uma não irá alterar a outra.
Se todos os indicadores não estiverem configurados no variables_order, seus arrays superglobais predefinidos respectivos estarão vazios.
O escopo de uma variável é o contexto onde ela foi definida. A maior parte das variáveis do PHP tem somente escopo local. Este escopo local inclui os arquivos incluídos. Por exemplo:
<?php
$a = 1;
include 'b.inc';
?>
Aqui a variável $a estará disponível no script incluído b.inc. Entretanto, com as funções definidas pelo usuário, um escopo local é introduzido. Quaisquer variáveis utilizadas dento da função é por default limitada dentro do escopo local da função. Por exemplo:
<?php
$a = 1; /* escopo global */
function Teste()
{
echo $a; /* referencia uma variável do escopo local (não definida) */
}
Teste();
?>
Este script não produz nenhuma saída porque a instrução echo() refere-se a uma versão local da variável $a, e ela não tem nenhum valor assimilado nesse escopo. Essa é uma pequena diferença da linguagem C quando variáveis globais são automaticamente disponíveis para funções sem sobreescrever uma eventual definição local. Isto causa problemas quando as pessoas mudam inadivertidamente uma variável global. No PHP, as variáveis globais precisam ser declaradas globais dentro de uma função se ela vai ser utilizada naquela função.
Primeiro, um exemplo de global:
Exemplo #1 Usando global
<?php
$a = 1;
$b = 2;
function Soma()
{
global $a, $b;
$b = $a + $b;
}
Soma();
echo $b;
?>
O script acima imprimirá "3". Declarando $a e $b globais na função, todas as referências a essas variáveis referem-se a versão global. Não há um limite para o número de variáveis globais que podem ser manipuladas por uma função.
Uma segunda maneira de acessar variáveis do escopo global é utilizando o array especial $GLOBALS definido pelo PHP. O exemplo anterior poderia ser rescrito como:
Exemplo #2 Usando $GLOBALS no lugar de global
<?php
$a = 1;
$b = 2;
function Soma()
{
$GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}
Soma();
echo $b;
?>
O array $GLOBALS é um array associativo onde o nome da variável global é a chave do array e o seu conteúdo da variável como o valor do elemento do array. Veja que $GLOBALS existe em qualquer escopo, isto porque $GLOBALS é uma superglobal. Segue um exemplo demonstrando o poder das superglobais:
Exemplo #3 Exemplo demonstrando superglobals e escopos
<?php
function test_global()
{
// A maioria das variaveis pré-definidas nao sao 'super' e requerem
// 'global' para serem disponiveis para funcoes em qualquer escopo.
global $HTTP_POST_VARS;
echo $HTTP_POST_VARS['name'];
// Superglobais são disponiveis em qualquer escopo e
// nao precisam de 'global'. Superglobais existem
// desde o PHP 4.1.0, e HTTP_POST_VARS é agora
// tida como obsoleta.
echo $_POST['name'];
}
?>
Outro recurso importante do escopo de variáveis é a variável estática. Uma variável estática existe somente no escopo local da função, mas ela não perde seu valor quando o nível de execução do programa deixa o escopo. Considere o seguinte exemplo:
Exemplo #4 Exemplo demonstrando a necessidade de variáveis estáticas
<?php
function Teste ()
{
$a = 0;
echo $a;
$a++;
}
?>
Essa função é inútil partindo de que cada vez que ela é chamada, ela coloca em $a o valor 0 e imprime "0". A instrução $a++ , que aumenta o valor da variável não tem sentido desde que a função sai e a variável $a desaparece. Para faze-la mais útil como contadora sem deixar de perder o sua conta atual, a variável $a é declarada como estática:
Exemplo #5 Exemplo de uso de variáveis estáticas
<?php
function Teste()
{
static $a = 0;
echo $a;
$a++;
}
?>
Agora, cada vez que a função Teste() for chamada ele imprimirá o valor de $a e o incrementará.
Variáveis estáticas fornecem uma solução ideal para funções recursivas. Uma função recursiva é aquela se chama a si mesma. Cuidados especiais precisam ser tomados quando escrevendo funções recursivas porque é possível que ela continue na recursão indefinidamente. Você tem de ter certeza que há uma maneira segura de terminar a recursão. A seguinte função recursiva conta até 10, utilizando a variável estática $count para saber quando parar:
Exemplo #6 Variáveis estáticas em funções recursivas
<?php
function Teste()
{
static $count = 0;
$count++;
echo $count;
if ($count < 10) {
Test ();
}
$count--;
}
?>
Nota: Variáveis estáticas podem ser declaradas como nos exemplos acima. A tentativa de assimilar valores para essas variáveis com resultados de expressões causarão um erro de interpretação (parse).
Exemplo #7 Declarando variáveis static
<?php
function foo(){
static $int = 0; // correro
static $int = 1+2; // errado (é uma expressão)
static $int = sqrt(121); // wrong (é uma expressão também)
$int++;
echo $int;
}
?>
A Zend Engine 1, base do PHP 4, implementa os modificadores static e global para variáveis na questão de referências. Por exemplo, uma veriável global importada dentro do escopo de uma função com a instrução global atualmente cria uma referência para a variável global. Isto pode causar comportamentos impresíveis para os seguintes casos:
<?php
function test_global_ref() {
global $obj;
$obj = &new stdclass;
}
function test_global_noref() {
global $obj;
$obj = new stdclass;
}
test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>
Executando esse exemplo você terá as seguites saídas:
NULL
object(stdClass)(0) {
}
Uma situação similar se aplica ao modificador static. Referências não são armazenadas estaticamente:
<?php
function &get_instance_ref() {
static $obj;
echo 'Objeto estatico: ';
var_dump($obj);
if (!isset($obj)) {
// Assimila uma referencia a variavel estatica
$obj = &new stdclass;
}
$obj->property++;
return $obj;
}
function &get_instance_noref() {
static $obj;
echo "Objeto estatico: ";
var_dump($obj);
if (!isset($obj)) {
// Assimila o objeto para a veriavel estatica
$obj = new stdclass;
}
$obj->property++;
return $obj;
}
$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
echo "\n";
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?>
Executando esse exemplo você terá as seguites saídas:
Objeto estatico: NULL
Objeto estatico: NULL
Objeto estatico: NULL
Objeto estatico: object(stdClass)(1) {
["property"]=>
int(1)
}
Este exemplo demonstra que quando assimilando uma referência para uma variável estática, ela não se lembra quando você chama a função &get_instance_ref() uma segunda vez.
As vezes é conveniente poder trabalhar com variáveis variáveis. Isto é, nomes de variáveis que pode ser criadas e utilizadas dinamicamente. Uma variável normal é criada numa instrução como:
<?php
$a = 'hello';
?>
Uma variável variável pega o valor de uma variável e a trata como o nome de uma variável. No exemplo acima, hello pode ser utilizada como o nome de uma variável utilizando dois sinais de cifrão:
<?php
$$a = "world";
?>
Neste ponto, duas variáveis foram definidas e preservadas na árvore de símbolos do PHP: $a contendo "hello" e $hello contendo "world". Da mesma forma, esta instrução:
<?php
echo "$a ${$a}";
?>
produz a mesma saida que:
<?php
echo "$a $hello";
?>
no caso: hello world.
Para poder utilizar variáveis variáveis com arrays, você precisa resolver um problema de ambigüidade. Assim, se você escrever $$a[1] então o interpretador pode entender que você quer usar $a[1] como uma variável ou que você quer usar $$a como uma variável e [1] como o índice dessa variável. A sintaxe para resolver essa ambigüidade é ${$a[1]} para o primeiro caso e ${$a}[1] para o segundo.
Note que variáveis variáveis não podem ser utilizadas com os novos arrays superglobais dentro de funções ou métodos de classes. A variável $this é também uma variável especial e não pode ser referenciada dinamicamente.
Quando um formulário é submetido para um script PHP, qualquer variável do formulário será automaticamente disponível para o script. Há várias maneiras de acessar estas informações, por exemplo:
Exemplo #1 Um formulário HTML simples
<form action="foo.php" method="post">
Nome: <input type="text" name="username" /><br />
Email: <input type="text" name="email" /><br />
<input type="submit" name="submit" value="Me aperte!" />
</form>
Dependendo da configuração local e suas preferencias pessoais, essas são as vias pela qual você pode acessar os dados de seus formulários:
Exemplo #2 Acessando dados de um formulário HTML via POST
<?php
// Disponível desde o PHP 4.1.0
echo $_POST['username'];
echo $_REQUEST['username'];
import_request_variables('p', 'p_');
echo $p_username;
// Indisponivel desde o PHP 6. A partir do PHP 5.0.0, essas longas
// variaveis pré-definidas podem ser desabilitadas pela diretiva register_long_arrays.
echo $HTTP_POST_VARS['username'];
// Disponível se a diretiva register_globals = on.
// Desde o PHP 4.2.0 o valor default de register_globals é off
// Usar/manter esse método é preferível.
echo $username;
?>
Utilizar um formulário GET é similar, exceto que você use a variável GET pré-definida. O metodo GET obtem os dados da QUERY_STRING (a informação depois do '?' numa URL). Então, por exemplo, http://www.example.com/test.php?id=3 contém os dados GET que serão acessíveis com $_GET['id']. Veja também $_REQUEST e import_request_variables().
Nota: Arrays superglobais, como $_POST e $_GET, estão disponíveis desde o PHP 4.1.0.
Como explicado, antes do PHP 4.2.0 o valor default de register_globals era on. E no PHP ele era sempre on. A comunidade PHP está encorajando todos a não alterarem essa diretiva, assumindo-a sempre como off e codificando em conformidade com isso.
Nota: A diretiva de configuração magic_quotes_gpc afeta os valores de GET, POST e Cookies. Se estiver ativada, o valor (It's "PHP!") se tornará automaticamente (It\'s \"PHP!\"). Escaping é necessário para inserção em bancos de dados. Veja também addslashes(), stripslashes() e magic_quotes_sybase.
O PHP entende arrays no contexto de variáveis de formulários (veja o FAQ relacionado). Você pode, por exemplo, agrupar variáveis relacionadas juntas, ou usar esse recurso para receber valores de um campo de seleção múltipla. Por exemplo, podemos ter um formulario que manda informações para si mesmo até um comando submetido para mostrar todos os dados.
Exemplo #3 Variáveis de formulários mais complexos
<?php
if ($_POST) {
echo '<pre>';
echo htmlspecialchars(print_r($_POST, true));
echo '</pre>';
} else {
?>
<form action="" method="post">
Nome: <input type="text" name="personal[name]" /><br />
Email: <input type="text" name="personal[email]" /><br />
Cerveja: <br />
<select multiple name="beer[]">
<option value="antartica">Antartica</option>
<option value="brahma">Brahma</option>
<option value="skol">Skol</option>
</select><br />
<input type="submit" value="Enviar dados!" />
</form>
Quando submetendo um formulário, é possível de se utilizar imagens ao invés do botão de submit padrão com uma tag do tipo:
<input type="image" src="image.gif" name="sub" />
Quando o usuário clica em algum lugar da imagem, o formulário que o acompanha é transmitido para o servidor com duas variáveis adicionais, sub_x e sub_y. Eles contém a coordenadas do clique do usuário na imagem. Os mais experientes percebem que os atuais nomes dessas variáveis enviados pelo browser contém um ponto ao invés de um sublinhado, mas o PHP converte o ponto para um sublinhado automaticamente.
Normalmente o PHP não altera o nome de variáveis quando elas são passadas para o script. Entretanto, é necessário notar que o ponto (ponto final) não é um caracter válido no nomes de variáveis do PHP. Para ilustrar, veja o seguinte exemplo:
<?php
$varname.ext; /* nome de variável inválido */
?>
Nessa situação, é importante saber que o PHP automaticamente substituirá qualquer ponto nos nomes de variáveis recebidas com sublinhados.
Porque o PHP determina os tipos de variáveis e faz conversões (geralmente) quando necessárias, nem sempre é óbvio o tipo de uma variável tem em todos os momentos. O PHP incluí várias funções que permitem determinar qual o tipo de uma variável, por exemplo: gettype(), is_array(), is_float(), is_int(), is_object(), e is_string(). Veja também o capítulo Tipos.
Uma constante é um identificador (nome) para um único valor. Como o nome sugere, esse valor não pode mudar durante a execução do script (exceção às constantes mágicas, que não são constantes de verdade). As constantes são sensíveis ao caso por padrão. Por convenção, o nomes de constantes são sempre em maiúsculas.
O nome de uma constante tem as mesmas regras de qualquer identificador no PHP. Um nome de constante válida começa com uma letra ou sublinhado, seguido por qualquer número de letras, números ou sublinhados. Em expressões regulares, ela pode ser representada por: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
Veja também o Guia de nomenclatura em espaço de usuário.
Exemplo #1 Nomes de constantes válidos e inválidos
<?php
// Nomes de constantes válidos
define("FOO", "alguma coisa");
define("FOO2", "alguma outra coisa");
define("FOO_BAR", "alguma coisa mais");
// Nomes de constantes inválidas
define("2FOO", "alguma coisa");
// Isto é válido, mas deve ser evitado:
// O PHP pode vir a fornercer uma constante mágica
// que danificará seu script
define("__FOO__", "alguma coisa");
?>
Nota: Para nossos exemplos, as letras a-z, A-Z e os caracteres ASCII do 127 ao 255 (0x7f-0xff).
Como as superglobals, o escopo de uma constante é global. Você pode acessar constantes de qualquer lugar em seu script sem se preocupar com o escopo. Para mais informações sobre o escopo no PHP, leia a seção do manual escopo de variáveis.
Você pode definir uma constante utilizando-se da função define(). Quando uma constante é definida, ela não pode ser mais modificada ou anulada.
Somente dados escalares (boolean, integer, float e string) pode ser colocados em constantes. Não defina constantes do tipo resource (recurso).
Você pode obter o valor de uma constante simplesmente especificando seu nome. Diferentemente de variáveis, você não pode prefixar uma constante com um sinal de $. Você também pode utilizar a função constant() para ler o valor de uma constante, se você precisar obter seu valor dinamicamente. Utilize get_defined_constants() para obter a lista de todas as constantes definidas.
Nota: As constantes e variáveis (globais) estão em espaços de nomes diferentes. Isto implica, por exemplo, que TRUE e $TRUE são geralmente diferentes.
Se você usar uma constante indefinida, o PHP assume o nome da constante como seu próprio valor, como se você tivesse uma string (CONSTANT vs "CONSTANT"). Um erro de nível E_NOTICE será lançado quando isso acontecer. Veja também a referência do manual sobre como $foo[bar] é errado (a não ser que você primeiro define() bar como uma constante). Se você simplesmente quer checar se uma constante foi definida, utilize a função defined().
Estas são as diferenças entre constantes e variáveis:
Exemplo #2 Definindo Constantes
<?php
define("CONSTANT", "Hello world.");
echo CONSTANT; // imprime "Hello world."
echo Constant; // imprime "Constant" e gera um alerta notice.
?>
Veja também Constantes de Classe.
O PHP fornece um grande número de predefined constants para qualquer script que ele execute. A maioria dessas constantes, entretanto, são criadas por várias extensões, e somente estarão presentes quando essas extensões estiverem disponíveis, por carregamento dinâmico ou por compilação direta.
Há sete constantes "mágicas", que mudam dependendo de onde elas são utilizadas. Por exemplo, o valor de __LINE__ depende do número da linha em que é utilizada em seu script. Essas constantes especiais são insensíveis ao caso:
| Nome | Descrição |
|---|---|
| __LINE__ | A linha atual do script. |
| __FILE__ | O caminho completo e nome do arquivo. Se utilizado dentro de um include, o nome do arquivo incluído será retornado. Desde o PHP 4.0.2, __FILE__ sempre contém um caminho absoluto com links simbólicos resolvidos enquanto em versões antigas ela continha um caminho relativo sob certas circunstâncias. |
| __DIR__ | O diretório do arquivo. Se usado dentro de um include, o diretório do arquivo incluído é retornado. Isto é equivalente a dirname(__FILE__). Este nome do diretório não possui barra no final, a não ser que seja o diretório raiz. (Adicionado no PHP 5.3.0.) |
| __FUNCTION__ | O nome da função (Acrescentado no PHP 4.3.0). A partir do PHP 5 esta constante retorna o nome da função como ela foi declarada (sensível a maiúsculas e minúsculas). No PHP 4 sempre retorna o nome em minúsculas. |
| __CLASS__ | O nome da classe (Acrescentado no PHP 4.3.0). A partir do PHP 5 esta constante retorna o nome da função como ela foi declarada (sensível a maiúsculas e minúsculas). No PHP 4 sempre retorna o nome em minúsculas. |
| __METHOD__ | O nome do método de classe. (Acrescentado no PHP 5.0.0). O nome do método é retornado como foi declarado (sensível a maiúsculas e minúsculas). |
| __NAMESPACE__ | O nome do atual namespace (sensível a maiúsculas e minúsculas). Esta constante é definida em tempo de compilação (Adicionada no PHP 5.3.0). |
Veja também get_class(), get_object_vars(), file_exists() e function_exists().
Expressões são as peças de construção mais importantes do PHP. No PHP, quase tudo o que você escreve são expressões. A maneira mais simples e ainda mais precisa de definir uma expressão é "tudo o que tem um valor".
As formas mais básicas de expressões são constantes e variáveis. Quando você digita "$a = 5", você está atribuindo '5' para $a. '5', obviamente, tem o valor 5, ou, em outras palavras, '5' é uma expressão com o valor 5 (neste caso, '5' é uma constante inteira).
Depois desta atribuição, você pode esperar que o valor de $a seja 5 também, assim se você escrever $b = $a, você pode esperar que $b se comporte da mesma forma que se você escrevesse $b = 5. Em outras palavras, $a é uma expressão com valor 5 também. Se tudo funcionou bem, isto é exatamente o que acontecerá.
Exemplos ligeiramente mais complexos para expressões são as funções. Por exemplo, considere a seguinte função:
<?php
function foo ()
{
return 5;
}
?>
Assumindo que você está familiarizado com o conceito de funções (se não estiver, dê uma olhada no capítulo sobre functions), você pode assumir que digitar $c = foo() é essencialmente a mesma coisa que escrever $c = 5, e você está certo. Funções são expressões com o valor igual ao seu valor de retorno. Como foo() retorna 5, o valor da expressão 'foo()' é 5. Geralmente, as funções não retornam apenas um valor estático, mas computam algo.
Claro, valores em PHP não tem que ser inteiros, e muito comumente eles não são. o PHP suporta quatro tipos de valores escalares: valores integer (inteiros), valores de ponto flutuante (float), valores string (caracteres) e valores boolean (booleano) (valores escalares são valores que você não pode partir em peças menores, diferentemente de matrizes, por exemplo). O PHP também suporta dois tipos compostos (não escalar): matrizes e objetos. Cada um desses valores podem ser definidos em uma variável ou retornados de uma função.
O PHP leva as expressões muito além, da mesma maneira que muitas outras linguagens fazem. O PHP é uma linguagem orientada a expressões, no sentido de que quase tudo são expressões. Considere o exemplo com o qual já lidamos, '$a = 5'. É fácil ver que há dois valores envolvidos aqui, o valor da constante inteira '5', e o valor de $a que está sendo atualizado para 5 também. Mas a verdade é que há um valor adicional envolvido aqui, e que é o próprio valor da atribuição. A própria atribuição é avaliada com o valor atribuído, neste caso 5. Na prática, significa que '$a = 5', independente do que faça, é uma expressão com o valor 5. Portanto, escrever algo como '$b = ($a = 5)' é como escrever '$a = 5; $b = 5;' (um ponto-e-vírgula marca o fim do comando). Como atribuições são analisadas da direita para a esquerda, você também pode escrever '$b = $a = 5'.
Outro bom exemplo de orientação de expressão é o pré e o pós-incremento e decremento. Usuários de PHP 2 e muitas outras linguagens podem estar familiarizados com a notação de variável++ e variable--. Este são operadores de incremento e decrimento. No PHP/FI 2, o comando '$a++' não tem valor (não é uma expressão), e portanto você não pode atribuir desta forma ou usá-la de jeito nenhum. O PHP evoluiu a capacidade de incremento/decremento criando estas expressões também, como em C. Em PHP, como em C, há dois tipos de incremento - pré-incremento e pós-incremento. Tanto o pré-incremento quanto o pós-incremento, essencialmente, incrementam as variáveis, e o efeito sobre a variável é idêntico. A diferença é com o valor da expressão de incremento. O pré-incremento, que é escrito '++$variavel', é avaliado como o valor de incremento (o PHP incrementa a variável antes de ler seu valor, por isso o nome pré-incremento). O pós-incremento, que é escrito '$variavel++' é avaliado como o valor original da variável, antes de ser incrementada (o PHP incrementa a variável depois de ler seu valor, por isso o nome 'pós-incremento').
Um tipo muito comum de expressões são expressões de comparação. Estas expressões avaliam para ser FALSE ou TRUE. O PHP suporta > (maior que), >= (maior ou igual a), == (igual), != (diferente), < (menor que) and <= (menor ou igual a). A linguagem também suporta um conjunto de operador de equivalencia estrita: === (igual a e do mesmo tipo) and !== (diferente de ou não do mesmo tipo). Estas expressões são mais comumente usada dentro de execução condicional como comandos if.
O último exemplo de expressões com que nós vamos lidar aqui são as expressões combinadas operador-atribuição. Você já sabe que se você quer incrementar $a de 1, você só precisa escrever '$a++' ou '++$a'. Mas e se você quiser somar mais que um a ele, por exemplo 3? Você poderia escrever '$a++' várias vezes, mas esta obviamente não é uma forma muito eficiente ou confortável. Uma prática muito mais comum é escrever '$a = $a + 3'. '$a + 3' é avaliada como o valor de $a mais 3, e é atribuído de volta a $a, que resulta em incrementar $a de 3. Em PHP, como em várias outras linguagens como o C, você pode escrever isto de uma forma mais curta, que com o tempo se torna mais limpa e rápida de se entender também. Somar 3 ao valor corrente de $a pode ser escrito '$a +=3'. Isto significa exatamente "pegue o valor de $a, some 3 a ele, e atribua-o de volta a $a." Além de ser mais curto e mais limpo, isto também resulta em execução mais rápida. O valor de '$a += 3', como o valor de uma atribuição regular, é o valor atribuído. Note que NÃO é 3, mas o valor combinado de $a mais 3 (este é o valor que é atribuído a $a). Qualquer operador de dois parâmetros pode ser usado neste modo operador-atribuição, por exemplo '$a -= 5' (subtrai 5 do valor de $a), '$ b *= 7' (multiplica o valor de $b por 7), etc.
Há mais uma expressão que podem parecer estranha se você não a viu em outras linguagens, o operador condicional ternário:
<?php
$primeira ? $segunda : $terceira
?>
Se o valor da primeira sub-expressão é verdadeiro (TRUE, não-zero), então a segunda sub-expressão é avaliada, e este é o resultado da expressão condicional. Caso contrário, a terceira sub-expressão é avaliada e este é o valor.
O seguinte exemplo deve ajudá-lo a entender um pouco melhor pré e pós-incremento e expressões em geral:
<?php
function double($i)
{
return $i*2;
}
$b = $a = 5; /* atribui o valor cinco às variáveis $a e $b */
$c = $a++; /* pós-incremento, atribui o valor original de $a
(5) para $c */
$e = $d = ++$b; /* pré-incremento, atribui o valor incrementado de
$b (6) a $d e $e */
/* neste ponto, tanto $d quanto $e são iguais a 6 */
$f = double($d++); /* atribui o dobro do valor de $d antes
do incremento, 2*6 = 12 a $f */
$g = double(++$e); /* atribui o dobro do valor de $e depois
do incremento, 2*7 = 14 a $g */
$h = $g += 10; /* primeiro, $g é incrementado de 10 e termina com o
valor 24. o valor da atribuição (24) é
então atribuído a $h, e $h termina com o valor
24 também. */
?>
Algumas expressões podem ser consideradas instruções. Neste caso, uma instrução na forma 'expr' ';' ou seja, uma expressão seguida de um ponto e vírgula. Em '$b=$a=5;', $a=5 é uma expressão válida, mas não é um comando por si só. '$b=$a=5;' porém é um comando válido.
Uma última coisa que vale mencionar é o valor-verdade de expressões. Em muitos eventos, principalmente em instruções condicionais e loops, você não está interessado no valor específico da expressão, mas somente se ela significa TRUE ou FALSE (o PHP não tem um tipo booleano dedicado). As constantes TRUE e FALSE (insensitivas ao caso) são seus dois valores booleanos possíveis. As vezes uma expressão é automaticamente convertida para um booleano. Veja a seção sobre type-casting para detalhes de como isso é feito.
O PHP fornece uma implementação completa e poderosa de expressões, e a completa documentação dela vai além do escopo deste manual. Os exemplos acima devem dar a você uma boa idéia sobre o que são as expressões e como você pode construir expressões úteis. Através do restante do manual nós escreveremos expr ou expressao para indicar qualquer expressão PHP válida.
Um operador é algo que você alimenta com um ou mais valores (ou expressões, no jargão de programação) e que devolve outro valor (e por isso os próprios construtores se tormam expressões). Assim, você pode pensar que as funções e os construtores que retornam valores (como o print) são operadores e os outros que não retornam nada (como echo) como uma outra coisa.
Há três tipos de operadores. Primeiramente, os operadores unários, que operam em apenas um valor. Por exemplo, ! (operador de negação) ou o ++ (operador de incremento). No segundo grupo estão os operadores binários, o o grupo que contém a maioria dos operadores que o PHP suporta, com uma lista completa logo abaixo na seção Precedência de operadores.
O terceiro grupo é do operador ternário: ?:. Ele pode ser usado para selecionar entre dois valores dependendo de uma terceira, em vez de selecionar duas sentenças ou encadeamentos de execução. Englobar expressões ternárias com parênteses é uma boa idéia.
A precedência de um operador especifica quem tem mais prioridade quando há duas delas juntas. Por exemplo, na expressão, 1 + 5 * 3, a resposta é 16 e não 18 porque o operador de multiplicação ("*") tem prioridade de precedência que o operador de adição ("+"). Parênteses podem ser utilizados para forçar a precedência, se necessário. Assim, (1 + 5) * 3 é avaliado como 18. Se a precedência do operador é igual, a associatividade da esquerda para direita é usada.
A tabela seguinte mostra a precedência dos operadores, da maior precedência no começo. Operadores com a mesma precedência estão na mesma linha, no caso a associatividade deles decidide qual ordem eles são avaliados.
| Associação | Operador | Informação adicional |
|---|---|---|
| não associativo | new | new |
| esquerda | [ | array() |
| não associativo | ++ -- | incremento/decremento |
| não associativo | ~ - (int) (float) (string) (array) (object) (bool) @ | tipos |
| não associativo | instanceof | tipos |
| direita | ! | lógico |
| esquerda | * / % | aritmético |
| esquerda | + - . | aritmético e string |
| esquerda | << >> | Bit-a-bit |
| não associativo | < <= > >= <> | comparação |
| não associativo | == != === !== | comparação |
| esquerda | & | Bit-a-bit e referências |
| esquerda | ^ | Bit-a-bit |
| esquerda | | | Bit-a-bit |
| esquerda | && | lógico |
| esquerda | || | lógico |
| esquerda | ? : | ternário |
| direita | = += -= *= /= .= %= &= |= ^= <<= >>= | atribuição |
| esquerda | and | lógico |
| esquerda | xor | lógico |
| esquerda | or | lógico |
| esquerda | , | muitos usos |
Associatividade a esquerda significa que a expressão é avaliada da esquerda para direita, associatividade a direita o oposto.
Exemplo #1 Associatividade
<?php
$a = 3 * 3 % 5; // (3 * 3) % 5 = 4
$a = true ? 0 : true ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2
$a = 1;
$b = 2;
$a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5
?>
Nota: Mesmo tendo = menor precedência que que outros operadores, o PHP ainda permitirá expressões similares à seguinte: if (!$a = foo()), que no caso o retorno de foo() é recebido em $a.
Lembra-se da aritmética básica da escola? Estes operadores funcionam exatamente como aqueles.
| Exemplo | Nome | Resultado |
|---|---|---|
| -$a | Negação | Oposto de $a. |
| $a + $b | Adição | Soma de $a e $b. |
| $a - $b | Subtração | Diferença entre $a e $b. |
| $a * $b | Multiplicação | Produto de $a e $b. |
| $a / $b | Divisão | Quociente de $a por $b. |
| $a % $b | Módulo | Resto de $a dividido por $b. |
O operador de divisão ("/") sempre retorna um valor com ponto flutuante, a não ser que os dois operados seja inteiros (ou strings que são convertidas para inteiros) e numéros inteiramente divisíveis, em outro caso um inteiro é retornado.
Operandos de módulo são convertidos para inteiros (removendo a parte decimal) antes de processar.
Nota: O resto de $a % $b é negativo se $a for negativo.
Veja também a página do manual funções matemáticas.
O operador básico de atribuição é "=". A sua primeira inclinação deve ser a de pensar nisto como "é igual". Não. Isto quer dizer, na verdade, que o operando da esquerda recebe o valor da expressão da direita (ou seja, "é configurado para").
O valor de uma expressão de atribuição é o valor atribuído. Ou seja, o valor de "$a = 3" é 3. Isto permite que você faça alguns truques:
<?php
$a = ($b = 4) + 5; // $a é igual a 9 agora e $b foi configurado como 4.
?>
Além do operador básico de atribuição, há "operadores combinados" para todos os operadores aritméticos, de array e string que permitem a você pegar um valor de uma expressão e então usar seu próprio valor para o resultado daquela expressão. Por exemplo:
<?php
$a = 3;
$a += 5; // configura $a para 8, como se disséssemos: $a = $a + 5;
$b = "Bom ";
$b .= "Dia!"; // configura $b para "Bom Dia!", como em $b = $b . "Dia!";
?>
Note que a atribuição copia a variável original para a nova (atribuição por valor), assim a mudança de uma não afeta a outra. Isto pode ter relevância se você precisa copiar algo como uma grande matriz dentro de um loop longo. Atribuições por referência é também suportada, usando a sintaxe $var = &$outra_var;. 'Atribuição por referência' significa que ambas as variáveis acabam apontando para os mesmos dados, e nada é copiado para lugar nenhum. Para aprender mais sobre referências, leia Referências explicadas. No PHP 5, objetos são atribuídos por referência a menos que explícitamente feito o contrário com a nova palavra chave clone.
Operadores bit-a-bit permitem que você acione ou desligue bits específicos dentro de um inteiro. Se ambos os parâmetros da esquerda e da direita forem strings, esses operadores irão trabalhar nos valores ASCII dos caracteres.
<?php
echo 12 ^ 9; // Imprime '5'
echo "12" ^ "9"; // Imprime o caracter de volta (backspace - ASCII 8)
// ('1' (ASCII 49)) ^ ('9' (ASCII 57)) = #8
echo "hallo" ^ "hello"; // Imprime os valores ASCII #0 #4 #0 #0 #0
// 'a' ^ 'e' = #4
echo 2 ^ "3"; // Imprime '1'
// 2 ^ ((int)"3") == 1
echo "2" ^ 3; // Imprime '1'
// ((int)"2") ^ 3 == 1
?>
| Exemplo | Nome | Resultado |
|---|---|---|
| $a & $b | E | Os bits que estão ativos tanto em $a quanto em $b são ativados. |
| $a | $b | OU | Os bits que estão ativos em $a ou em $b são ativados. |
| $a ^ $b | XOR | Os bits que estão ativos em $a ou em $b, mas não em ambos, são ativados. |
| ~ $a | NÃO | Os bits que estão ativos em $a não são ativados, e vice-versa. |
| $a << $b | Deslocamento à esquerda | Desloca os bits de $a $b passos para a esquerda (cada passo significa "multiplica por dois") |
| $a >> $b | Deslocamento à direita | Desloca os bits de $a $b passos para a direita (cada passo significa "divide por dois") |
Não desloque bits à direita maiores que 32 bits em sistemas 32 bits. E também a esquerda no caso do resultado ser um número maior que 32 bits.
Operadores de comparação, como os seus nomes implicam, permitem que você compare dois valores. Você pode se interessar em ver as tabelas de comparação de tipos, que tem exemplo das várias comparações entre tipos relacionadas.
| Exemplo | Nome | Resultado |
|---|---|---|
| $a == $b | Igual | Verdadeiro (TRUE) se $a é igual a $b. |
| $a === $b | Idêntico | Verdadeiro (TRUE) se $a é igual a $b, e eles são do mesmo tipo (introduzido no PHP4). |
| $a != $b | Diferente | Verdadeiro se $a não é igual a $b. |
| $a <> $b | Diferente | Verdadeiro se $a não é igual a $b. |
| $a !== $b | Não idêntico | Verdadeiro de $a não é igual a $b, ou eles não são do mesmo tipo (introduzido no PHP4). |
| $a < $b | Menor que | Verdadeiro se $a é estritamente menor que $b. |
| $a > $b | Maior que | Verdadeiro se $a é estritamente maior que $b. |
| $a <= $b | Menor ou igual | Verdadeiro se $a é menor ou igual a $b. |
| $a >= $b | Maior ou igual | Verdadeiro se $a é maior ou igual a $b. |
Se você comparar um inteiro com uma string, a string é convertida para um número. Se você comparar 2 strings numéricas, elas serão comparadas como inteiras. Estas regras também se aplicam ao comando switch.
<?php
var_dump(0 == "a"); // 0 == 0 -> true
var_dump("1" == "01"); // 1 == 1 -> true
var_dump("1" == "1e0"); // 1 == 1 -> true
switch ("a") {
case 0:
echo "0";
break;
case "a": // nunca é alcançado porque "a" já foi combinado com 0
echo "a";
break;
}
?>
Para vários tipos, comparações são feitas de acordo com a seguinte tabela (em ordem).
| Tipo do 1º operando | Tipo do 2º operando | Resultado |
|---|---|---|
| null ou string | string | Converte NULL para "", numérico ou comparação léxica |
| bool or null | qualquer | Converte para bool, FALSE < TRUE |
| object | object | Classes nativas podem definir como são comparadas, classes diferentes são incomparáveis, mesma classe - compara propriedades igual faz arrays (PHP 4), PHP 5 tem sua explicação |
| string, resource ou number | string, resource ou number | Transforma strings e resources para números |
| array | array | Array com menos membros é menor, se a chave do operando 1 não é encontrada no operando 2, então os arrays são incomparáveis, caso contrário - compara valor por valor (veja o seguinte exemplo) |
| array | qualquer | array é sempre maior |
| object | qualquer | object é sempre maior |
Exemplo #1 Transcrição do padrão de comparação de array
<?php
// Arrays are compared like this with standard comparison operators
function standard_array_compare($op1, $op2)
{
if (count($op1) < count($op2)) {
return -1; // $op1 < $op2
} elseif (count($op1) > count($op2)) {
return 1; // $op1 > $op2
}
foreach ($op1 as $key => $val) {
if (!array_key_exists($key, $op2)) {
return null; // uncomparable
} elseif ($val < $op2[$key]) {
return -1;
} elseif ($val > $op2[$key]) {
return 1;
}
}
return 0; // $op1 == $op2
}
?>
Veja também strcasecmp(), strcmp(), operadores de array, e a seção do manual sobre Tipos.
Outro operador condicional é o operador "?:" (ou ternário).
Exemplo #2 Atribuindo um valor padrão
<?php
// Example usage for: Ternary Operator
$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];
// The above is identical to this if/else statement
if (empty($_POST['action'])) {
$action = 'default';
} else {
$action = $_POST['action'];
}
?>
Nota: Note que o operador ternário é um comando, e ele não é avaliado para uma variável, mas para o resultado do comando. Isto é importante saber se você quer retornar uma variável por referência. O comando return $var == 42 ? $a : $b; em uma função que retorna por referência conseqüêntemente não irá funcionar e será avisado nas últimas versões do PHP.
Nota: É recomendado para evitar "stacking" de expressões ternárias. O comportamento do PHP quando usando mais de um operador ternário no único comando não é óbvio:
Exemplo #3 Não-óbvio comportamento do ternário
<?php
// o seguinte aparenta imprimir 'true'
echo (true?'true':false?'t':'f');
// conteudo, a saída acima é 't'
// isto por causa da expressão ternário se avaliada da esquerda pra direita
// o seguinte é a versão mais óbvia do mesmo código acima
echo ((true ? 'true' : 'false') ? 't' : 'f');
// aqui, você pode ver que a primeira expressão é avaliada para 'true', que
// por sua vez avalia para (bool)true, assim retornando a parte true da
// segunda expressão ternária.
?>
O PHP suporta um operador de controle de erro: o sinal 'arroba' (@). Quando ele precede uma expressão em PHP, qualquer mensagem de erro que possa ser gerada por aquela expressão será ignorada.
Se o recurso track_errors estiver habilitado, qualquer mensagem de erro gerada pela expressão será gravada na variável global $php_errormsg. Esta variável será sobrescrita em cada erro, assim verifique-a constantemente se você quiser usá-la.
<?php
/* Erro de arquivo intencional */
$my_file = @file ('arquivo_nao_existente') or
die ("Falha abrindo arquivo: '$php_errormsg'");
// Isto funciona para qualquer expressão, não apenas para funções:
$value = @$cache[$key];
// você não receberá nenhum aviso se a chave $key não existir.
?>
Nota: O operador @ funciona somente em expressões. Uma regra simples para lembrar disso: se você pode pegar o valor de alguma coisa, você pode prefixar isso com o @. Assim, você pode prefixar chamadas de variáveis, funções e include()s, constantes e afins. Você não pode prefixar definições de funções ou classe, estruturas condicionais como o if, foreach e assim por diante.
Veja também error_reporting() e a seção do manual sobre funções de Manipulação de Erros e Logging.
Nota: O prefixo de controle de erro "@" não desabilita mensagens que são resultado de erros de interpretação (parse errors).
Atualmente, o operador de controle de erro "@" sempre desativa mensagens de erro, mesmo para erros críticos, que terminam a execução de scripts. Além de outras coisas, isto significa que se você usar "@" para suprimir erros de certas funções e elas não estiverem disponíveis ou com tipos incorretos, o script vai parar exatamente aí sem nenhuma indicação da razão.
O PHP suporta um operador de execução: acentos graves (``). Note que não são apóstrofes! O PHP tentará executar o conteúdo dos acentos graves como um comando do shell; a saída será retornada (isto é, ela não será simplesmente descarregada para a saída; ela pode ser atribuída a uma variável). A utilização do operador contra-apóstrofo é idêntica a função shell_exec().
<?php
$output = `ls -al`;
echo "<pre>$output</pre>";
?>
Nota: O operador de execução fica desabilitado quando safe mode está ativo ou shell_exec() está desabilitado.
Veja também a seção do manual sobre funções de execução de programas, popen() proc_open() e Utilizando o PHP em linha de comando.
O PHP suporta operadores de pré e pós-incremento e decremento no estilo C.
Nota: Os operadores incremento/decremento não afetam valores booleanos. Decrementando valores NULL não há efeito também, mas incrementando resulta em 1.
| Exemplo | Nome | Efeito |
|---|---|---|
| ++$a | Pré-incremento | Incrementa $a em um, e então retorna $a. |
| $a++ | Pós-incremento | Retorna $a, e então incrementa $a em um. |
| --$a | Pré-decremento | Decrementa $a em um, e então retorna $a. |
| $a-- | Pós-decremento | Retorna $a, e então decrementa $a em um. |
Aqui está um script de exemplo simples:
<?php
echo "<h3>Pós-incremento</h3>";
$a = 5;
echo "Deve ser 5: " . $a++ . "<br />\n";
echo "Deve ser 6: " . $a . "<br />\n";
echo "<h3>Pré-incremento</h3>";
$a = 5;
echo "Deve ser 6: " . ++$a . "<br />\n";
echo "Deve ser 6: " . $a . "<br />\n";
echo "<h3>Pós-decremento</h3>";
$a = 5;
echo "Deve ser 5: " . $a-- . "<br />\n";
echo "Deve ser 4: " . $a . "<br />\n";
echo "<h3>Pré-decremento</h3>";
$a = 5;
echo "Deve ser 4: " . --$a . "<br />\n";
echo "Deve ser 4: " . $a . "<br />\n";
?>
O PHP segue a convenção Perl quando tratando operações aritmétricas em variavéis caracter em vez da convenção C. Por exemplo, em Perl 'Z'+1 se torna 'AA', enquanto que no C 'Z'+1 se torna '[' ( ord('Z') == 90, ord('[') == 91 ). Note que variáveis caracter podem ser incrementadas mas não decrementadas e somente caracteres plain ASCII (a-z e A-Z) são suportados.
Exemplo #1 Operações aritmétricas em variáveis caractere
<?php
$i = 'W';
for ($n=0; $n<6; $n++) {
echo ++$i . "\n";
}
?>
O exemplo acima irá imprimir:
X Y Z AA AB AC
Incrementar ou decrementar booleanos não há efeito.
| Exemplo | Nome | Resultado |
|---|---|---|
| $a and $b | E | Verdadeiro (TRUE) se tanto $a quanto $b são verdadeiros. |
| $a or $b | OU | Verdadeiro se $a ou $b são verdadeiros. |
| $a xor $b | XOR | Verdadeiro se $a ou $b são verdadeiros, mas não ambos. |
| ! $a | NÃO | Verdadeiro se $a não é verdadeiro. |
| $a && $b | E | Verdadeiro se tanto $a quanto $b são verdadeiros. |
| $a || $b | OU | Verdadeiro se $a ou $b são verdadeiros. |
A razão para as duas variantes dos operandos "and" e "or" é que eles operam com precedências diferentes. (Veja Precedência de Operadores.)
Exemplo #1 Ilustrando operadores lógicos
<?php
// foo() nunca será chamada como estes operadores são short-circuit
$a = (false && foo());
$b = (true || foo());
$c = (false and foo());
$d = (true or foo());
// "||" tem maior precedência que "or"
$e = false || true; // $e will be assigned to (false || true) which is true
$f = false or true; // $f will be assigned to false
var_dump($e, $f);
// "&&" tem maior precedência que "and"
$g = true && false; // $g will be assigned to (true && false) which is false
$h = true and false; // $h will be assigned to true
var_dump($g, $h);
?>
O exemplo acima irá imprimir algo similar a:
bool(true) bool(false) bool(false) bool(true)
Há dois operadores de string. O primeiro é o operador de concatenação ('.'), que retorna a concatenação dos seus argumentos direito e esquerdo. O segundo é o operador de atribuição de concatenação ('.='), que acrescenta o argumento do lado direito no argumento do lado esquerdo. Veja em Operadores de Atribuição para mais informações.
<?php
$a = "Olá ";
$b = $a . "mundo!"; // agora $b contém "Olá mundo!"
$a = "Olá ";
$a .= "mundo!"; // agora $a contém "Olá mundo!"
?>
Veja também as seções do manual sobre o tipo String e as funções de manipulação de Strings.
| Exemplo | Nome | Resultado |
|---|---|---|
| $a + $b | União | União de $a e $b. |
| $a == $b | Igualdade | TRUE se $a e $b tem os mesmos pares de chave/valor. |
| $a === $b | Identidade | TRUE se $a e $b tem os mesmos pares de chave/valor na mesma ordem e do mesmo tipo. |
| $a != $b | Desigualdade | TRUE se $a não é igual a $b. |
| $a <> $b | Desigualdade | TRUE se $a não é igual a $b. |
| $a !== $b | Não identidade | TRUE se $a não é identico a $b. |
O operador + acrescenta os elementos da direita no array da esquerda, contudo, chaves duplicadas NÃO são sobrescritas.
<?php
$a = array("a" => "maçã", "b" => "banana");
$b = array("a" =>"pêra", "b" => "framboesa", "c" => "morango");
$c = $a + $b; // Uniao de $a e $b
echo "União de \$a e \$b: \n";
var_dump($c);
$c = $b + $a; // União de $b e $a
echo "União de \$b e \$a: \n";
var_dump($c);
?>
União de $a e $b: array(3) { ["a"]=> string(5) "maçã" ["b"]=> string(6) "banana" ["c"]=> string(6) "morango" } União de $b e $a: array(3) { ["a"]=> string(4) "pêra" ["b"]=> string(10) "framboesa" ["c"]=> string(6) "morango" }
Elementos do array são iguais para efeitos de comparação se eles possuem o mesmo valor e chave.
Exemplo #1 Comparando arrays
<?php
$a = array("maçã", "banana");
$b = array(1 => "banana", "0" => "maçã");
var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>
Veja também as seções do manual sobre o tipo Array e funções de manipulação de Arrays.
instanceof é usado para determinar se um variável do PHP é uma objeto instânciado de uma certa classe:
Exemplo #1 Usando instanceof com classes
<?php
class MyClass
{
}
class NotMyClass
{
}
$a = new MyClass;
var_dump($a instanceof MyClass);
var_dump($a instanceof NotMyClass);
?>
O exemplo acima irá imprimir:
bool(true) bool(false)
instanceof pode também ser usado para determinar se uma variável é um objeto instânciado de uma classe que herda de uma classe pai:
Exemplo #2 Usando instanceof com herança
<?php
class ParentClass
{
}
class MyClass extends ParentClass
{
}
$a = new MyClass;
var_dump($a instanceof MyClass);
var_dump($a instanceof ParentClass);
?>
O exemplo acima irá imprimir:
bool(true) bool(true)
Para verificar se um objeto não é uma instância de uma classe, o operador lógico not pode ser usado.
Exemplo #3 Usando instanceof para verificar se o objeto não é uma instância da classe
<?php
class MyClass
{
}
$a = new MyClass;
var_dump(!($a instanceof stdClass));
?>
O exemplo acima irá imprimir:
bool(true)
Por fim, instanceof pode também ser usado para determinar se uma variável é um objeto instânciado de uma classe que implementa uma interface:
Exemplo #4 Usando instanceof para classe
<?php
interface MyInterface
{
}
class MyClass implements MyInterface
{
}
$a = new MyClass;
var_dump($a instanceof MyClass);
var_dump($a instanceof MyInterface);
?>
O exemplo acima irá imprimir:
bool(true) bool(true)
Embora instanceof é usualmente usado com um nome de classe literal, ele pode também ser usado com outro objeto ou uma variável string:
Exemplo #5 Usando instanceof com outras variáveis
<?php
interface MyInterface
{
}
class MyClass implements MyInterface
{
}
$a = new MyClass;
$b = new MyClass;
$c = 'MyClass';
$d = 'NotMyClass';
var_dump($a instanceof $b); // $b é umn objeto da classe MyClass
var_dump($a instanceof $c); // $c é uma string 'MyClass'
var_dump($a instanceof $d); // $d é uma string 'NotMyClass'
?>
O exemplo acima irá imprimir:
bool(true) bool(true) bool(false)
Há algumas detalhes para estar ciente. Antes do PHP 5.1.0, instanceof podia chamar __autoload() quando o nome da classe não existe. Em adicional, se a classe não foi carregada, um erro fatal poderia ocorrer. Isto pode funcionar usando a dynamic class reference, ou uma variável string contendo o nome da classe:
Exemplo #6 Evitando que o nome da classe seje verificado e fatal erros com instanceof no PHP 5.0
<?php
$d = 'NotMyClass';
var_dump($a instanceof $d); // não causa erro fatal
?>
O exemplo acima irá imprimir:
bool(false)
O operador instanceof foi introduzido no PHP 5. Antes disso is_a() era usado mas is_a() tornou-se obsoleto pelo instanceof.
Veja também get_class() e is_a().
Qualquer script PHP é construído por uma série de instruções. Uma instrução pode ser uma atribuição, uma chamada de função, um 'loop', uma instrução condicional, ou mesmo uma instrução que não faz nada (um comando vazio). Instruções geralmente terminam com um ponto e vírgula. Além disso, as instruções podem ser agrupados em um grupo de comandos através do encapsulamento de um grupo de comandos com chaves. Um grupo de comandos é uma instrução também. Os vários tipos de instruções são descritos neste capítulo.
A construção if é uma das mais importantes implementações de muitas linguagens, incluindo o PHP. Ela permite a execução condicional de fragmentos de código. O PHP implementa uma estrutura if que é similar aquela do C:
if (expressao)
instrucoes
Como descrita na seção sobre expressões , expressao é avaliado por seu contexto Booleano. Se expressao for avaliado como TRUE, o PHP executará instrucoes, e se for avaliado como FALSE, ele será ignorado. Maiores informações sobre a avaliação para FALSE podem ser encontradas na seção Convertendo para Booleanos .
Os exemplos a seguir mostrariam que a é maior que b se $a for maior que $b:
<?php
if ($a > $b)
echo "a é maior que b";
?>
Normalmente você vai querer ter mais que uma instrução seja executado condicionalmente. E é claro, não há necessidade de englobar cada instrução com uma cláusula if. Em vez disso, você pode colocar várias instruções em um agrupamento de comandos. Por exemplo, este código mostraria a é maior que b se $a for maior que $b, e então atribuiria o valor de $a para $b:
<?php
if ($a > $b) {
echo "a é maior que b";
$b = $a;
}
?>
Comandos if podem ser aninhados infinitamente dentro de outros comandos if, o que faz com que você complete a flexibilidade para a execução condicional de várias partes do seu programa.
Normalmente você vai querer executar uma instrução se uma certa condição for encontrada, e uma instrução diferente se a condição não for encontrada. Isto é o que o else faz. else estende um comando if para executar uma instrução caso a expressão no comando if seja avaliada como FALSE. Por exemplo, o código a seguir mostraria a é maior que b se $a for maior que $b, e a NÃO é maior que b caso contrário:
<?php
if ($a > $b) {
echo "a é maior que b";
} else {
echo "a NÃO é maior que b";
}
?>
elseif, como seu nome sugere, é uma combinação de if e else. Da mesma forma que o else, ele estende um comando if para executar uma instrução diferente no caso de a expressão if original ser avaliada como FALSE. Porém, ao contrário de else, ele executará aquela expressão alternativa somente se a expressão condicional do elseif for avaliada como TRUE. Por exemplo, o código a seguir mostraria a é maior que b, a é igual a b ou a é menor que b:
<?php
if ($a > $b) {
echo "a é maior que b";
} elseif ($a == $b) {
echo "a é igual a b";
} else {
echo "a é menor que b b";
}
?>
Podem haver vários elseifs dentro da mesma instrução if. A primeira expressão elseif (se houver) que for avaliada como TRUE será executada. No PHP, você também pode escrever 'else if' (em duas palavras) e o comportamento será idêntico a um 'elseif' (em uma só palavra). O significado sintático é ligeiramente diferente (se você está familiarizado com C, eles tem o mesmo comportamento), mas no final das contas ambos teriam exatamente o mesmo comportamento.
O comando elseif só é executado se a expressão if precedente e quaisquer expressões elseif anteriores forem avaliadas como FALSE, e a expressão elseif atual for avaliada como TRUE.
O PHP oferece uma sintaxe alternativa para algumas das suas estruturas de controle: if, while, for, foreach e switch. Em cada caso, a forma básica da sintaxe alternativa é mudar o sinal de abertura para dois-pontos (:) e o sinal de fechamento para endif;, endwhile;, endfor;, endforeach; ou endswitch;, respectivamente.
<?php if ($a == 5): ?>
A é igual a 5
<?php endif; ?>
No exemplo acima, o bloco HTML "A é igual a 5" está aninhado dentro de uma instrução if escrito na sintaxe alternativa. O bloco HTML será mostrado somente se $a é igual a 5.
A sintaxe alternativa se aplica a else e elseif também. A seguir temos uma estrutura if com elseif e else no formato alternativo:
<?php
if ($a == 5):
echo "a igual a 5";
echo "...";
elseif ($a == 6):
echo "a igual a 6";
echo "!!!";
else:
echo "a não é nem 5 nem 6";
endif;
?>
Loops while são o tipo mais simples de criar um 'loop' em PHP. Eles se comportam como seus compatíveis em C. O formato básico de um comando while é:
while (expressao) instrucoes
O significado de um comando while é simples. Ele pede que o PHP execute os comandos aninhados repetidamente, enquanto a expressão do while é avaliada como TRUE. O valor da expressão é verificada cada vez que se passa no começo do 'loop', desta forma, mesmo que este valor mude durante a execução do(s) comando(s) aninhado(s), a execução não parará até que o fim da iteração (cada vez que o PHP executa os comandos dentro do 'loop' é uma iteração). Às vezes, se a expressão while é avaliada como FALSE logo no início, o(s) comando(s) aninhado(s) não será(ão) rodado(s) nem uma vez sequer.
Como no comando if, você pode agrupar múltiplos comandos dentro do mesmo laço while englobando um grupo de instruções com chaves, ou usando a sintaxe alternativa:
while (expressao): instrucoes ... endwhile;
Os exemplos a seguir são idênticos, e ambos imprimem números de 1 até 10:
<?php
/* exemplo 1 */
$i = 1;
while ($i <= 10) {
echo $i++; /* o valor impresso será
$i depois do acréscimo
(post-