Deixando o Lighttpd iniciar processos PHP

Para configurar o Lighttpd para se conectar ao PHP e iniciar processos FastCGI, edite o arquivo lighttpd.conf. Sockets são a maneira preferida de se conectar a processos FastCGI no sistema local.

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
  ))
)

A diretiva bin-path permite ao lighttpd iniciar processos FastCGI dinamicamente. O PHP irá iniciar processos-filhos de acordo com a variável de ambiente PHP_FCGI_CHILDREN. A diretiva bin-environment define o embiente para os processos inciados. O PHP irá fechar um processo filho depois que o número de requisições especificados por PHP_FCGI_MAX_REQUESTS for alcançado. As diretivas min-procs e max-procs devem geralmente ser evitadas com o PHP. O PHP gerencia seus próprios processos filhos, e caches opcode como APC somente irão compartilhar dados entre filhos gerenciados pelo PHP. Se min-procs for definido para algo maior que 1, o número total de respondedores php será a multiplicação por PHP_FCGI_CHILDREN (2 min-procs * 16 filhos são 32 respondedores).

Iniciando processos com spawn-fcgi

Lighttpd fornece um programa chamado spawn-fcgi para tornar a tarefa de iniciar processos FastCGI mais fácil.

Iniciando processo com php-cgi

É possível iniciar processos sem o spawn-fcgi, porém um pouco mais de esforço é requerido. Configurar a variável de ambiente PHP_FCGI_CHILDREN controla quantos processos filhos do PHP irão iniciar para lidar com as requisições que chegam. Configurar PHP_FCGI_MAX_REQUESTS irá determinar por quanto tempo (em requisições) cada filho ficará ativo. Aqui está um script bach simples para ajudar a ininicar respondedores php.

#!/bin/sh

# Localização do binário php-cgi
PHP=/usr/local/bin/php-cgi

# Localização do arquivo PID
PHP_PID=/tmp/php.pid

# Ligação a um endereço
#FCGI_BIND_ADDRESS=10.0.1.1:10000
# Ligação a um 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"

Conectando a instâncias remotas FCGI

Instâncias FastCGI podem ser iniciadas em máquinas remotas múltiplas para expandir aplicações.

fastcgi.server = ( ".php" =>
   (( "host" => "10.0.0.2", "port" => 1030 ),
    ( "host" => "10.0.0.3", "port" => 1030 ))
)

Testando

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.

Usando Variáveis

Algumas variáveis de ambientes fornecidas pelo servidor não são definidas na atual » CGI/1.1 specification. Apenas as seguintes variáveis são definidas: 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'.

Usando Pacotes Binários

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 php, que contém o engine básico (mais gettext e iconv), e pode estar disponível dentre várias versões a escolher. Depois, olhe os pacotes com módulos, como o php-mysqli ou php-imap. Você precisa usar o comando phpxs para ativar e desativar esses módulos no seu arquivo php.ini.

# pkg_add php
# pkg_add php-apache
# pkg_add php-mysqli
  (install the PEAR libraries)
# pkg_add pear

Siga as instruções de cada pacote!

  (to remove packages)
# pkg_delete php
# pkg_delete php-apache
# pkg_delete php-mysqli
# pkg_delete pear

Leia o manual de » packages(7) para mais informações sobre pacotes binários no OpenBSD.

Usando Ports

Você também pode compilar o PHP a partir dos fontes usando a » árvore ports. No entanto, isso só é recomendado para usuários familiarizados com OpenBSD. O port do PHP é dividido em núcleo e extensões. As extensões geram 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.

Problemas Comuns

• Apache e Nginx não são mais os servidores padrão no OpenBSD, mas eles podem ser facilmente encontrados em ports e pacotes. O novo servidor é chamado 'httpd'.
• A instalação padrão do Apache roda dentro de uma » prisão de chroot(2), que restringe os scripts PHP a acessar arquivos abaixo de /var/www. Você irá, portanto, precisar criar um diretório /var/www/tmp para que os arquivos de sessão do PHP sejam guardados, ou usar um backend alternativo para sessões. Além disso, sockets de bancos de dados devem ser colocados dentro da prisão ou escutar na interface localhost. Se você usar funções de rede, alguns arquivos do diretório /etc como /etc/resolv.conf e /etc/services precisarão ser movidos para /var/www/etc. O pacote OpenBSD PEAR se instala automaticamente nos diretórios chroot corretos.
• Os pacotes do OpenBSD package para a extensão » gd requer o Xorg para instalação. Isso é realizado na instalação com o acréscimo de o file set xbase.tgz, ou pode ser instalado posteriormente (veja » OpenBSD FAQ#4).

Software Necessário

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.

Para descompactar uma distribuição PHP você precisará de:

• tar
• gzip or
• bzip2

Para compilar o PHP você precisará de:

• gcc (recomendado, outros compiladores C podem funcionar)
• make
• GNU sed

Para compilar extensões extras ou hackear o código do PHP você também precisará de:

• re2c
• bison
• m4
• autoconf
• automake

Utilizando pacotes

Você pode simplificar o processo de instalação no Solaris ao utilizar pkgadd para instalar os componentes mais comuns. O Image Packaging System (IPS) para Solaris 11 Express também contém os componentes mais comuns utilizando-se o comando pkg.

Usando APT

Primeiro veja que outros pacotes relacionados podem ser desejados, como libapache-mod-php para integração com o Apache 2 e php-pear para o PEAR.

Segundo, antes de instalar um pacote é melhor garantir que a lista de pacotes está atualizada. Isso é feito rodando o comando apt update.

# apt install php-common libapache2-mod-php php-cli

APT instalará automaticamente o módulo do PHP para Apache 2 e todas as suas dependências, depois ativando-o. O Apache deve ser inicializado para que as modificações tenham efeito. Por exemplo:

# /etc/init.d/apache2 stop
# /etc/init.d/apache2 start

Controle melhor as configurações

Até então o PHP foi instalado apenas com os meus módulos principais. É bem provável que módulos adicionais serão desejados, como MySQL, cURL, GD, etc. Estes também podem ser instalados pelo comando apt.

# apt-cache search php
# apt search php | grep -i mysql
# aptitude search php

Os exemplos mostrarão uma grande quantidade de pacotes incluindo vários específicos do PHP, como php-cgi, php-cli e php-dev. Determine quais serão necessários e instale como quaisquer outros via os comandos apt ou aptitude. Como o Debian verifica as dependências, ele perguntará sobre elas. Por exemplo, para instalar MySQL e cURL:

# apt install php-mysql php-curl

O APT irá automaticamente adicionar as linhas apropriadas a arquivos php.ini relacionados, como /etc/php/7.4/php.ini, /etc/php/7.4/conf.d/*.ini, etc., e dependendo da da extensão irá ainda acrescentar diretivas similares a extension=foo.so. Entretanto é necessário reiniciar o servidor web para que essas alterações tenham efeito.

Problemas comuns

• Se os scripts PHP não estão sendo interpretados pelo servidor web, então é provável que o PHP não tenha sido acrescentado aos arquivos de configuração do servidor web, que no Debian pode ser /etc/apache2/apache2.conf ou algo similar. Veja o manual do Debian para mais detalhes.
• Se uma extensão parece ter sido instalada e ainda assim funções permanecem não definidas, verifique que o arquivo .ini apropriado está sendo carregado e/ou se o servidor web foi reiniciado após a instalação.
• Há dois comandos básicos para instalar pacotes no Debian (e em outras variantes Linux): apt e aptitude. Entretanto explicar as sutis diferenças entre esses dois comandos vai além do escopo deste manual.

Ferramentas de instalação do PHP

» XAMPP, WampServer e BitNami irão configurar as aplicações PHP para utilização com Apache no Windows.

Preparar e configurar o Nginx no Windows requer um pouco mais de configuração. Consulte a » documentação Nginx para apoio adicional.

OpCache

É altamente recomendado habilitar o OpCache. Esta extensão é incluída no PHP para Windows. Ela compila e otimiza os scripts PHP e os mantém na memória cache para que não sejam compilados toda vez que uma página é carregada.

Configure o php.ini:

opcache.enable=On
opcache.enable_cli=On

WinCache

Recomenda-se usar o WinCache se o IIS for usado, especialmente em um ambiente de hospedagem web compartilhado ou em armazenamento de arquivos de rede (NAS). Note que o WinCache não é mais suportado a partir do PHP 8.0.0. Todas as aplicações PHP se beneficiam automaticamente do recurso de cache de arquivo do WinCache. Operações do sistema de arquivos são armazenadas em cache. WinCache também armazena em cache objetos de usuário e compartilha-os entre os processos php.exe ou php-cgi.exe (compartilha objetos entre requisições). Muitas das grandes aplicações web têm um plugin ou extensão ou opção de configuração para uso do WinCache para cache de objetos de usuário. Se um alto desempenho é requerido, deve-se usar cache de objetos na aplicação. Consulte: » http://pecl.php.net/package/WinCache para baixar uma DLL WinCache (or tgz) para a pasta de extensões PHP (extensions_dir no php.ini). Configure o php.ini:

extension=php_wincache.dll
wincache.fcenabled=1
wincache.ocenabled=1 ; removida a partir do wincache 2.0.0.0

Configuração IIS

No Gerenciador IIS, instale o módulo FastCGI e adicione um manipulador para mapear a extensão `.php` para o caminho do PHP-CGI.exe (não para o PHP.exe)

Pode ser usado o Prompt de Comando para configurar o IIS via script.

Banco de Dados

Provavelmente será necessário um Servidor de Banco de Dados. Bancos de dados populares fornecem extensões PHP para que possam ser utilizados. Se o site não tiver um tráfego muito alto, o servidor de banco de dados pode ser executado no mesmo servidor web. Muitos bancos de dados populares podem são compatíveis com o Windows.

O PHP inclui as extensões mysqli e pdo_mysql.

Consulte » https://dev.mysql.com/downloads/windows/

Escolhendo o Servidor Web

@echo off

REM Baixe o arquivo .ZIP da versão do PHP no link http://windows.php.net/downloads/

REM Caminho para a pasta onde deve-se descompactar o arquivo .ZIP do PHP (sem \ no final)
set phppath=c:\php


REM Limpe os manipuladores atuais do PHP
%windir%\system32\inetsrv\appcmd clear config /section:system.webServer/fastCGI
REM O comando a seguir irá gerar uma mensagem de erro se o PHP não estiver instalado. Isto pode ser ignorado.
%windir%\system32\inetsrv\appcmd set config /section:system.webServer/handlers /-[name='PHP_via_FastCGI']

REM Defina os manipuladores do PHP
%windir%\system32\inetsrv\appcmd set config /section:system.webServer/fastCGI /+[fullPath='%phppath%\php-cgi.exe']
%windir%\system32\inetsrv\appcmd set config /section:system.webServer/handlers /+[name='PHP_via_FastCGI',path='*.php',verb='*',modules='FastCgiModule',scriptProcessor='%phppath%\php-cgi.exe',resourceType='Unspecified']
%windir%\system32\inetsrv\appcmd set config /section:system.webServer/handlers /accessPolicy:Read,Script

REM Configure as variáveis FastCGI
%windir%\system32\inetsrv\appcmd set config -section:system.webServer/fastCgi /[fullPath='%phppath%\php-cgi.exe'].instanceMaxRequests:10000
%windir%\system32\inetsrv\appcmd.exe set config -section:system.webServer/fastCgi /+"[fullPath='%phppath%\php-cgi.exe'].environmentVariables.[name='PHP_FCGI_MAX_REQUESTS',value='10000']"
%windir%\system32\inetsrv\appcmd.exe set config -section:system.webServer/fastCgi /+"[fullPath='%phppath%\php-cgi.exe'].environmentVariables.[name='PHPRC',value='%phppath%\php.ini']"

Escolha a Compilação

Compilações para o Windows podem ser baixadas de » http://windows.php.net/download/. Todas as compilações são otimizadas (PGO), e as versões QA e GA são extensivamente testadas.

Existem 4 tipos de compilação do PHP:

• Thread-Safe(TS) - para servidores web de processo único, como Apache com mod_php.

• Non-Thread-Safe(NTS) - para IIS e outros servidores web FastCGI (Apache com mod_fastcgi) e recomendado para scripts de linha de comando.

• x86 - para sistemas de 32-bits.

• x64 - para sistemas de 64-bits.

Instalando como um controlador Apache

Para carregar o módulo PHP para Apache 2.x, as seguintes linhas no arquivo de configuração Apache httpd.conf precisam ser inseridas:

# antes do PHP 8.0.0 o nome do módulo era php7_module
LoadModule php_module "c:/php/php8apache2_4.dll"
<FilesMatch \.php$>
    SetHandler application/x-httpd-php
</FilesMatch>
# configure caminho para php.ini
PHPIniDir "C:/php"

Nota: O caminho correto do PHP precisa ser substituído em vez de C:/php/ nos exemplos acima. Certifique-se de que o arquivo referenciado na diretiva LoadModule está no local especificado. Use php7apache2_4.dll para PHP 7, ou php8apache2_4.dll para PHP 8.

Executando PHP como CGI

É altamente recomendável consultar a » documentação Apache CGI para uma compreensão mais completa da execução de CGI no Apache.

Para executar o PHP como CGI, os arquivos php-cgi precisarão ser colocados em um diretório designado como um diretório CGI usando a diretiva ScriptAlias.

Uma linha iniciada com #! precisará ser colocada nos arquivos PHP que apontam para a localização do binário do PHP:

#!C:/php/php.exe
<?php
  phpinfo();
?>

Executando PHP sobre FastCGI

Executar o PHP no FastCGI tem uma série de vantagens sobre executá-lo como um CGI. Configurá-lo dessa forma é bastante simples:

Baixe mod_fcgid de » https://www.apachelounge.com. Os binários do Win32 estão disponíveis para download neste site. Instale o módulo de acordo com as instruções que o acompanham.

Configure o seu servidor web conforme mostrado abaixo, tendo o cuidado de ajustar quaisquer caminhos para refletir como você instalou em seu sistema específico:

LoadModule fcgid_module modules/mod_fcgid.so
# Onde está seu arquivo php.ini?
FcgidInitialEnv PHPRC        "c:/php"
<FilesMatch \.php$>
    SetHandler fcgid-script
</FilesMatch>
FcgidWrapper "c:/php/php-cgi.exe" .php

Verifique as Permissões da Pasta Temporária

WinCache

O WinCache está habilitado por padrão no Azure App Services e é recomendado que você o mantenha habilitado. Se você instalar sua própria compilação do PHP, você deve habilitar o WinCache nela também.

Compilação Customizada do PHP

Você pode fazer o upload de sua própria compilação do PHP para o seu D:\Home (C:\ NÃO é gravável). Em seguida, no Portal Azure, defina SCRIPT_PROCESSOR para .php como o caminho absoluto do arquivo php-cgi.exe na sua compilação.

Compilando dos fontes

Para habilitar o FPM na sua compilação do PHP você deve adicionar --enable-fpm à sua linha de configuração

Há várias outras opções de configuração específicas para o FPM (todas opcionais):

• --with-fpm-user - configura o usuário FPM (padrão - nobody).

• --with-fpm-group - configura o grupo FPM (padrão - nobody).

• --with-fpm-systemd - Ativa a integração com o systemd (padrão - no).

• --with-fpm-acl - Usa Access Control Lists do POSIX (padrão - no).

• --with-fpm-apparmor - Ativa a integração com o AppArmor (padrão - no).

• --with-fpm-selinux - Ativa a integração com o SELinux (padrão - no).

Registro de Alterações

Lista de diretivas globais php-fpm.conf

pid string

Caminho para o arquivo PID. Valor padrão: nenhum.

error_log string

Caminho para o arquivo de log de erro. Valor padrão: #INSTALL_PREFIX#/log/php-fpm.log. Se configurado com "syslog", o log será enviado para o syslogd ao invés de ser escrito em uma arquivo local.

log_level string

Nível de log de erro. Valores possíveis: alert, error, warning, notice, debug. Valor padrão: notice.

log_limit int

Limite para tamanho das linhas para permitir mensagens de log maiores que 1024 caracteres sem quebras. Valor padrão: 1024. Disponível desde o PHP 7.3.0.

log_buffering bool

Log sem buffering (experimental). Valor padrão: yes. Disponível desde o PHP 7.3.0.

syslog.facility string

usado para especificar que tipo de programa está logando a mensagem. Valor Padrão: daemon.

syslog.ident string

No início de todas as mensagens. Se possuir múltiplas instâncias do FPM rodando no mesmo servidor, pode-se modificar o valor padrão para adaptar-se às necessidades. Valor padrão: php-fpm.

emergency_restart_threshold int

Se esse número de processos filho sair com SIGSEGV ou SIGBUS dentro do intervalo de tempo definido pelo emergency_restart_interval, o FPM será reiniciado. Um valor 0 significa 'Off'. Valor padrão: 0 (desligado).

emergency_restart_interval mixed

Intervalo de tempo utilizado por emergency_restart_interval para determinar quando um reinício será feito. Pode ser útil para contornar corrupções acidentais em memória compartilhada de um acelerador. Unidades disponíveis: s(egundos), m(minutos), h(horas), ou d(ias). Unidade Padrão: seconds. Valor padrão: 0 (desligado).

process_control_timeout mixed

Prazo para processos filhos para esperar uma reação em sinais de mestre. Unidades disponíveis: s(egundos), m(minutos), h(horas), ou d(ias) Unidade Padrão: seconds. Valor padrão: 0.

process.max int

O número máximo de processos que o FPM criará. Projeto para controlar o número global de processos ao utilizar PM dinâmico em várias rotinas. Utilize com cautela. Valor padrão: 0.

process.priority int

Especifica a prioridade nice(2) a ser aplicada ao processo mestre (se estiver configurado). O valor varia de -19 (maior prioridade) até 20 (menor prioridade). Valor padrão: não especificado.

daemonize bool

Faz o FPM ser executado em segundo plano. Defina como 'no' para manter o FPM em primeiro plano, para fins de depuração. Valor padrão: yes.

rlimit_files int

Configura o descritor rlimit para abertura de arquivos no processo mestre. Valor padrão: valor definido pelo sistema operacional.

rlimit_core int

Configura o tamanho do núcleo rlimit no processo mestre. Valor padrão: 0.

events.mechanism string

Especifica o mecanismo de eventos que o FPM utilizará. Os seguintes estão disponíveis: select, pool, epoll, kqueue (*BSD), port (Solaris). Valor padrão: não especificado (detectado automaticamente).

systemd_interval int

Quando o FPM for compilado com integração ao systemd, especifica o intervalo, em segundos, entre a notificação ao systemd. Defina com 0 para desabilitar. Valor padrão: 10.

Lista de diretivas de rotina

Com o FPM você pode executar várias rotinas de processos com configuração diferente. Essas são as configurações que podem ser otimizadas por cada rotina.

listen string

O endereço que aceita pedidos FastCGI. Sintaxes válidas são: 'ip.add.re.ss:port', 'port', '/path/to/unix/socket'. Esta opção é obrigatória em cada rotina.

listen.backlog int

Define o backlog de listen(2). O valor de -1 significa o máximo em sistemas BSD;. Valor padrão: -1 (FreeBSD ou OpenBSD) ou 511 (Linux e outras plataformas).

listen.allowed_clients string

Lista de endereços IPv4 de clientes FastCGI que estão autorizados a conectar. Equivalente à variável de ambiente FCGI_WEB_SERVER_ADDRS no PHP FastCGI (5.2.2+). Só faz sentido com um soquete de escuta TCP. Cada endereço deve ser separado por uma vírgula. Se este valor for deixado em branco, conexões serão aceitas a partir de qualquer endereço IP. Valor padrão: nenhum (aceita conexões de qualquer IP).

listen.owner string

Define permissões para socket unix, se utilizado. No Linux, permissões de leitura/gravação devem ser definidas de forma a permitir conexões a partir de um servidor web. Muitos sistemas derivados do BSD permitir conexões independentemente das permissões. Os valores padrão: usuários e grupos são definidos como o usuário que está executando, de modo está definido para 0660.

listen.group string

Veja listen.owner.

listen.mode string

Veja listen.owner.

listen.acl_users string

Quando o suporte ao Access Control Lists POSIX for suportado, pode-se configurá-lo utilizando esta opção. Ao configurá-lo, listen.owner e listen.group serão ignorados. Seu valor é uma lista de nomes de usuários, separada por vírgula.

listen.acl_groups string

Veja listen.acl_users. Seu valor é uma lista de nomes de grupo, separada por vírgula.

user string

Usuário Unix dos processos FPM. Esta opção é obrigatória.

group string

Grupo Unix dos processos FPM. Se não for definido, o grupo do usuário padrão será utilizado.

pm string

Escolha como o gerenciador de processos controlará o número de processos filhos. Valores possíveis: static, ondemand, dynamic. Esta opção é obrigatória.

static - o número de processos filho é fixo (pm.max_children).

ondemand - os processos sob demanda (quando solicitado, em oposição a dinâmica, então pm.start_servers são iniciadas quando o serviço é iniciado.

dynamic - o número de processos filhos são definidos dinamicamente com base nas seguintes diretrizes: pm.max_children, pm.start_servers, pm.min_spare_servers, pm.max_spare_servers.

pm.max_children int

O número de processos filhos que podem ser criados quando pm está configurado como static e o número máximo de processos filhos podem ser criados quando pm está configurado como dynamic. Essa opção é obrigatória.

Esta opção define o limite para o número de solicitações simultâneas que será servida. Equivalente à directiva ApacheMaxClients com mpm_prefork e ao PHP_FCGI_CHILDREN variável de ambiente no originais PHP FastCGI.

pm.start_servers int

O número de processos filhos criados na inicialização. Usado apenas quando pm é configurado em dynamic. Valor padrão: min_spare_servers + (max_spare_servers - min_spare_servers) / 2.

pm.min_spare_servers int

O número mínimo desejado de processos servidores inativos. Usado apenas quando pm está configurado como dynamic. Também obrigatório neste caso.

pm.max_spare_servers int

O número máximo desejado de processos servidores inativos. Usado apenas quando pm está configurado como dynamic. Também obrigatório neste caso.

pm.max_spawn_rate int

O número de processos para inicializar de uma vez. Utilizado apenas quando pm é configurado para dynamic. Valor padrão: 32

pm.process_idle_timeout mixed

O número de segundos após qual um processo parado será encerrado. Utilizado apenas quando pm é configurado como ondemand. Unidades disponíveis: s(segunfos)(default), m(minutos), h(horas), or d(dias). Valor padrão: 10s.

pm.max_requests int

O número de solicitações de cada processo filho deve ser executado antes respawning. Isto pode ser útil para contornar falhas de memória de bibliotecas de terceiro partido. Para o processamento de pedido interminável especificar '0 '. equivalente a PHP_FCGI_MAX_REQUESTS. Valor padrão: 0.

pm.status_listen string

O endereço no qual o FastCGI acessa requisições de status. Isto cria um novo pool invisível que sustenta essas requisições independentemente. Útil se o pool principal está ocupado com requisições longas dado que é possível obter a página de status FPM enquanto rodando requisições longas. A sintaxe é a mesma da opçãolisten. Valor padrão: vazio.

pm.status_path string

O URI para visualizar a FPM status page. Este valor precisa começar com uma contra barra (/). Se o valor estiver vazio, nenhuma URI será reconhecida como uma página de status. Valor padrão: vazio.

ping.path string

O URI ping para chamar a página de FPM de monitoramento. Se este valor não é definido, nenhuma URI será reconhecido como uma página de ping. Isto poderia ser usado para testar de fora que FPM está vivo e responder. Por favor, note que o valor deve começar com uma barra à esquerda (/).

ping.response string

Esta diretiva pode ser usado para personalizar a resposta a um pedido ping. A resposta é formatada como text/plain com uma resposta de código 200. Valor padrão: pong.

process.priority int

Especifica a prioridade de nice(2) a ser aplicado ao processo (se informado). Esse valor pode variar de -19 (prioridade máxima) to 20 (priridade mínima). Valor padrão: vazio.

process.dumpable bool

Configura a flag dumpable (PR_SET_DUMPABLE prctl) mesmo no caso do processo de usuário ou grupo for diferente do processo inicializador. Isto permite criar core dumps de processos e realizar ptrace no user pool. Valor padrão: no. Desde os PHP 7.0.29, 7.1.17 e 7.2.5.

prefix string

Especifica um prefix para interpretação de caminhos.

request_terminate_timeout mixed

O tempo limite para servir um único pedido após o qual o processo trabalha serão encerradas. Esta opção deve ser usada quando o 'max_execution_time', opção do arquivo ini não parar a execução do script por algum motivo. Um valor de '0', significa 'Off'. Unidades disponíveis: s(econds) (padrão), m(inuts), h(our), ou d(ays). Valor padrão: 0.

request_terminate_timeout_track_finished bool

O timeout configurado para request_terminate_timeout não é disparado depois de fastcgi_finish_request or quando a aplicação terminou e funções internas de finalização estão rodando. Esta diretiva irá aplicar o timeout mesmo para esses casos. Valor padrão: no. Desde o PHP 7.3.0.

request_slowlog_timeout mixed

O tempo limite para servir um único pedido depois que um rastreamento PHP serão despejados para o arquivo 'slowlog. Um valor de '0 'significa' Off '. Unidades disponíveis: s(egundos)(padrão), m(inutos), h(oras), or d(dias). Valor padrão: 0.

request_slowlog_trace_depth int

A profundidade do stack trace de slowlog. Valor padrão: 20. Desde o PHP 7.2.0.

slowlog string

O arquivo de log de solicitações lentas. Valor padrão: #INSTALL_PREFIX#/log/php-fpm.log.slow.

rlimit_files int

Define o descritor de arquivo de abertura rlimit. Valor padrão: valor definido pelo sistema.

rlimit_core int

Defina o tamanho do núcleo máxímo do rlimit. Valores possíveis: 'unlimited' ou um número inteiro maior ou igual a 0. Valor padrão: valor definido pelo sistema.

chroot string

Chroot neste diretório, na inicialização. Este valor deve ser definido como um caminho absoluto. Quando este valor não está definido, chroot não é usado.

chdir string

Chdir neste diretório, na inicialização. Este valor deve ser um caminho absoluto. Valor padrão: diretório atual ou / ao chroot.

catch_workers_output bool

Redirecionar stdout e stderr no log de erro principal. Se não for definido, stdout e stderr serão redirecionadas para /dev/null de acordo com especificações FastCGI. Valor padrão: no.

decorate_workers_output bool

Ativa a decoração do outpur de workers quando catch_workers_output estiver ativo. Valor padrão: yes. Disponível desde o PHP 7.3.0.

clear_env bool

Limpa o ambiente dos workers do FPM. Previne que variáveis de ambiente arbitrárias alcancem os processos dos workers do FPM limpando o ambiente nos workers antes das variáveis de ambientes desta rotina serem adicionadas. Valor padrão: Yes.

security.limit_extensions string

Limita as extensões que o script principal do FPM possui permissão a analisar. Evita problemas de configurações no servidor de aplicação. Você deve limitar as extensões do FPM a somente o .php para evitar que usuários maliciosos utilizem outras extensões para executar códigos php. Default value: .php .phar

apparmor_hat string

Se AppArmor estiver ativo, isto permite modificar o hat. Valor padrão: não configurado.

access.log string

O arquivo de log de acessos. Valor padrão: não configurado.

access.format string

O formato do log de acesso. Valor padrão: "%R - %u %t \"%m %r\" %s":

Valid options

Código	Descrição
%C	%CPU
%d	duration µs
%e	fastcgi env
%f	script
%l	content length
%m	method
%M	memory
%n	pool name
%o	header output
%p	PID
%q	query string
%Q	a cola entre %q e %r
%r	request URI
%R	IP remoto
%s	status
%T	time
%t	time
%u	remote user

É possível passar variáveis de ambiente adicionais e atualizar as configurações do PHP de uma determinada rotina. Para fazer isso, precisa-se adicionar as seguintes opções no arquivo de configuração da rotina.

env[HOSTNAME] = $HOSTNAME
env[PATH] = /usr/local/bin:/usr/bin:/bin
env[TMP] = /tmp
env[TMPDIR] = /tmp
env[TEMP] = /tmp

php_admin_value[sendmail_path] = /usr/sbin/sendmail -t -i -f www@my.domain.com
php_flag[display_errors] = off
php_admin_value[error_log] = /var/log/fpm-php.www.log
php_admin_flag[log_errors] = on
php_admin_value[memory_limit] = 32M

Configurações definidas com php_admin_value e php_admin_flag não podem ser sobrescritas com ini_set().

Configurações do PHP que também podem ser definidas no servidor.

set $php_value "pcre.backtrack_limit=424242";
set $php_value "$php_value \n pcre.recursion_limit=99999";
fastcgi_param  PHP_VALUE $php_value;

fastcgi_param  PHP_ADMIN_VALUE "open_basedir=/var/www/htdocs";

Nota: Pools não são um mecanismo de segurança, dado que eles não fornecem total separação; por exemplo, todos os pools utiliza uma única instância de OPcache.

Onde encontrar uma extensão?

As extensões do PHP geralmente são chamadas de php_*.dll (onde o asterisco representa o nome da extensão) e estão localizadas no diretório PHP\ext.

O PHP vem com as extensões mais úteis para a maioria dos desenvolvedores. Elas são chamadas extensões nativas do PHP.

Entretanto, se as extensões nativas não fornecerem a funcionalidade necessária, uma extensão que ofereça essa funcionalidade ainda pode ser encontrada no » PECL. A biblioteca comunitária de extensões PHP (PECL) é um repositório de extensões PHP, que fornece um diretório de todas as extensões conhecidas e recursos de hospedagem para download e desenvolvimento de extensões PHP.

Se uma extensão foi desenvolvida para usos específicos, ela pode ser hospedada no PECL para que outras pessoas com as mesmas necessidades possam se beneficiar delas. Um bom efeito colateral é que é uma excelente chance de receber feedbacks, agradecimentos, relatórios de erros e até mesmo correções/patches. Antes de enviar uma extensão para hospedagem no PECL, consulte sobre » Submissão ao PECL.

Qual extensão baixar?

Muitas vezes, haverá várias versões disponíveis de cada DLL:

• Números de versão diferentes (pelo menos os dois primeiros números devem corresponder)
• Versões de thread safety diferentes
• Arquitetura de processador diferente (x86, x64, ...)
• Configurações de depuração diferentes
• etc.

Lembre-se de que as configurações de extensão devem corresponder a todas as configurações do executável PHP que está sendo usado. O script a seguir informará tudo sobre as configurações do PHP:

Ou na linha de comando, execute:

drive:\caminho\para\o\executavel\php.exe -i

Carregando uma extensão

A forma mais comum de carregar uma extensão PHP é incluí-la no arquivo de configuração php.ini. Observe que muitas extensões já estão presentes no php.ini e só é preciso remover o ponto e vírgula para ativá-las.

A partir do PHP 7.2.0, o nome da extensão pode ser usado ao invés do nome do arquivo da extensão. Como é independente do sistema operacional é mais fácil, especialmente para iniciantes, essa é a maneira recomendada de especificar as extensões a serem carregadas. Os nomes dos arquivos continuam suportados para compatibilidade com versões anteriores.

;extension=php_extname.dll

extension=php_extname.dll

; A partir do PHP 7.2.0, prefira:
extension=extname
zend_extension=another_extension

No entanto, isso pode causar confusão em alguns servidores web porque eles não usam o arquivo php.ini localizado junto do executável PHP. Para descobrir onde o arquivo php.ini está, procure seu caminho na função phpinfo():

Configuration File (php.ini) Path  C:\WINDOWS

Loaded Configuration File   C:\Program Files\PHP\8.2\php.ini

Depois de ativar uma extensão, salve o arquivo php.ini, reinicie o servidor web e verifique a função phpinfo() novamente. A nova extensão agora deve ter sua própria seção.

Resolvendo problemas

Se uma extensão não aparecer na função phpinfo(), os logs devem ser verificados para saber de onde vem o problema.

Se o PHP estiver sendo usado na linha de comando (CLI), os erros de carregamento da extensão podem ser lidos diretamente na tela.

Se o PHP estiver sendo usado com um servidor web, a localização e o formato dos logs irão variar dependendo do software usado. Consulte a documentação do servidor web para localizar os logs, pois isso não está relacionado com o PHP.

Problemas comuns são a localização da DLL e das DLLs das quais ela depende, o valor da diretiva "extension_dir" no arquivo php.ini e incompatibilidades de configuração em tempo de compilação.

Se o problema estiver em uma incompatibilidade de configuração em tempo de compilação, provavelmente a DLL errada foi baixada. Tente baixar novamente a extensão com as configurações corretas. Novamente, a função phpinfo() pode ser de grande ajuda.

Configuração em diretório

É possível configurar o PHP para procurar por arquivos .ini em um diretório após a leitura do php.ini. Isto é possível na compilação pela configuração da opção --with-config-file-scan-dir. No O diretório de configuração pode ser sobrescrito em tempo de execução através da configuração da variável de ambiente PHP_INI_SCAN_DIR.

É possível procurar em vários diretórios os separando com o delimitador específico da plataforma (; no Windows, NetWare e RISC OS; : em todas as outras plataformas; o PHP utilizará a constante PATH_SEPARATOR). Se um diretório em branco estiver informado em PHP_INI_SCAN_DIR, o PHP também procurará pelo diretório informado na diretiva de compilação --with-config-file-scan-dir.

Dentro de cada diretório o PHP irá pesquisar todos os arquivos terminados em .ini em ordem alfabética. A lista de arquivos é carregada, e nessa ordem são interpretados com uma chamada a php_ini_scanned_files(), o por rodar o PHP com a opção --ini.

Assumindo que o PHP foi configurado com --with-config-file-scan-dir=/etc/php.d,
e o separador de caminho é :...

$ php
  PHP irá carregar todos os arquivos de configuração em in /etc/php.d/*.ini.

$ PHP_INI_SCAN_DIR=/usr/local/etc/php.d php
  PHP irá carregar todos os arquivos de configuração em /usr/local/etc/php.d/*.ini.


$ PHP_INI_SCAN_DIR=:/usr/local/etc/php.d php
  PHP irá carregar todos os arquivos de configuração em /etc/php.d/*.ini, e então em
  /usr/local/etc/php.d/*.ini.

$ PHP_INI_SCAN_DIR=/usr/local/etc/php.d: php
  PHP irá carregar todos os arquivos de configuração em /usr/local/etc/php.d/*.ini, e então em
  /etc/php.d/*.ini.

Executando PHP como módulo do Apache

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ê precisará de privilégios "AllowOverride Options" ou "AllowOverride All" para fazer isso.

Há várias diretivas do Apache que permitem que você mude a configuração do PHP de dentro dos arquivos de configuração do Apache. Para uma lista de quais diretivas são INI_ALL, INI_PERDIR, or INI_SYSTEM, olhe no apêndice Lista de diretivas do arquivo php.ini.

php_value name value

Define o valor da diretiva especificada. Pode ser usado apenas com diretivas do tipo INI_ALL e INI_PERDIR. Para limpar um valor definido anteriormente, use o valor none.

Nota: Não use php_value para definir valores booleanos. A diretiva php_flag deve ser usada (veja abaixo).

php_flag name on|off

Usado para definir uma diretiva de configuração booleana. Pode ser usada apenas com diretivas dos tipos INI_ALL e INI_PERDIR.

php_admin_value name value

Define o valor da diretiva especificada. Essa diretiva não pode ser usada em arquivos .htaccess. Qualquer tipo de diretiva definido com php_admin_value não pode ser sobrescrito pelo .htaccess ou pela função ini_set(). Para limpar um valor definido anteriormente, use o valor none.

php_admin_flag name on|off

Usado para definir uma diretiva de configuração booleana. Essa diretiva não pode ser usada em arquivos .htaccess. Qualquer tipo de diretiva definido com php_admin_flag não pode ser sobrescrito pelo .htaccess ou pela função ini_set().

<IfModule mod_php5.c>
  php_value include_path ".:/usr/local/lib/php"
  php_admin_flag engine on
</IfModule>
<IfModule mod_php4.c>
  php_value include_path ".:/usr/local/lib/php"
  php_admin_flag engine on
</IfModule>

Mudando configuração do PHP através do registro do Windows

Quando executar o PHP no Windows, os valores de configuração podem ser modificados para cada diretório, usando o registro do Windows. Os valores de configuração são armazenados 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 armazenados na chave HKLM\SOFTWARE\PHP\Per Directory Values\c\inetpub\wwwroot. As configurações para o diretório estarão ativas para qualquer script rodando neste 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 PHP nos valores não são interpretados. Apenas valores de configuração modificáveis no INI_USER podem ser definidos desta forma, e valores do INI_PERDIR não podem, pois esses valores são recarregados em cada request.

Outras interfaces para PHP

Independente de como você execute PHP, você pode mudar certos valores durante a execução de seus scripts através da função ini_set(). Veja a documentação na página ini_set() para mais informações.

Se você estiver interessado na lista completa das configurações definidas no seu sistema com os 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 as funções ini_get() ou get_cfg_var().

Tipos atômicos

Tipos atômicos são tipos internos que são fortemente integrados com a linguagem e não podem ser reproduzidos com tipos definidos pelo usuário.

A lista de tipos básicos é:

• Tipos integrados
  • tipo null
  • Tipos escalares:
    • tipo bool
    • tipo int
    • tipo float
    • tipo string
  • tipo array
  • tipo object
  • tipo resource
  • tipo never
  • tipo void
  • Tipos de classes relativas: self, parent, e static
• Valores literais
  • false
  • true
• Tipos definidos pelo usuário (geralmente chamados de tipos de classe)
  • Interfaces
  • Classes
  • Enumerações
• tipo callable

Tipos compostos

É possível combinar vários tipos atômicos em tipos compostos. O PHP permite que os tipos sejam combinados das seguintes maneiras:

• Interseção de tipos de classes (interfaces e nomes de classes).
• União de tipos.

Alias de tipo

O PHP suporta dois aliases de tipo: mixed e iterable que corresponde ao tipo de união de object|resource|array|string|float|int|bool|null e Traversable|array, respectivamente.

Nota: O PHP não suporta aliases de tipo definidos pelo usuário.

Sintaxe

Há apenas um valor do tipo null, a constante case-insensitive null.

Convertendo para null

Converter uma variável para null utilizando (unset) $var não removerá a variável ou apagará seu valor. Apenas retornará null como valor.

Veja Também

• is_null()
• unset()

Sintaxe

Para especificar um bool literal, use as palavras-chave true ou false. Ambas são case-insensitive.

Tipicamente, o resultado de um operador que retorne um valor bool, é passado para uma estrutura de controle.

Convertendo para booleano

Para converter explicitamente um valor em bool, use a conversão (bool). Geralmente isso não é necessário porque quando um valor é usado em um contexto lógico ele será automaticamente interpretado como um valor do tipo bool. Para obter mais informações, consulte a página Manipulação de tipos.

Ao converter para bool, os seguintes valores são considerados false:

• o próprio booleano false
• o inteiro 0 (zero)
• os pontos flutuantes 0.0 e -0.0 (zero)
• uma string vazia "", e a string "0"
• um array sem elementos
• o tipo especial NULL (incluindo variáveis não definidas)
• Objetos internos que sobrecarregam seu comportamento de conversão para bool. Por exemplo: Objetos SimpleXML criados a partir de elementos vazios sem atributos.

Todos os outros valores são considerados true (incluindo resource e NAN).

Veja Também

• Números de ponto flutuante
• Precisão arbitrária / BCMath
• Número inteiro de comprimento arbitrário / GMP

Sintaxe

Int pode ser especificado em notação decimal (base 10), hexadecimal (base 16), octal (base 8) ou binária (base 2). O operador de negação pode ser usado para indicar um int negativo.

Para usar a notação octal, preceda o número com um 0 (zero). A partir do PHP 8.1.0, a notação octal também pode ser precedida por 0o ou 0O. Para utilizar a notação hexadecimal, preceda o número com 0x. Para utilizar a notação binária, preceda o número com 0b.

A partir do PHP 7.4.0, inteiros literais podem conter sublinhados (_) entre os dígitos, para melhorar a sua leitura. Estes sublinhados serão removidos pelo scanner do PHP.

Formalmente, a estrutura para literais int é a partir do PHP 8.1.0 (anteriormente, os prefixos octal 0o ou 0O não eram permitidos, e antes do PHP 7.4.0 os sublinhados não eram permitidos):

decimal     : [1-9][0-9]*(_[0-9]+)*
            | 0

hexadecimal : 0[xX][0-9a-fA-F]+(_[0-9a-fA-F]+)*

octal       : 0[oO]?[0-7]+(_[0-7]+)*

binary      : 0[bB][01]+(_[01]+)*

integer     : decimal
            | hexadecimal
            | octal
            | binary

O tamanho de um int depende da plataforma, embora um valor máximo de cerca de dois bilhões seja o valor usual (são 32 bits assinados). As plataformas de 64 bits geralmente têm um valor máximo de cerca de 9E18. O PHP não suporta int não assinados. O tamanho int pode ser determinado usando a constante PHP_INT_SIZE, o valor máximo usando a constante PHP_INT_MAX e o valor mínimo usando a constante PHP_INT_MIN.

Overflow de inteiros

Se o PHP encontrar um número além dos limites do tipo int, ele será interpretado como um float. Assim, uma operação que resulte em um número além dos limites do tipo int, retornará um float.

Não existe operador de divisão int no PHP, para conseguir isso use a função intdiv() . 1/2 produz o float 0.5. O valor pode ser convertido em um int para arredondar para zero ou a função round() fornece um controle mais preciso sobre o arredondamento.

Convertendo para inteiro

Para converter explicitamente um valor para int, utiliza-se um dos modificadores (int) ou (integer). Entretanto, na maioria dos casos, o modificador não é necessário, já que o valor será automaticamente convertido se um operador, função ou estrutura de controle requerer um int como argumento. Um valor também pode ser convertido para int utilizando a função intval().

Se um resource for convertido para um int, resultará no número único do recurso, atribuído ao resource pelo PHP em tempo de execução.

Veja também Manipulação de tipos.

Convertendo para float

Comparando floats

Como notado acima, testar números de ponto flutuante com igualdade é problemático, por causa da maneira como são representados internamente. Entretanto existem maneiras de fazer comparações com números de ponto flutuante que contornam essas limitações.

Para testar números de ponto flutuante, utilize um "valor de erro máximo" na comparação utilizada. Esse valor é também chamado de epsilon, ou unidade de erro, e deve ser a diferença mínima aceitável no resultado dos cálculos.

NaN

Algumas operações numéricas podem resultar em valores representados pela constante NAN. Esse resultado representa um valor desconhecido ou não representável nos cálculos de ponto flutuante. Qualquer comparação frouxa ou restrita deste valor com qualquer outro, inclusive ele mesmo, com exceção de true, terá como resultado false.

Como o NAN representa um resultado irrepresentável, NAN não deve ser comparado com outros valores, incluindo ele mesmo, em vez disso, deve-se checá-lo utilizando a função is_nan().

Sintaxe

Uma string literal pode ser especificada de quatro formas diferentes.

• aspas simples
• aspas duplas
• sintaxe heredoc
• sintaxe nowdoc

      a
     b
    c

  a
 b
c

PHP Parse error:  Invalid body indentation level (expecting an indentation level of at least 3) in example.php on line 4

PHP Parse error:  Invalid indentation - tabs and spaces cannot be mixed in example.php line 8

array(2) {
  [0] =>
  string(11) "a
  b
    c"
  [1] =>
  string(5) "d e f"
}

PHP Parse error:  syntax error, unexpected identifier "ING", expecting "]" in example.php on line 6

Meu nome é "Meu nome". Eu estou imprimindo Foo.
Agora, eu estou imprimindo Bar2.
Isto deve imprimir um 'A' maiúsculo: A

Exemplo de string abrangendo várias linhas
usando a sintaxe nowdoc. As barras invertidas são sempre tratadas literalmente,
por exemplo. \\ e \'.

Meu nome é "$nome". Estou imprimindo alguns $foo->foo.
Agora, estou imprimindo alguns {$foo->bar[1]}.
Isso não deve imprimir um 'A' maiúsculo: \x41

Ele bebeu um pouco de suco de maçã.
Ele bebeu um pouco de suco feito de .
Ele bebeu um pouco de suco feito de maçãs.

Ele bebeu um pouco de suco de maçã.
Ele bebeu um pouco de suco de laranja.
Ele bebeu um pouco de suco roxo.
John Smith bebeu um pouco de suco de maçã.
John Smith então disse olá para Jane Smith.
A esposa de John Smith cumprimentou Robert Paulsen.
Robert Paulsen cumprimentou os dois .

O caractere no índice -2 é n.
Alterar o caractere no índice -3 para o dá strong.

I am bar.
I am bar.

string(1) "b"
bool(true)

Warning: Illegal string offset '1.0' in /tmp/t.php on line 7
string(1) "b"
bool(false)

Warning: Illegal string offset 'x' in /tmp/t.php on line 9
string(1) "a"
bool(false)
string(1) "b"
bool(false)

Funções e operadores úteis

Strings podem ser concatenadas utilizando o operador '.' (ponto). Note que o operador '+' (adição) não funciona para isso. Veja operadores de string para mais informações.

Há bastantes funções úteis para manipulação de strings.

Veja a seção de funções de string para funções gerais e funções de expressões regulares compatíveis com Perl para funcionalidades avançadas de localização & e substituição.

Há também funções para strings URL e funções para criptografia/descriptografia de strings (Sodium e Hash).

Finalmente, veja também as funções de tipos de caracteres.

Conversão em strings

Um valor pode ser convertido em uma string utilizando o modificador (string) ou a função strval(). A conversão em string é automaticamente realizada no escopo de uma expressão onde uma string é necessária. Isto acontece no uso das funções echo ou print ou quando o valor de uma variável é comparado com uma string. As seções Tipos e Conversão de Tipos tornarão um pouco mais claro o assunto. Veja também a função settype().

O valor bool true é convertido para a string "1". O bool false é convertido para "" (uma string vazia). Isso permite converter nos dois sentidos entre os valores bool e string.

Um int ou um float é convertido para uma string representando o número textualmente (incluindo a parte do expoente nos floats). Números de ponto flutuante podem ser convertidos usando a notação exponencial (4.1E+6).

Nota:

A partir do PHP 8.0.0, o caracter de ponto decimal sempre é um periodo ("."). Anteriormente ao PHP 8.0.0, o ponto decimal era definido pelo locale do script (LC_NUMERIC). Veja mais detalhes na função setlocale().

Arrays são sempre convertidos para uma string "Array"; por isso echo e print não podem, por si só, mostrar o conteúdo de um array. Para visualizar um único elemento, use uma construção como echo $arr['foo']. Veja abaixo dicas de como visualizar todo seu conteúdo.

Para converter objects em strings, o método mágico __toString deve ser usado.

Resources são sempre convertidos para strings na estrutura "Resource id #1" onde 1 é o número único do resource atribuído pelo PHP em tempo de execução. Apesar de que a estrutura exata desta string não seja confiável e esteja sujeita a modificações, será sempre única a um dado recurso dentro do ciclo de vida de um script sendo executado (por exemplo numa requisição Web ou em um processo CLI) e não será reutilizada. Para obter o tipo de um resource, utilize a função get_resource_type().

null é sempre convertido para uma string vazia.

Como declarado acima, converter diretamente um array, object ou resource para uma string não fornece nenhuma informação útil sobre o valor, a não ser seu tipo. Veja as funções print_r() e var_dump() para maneiras mais efetivas de inspecionar o conteúdo destes tipos.

A maioria dos valores no PHP também podem ser convertidos em strings para armazenamento permanente. Este método é chamado de serialização e pode ser feito com a função serialize().

Detalhes do tipo string

A string no PHP é implementada como um array de bytes e um inteiro indicando seu tamanho no buffer. Não existem informações de como esses bytes são traduzidos em caracteres, ficando essa tarefa com o programador. Não existem limitações sobre a composição dos valores da string; em particular, bytes com valor 0 (“NUL bytes”) são permitidos em qualquer lugar da string (entretanto, algumas funções, mencionadas neste manual como não “binary safe”, podem repassar as strings para bibliotecas que ignorem os dados após o byte nulo.)

Esta natureza do tipo string explica o motivo de não haver o tipo "byte" disponível no PHP – as strings assumem este papel. Funções que não retornam nenhuma informação textual – por exemplo, dados arbitrários lidos de um socket de rede – continuarão retornando strings.

Dado que o PHP não dita uma codificação específica para strings, pode-se questionar como strings literais seriam codificadas. Por exemplo, a string "á" é equivalente a "\xE1" (ISO-8859-1), "\xC3\xA1" (UTF-8, C form), "\x61\xCC\x81" (UTF-8, D form) ou qualquer outra representação possível? A resposta é que a string poderá ser codificada em qualquer forma que o arquivo de script estiver codificado. Assim, se o script for escrito na codificação ISO-8859-1, a string será codificada como ISO-8859-1 e assim por diante. Entretanto, isso não se aplica se o Zend Multibyte estiver ativado; neste caso, o script pode ser escrito em uma codificação arbitrária (que é declarada explicitamente ou é detectada) e então convertida em um codificação interna, a qual será a codificação utilizada nas strings literais. Note que há algumas restrições na codificação do script (ou na codificação interna caso o Zend Multibyte esteja ativo) – isso quase sempre significa que essa codificação deve ser um conjunto que contenha dentro de si a ASCII, como UTF-8 ou ISO-8859-1. Note, entretanto, que codificações que são dependentes de estado, onde os mesmos valores de bytes possam ser utilizados tanto em estados iniciais quanto não iniciais, podem ser problemáticos.

Claro que, para serem úteis, funções que operam em textos podem ter que fazer certas suposições sobre como as strings foram codificadas. Infelizmente, existem muitas variações sobre este assunto através das funções do PHP:

• Algumas funções assumem que a string foi codificada em alguma (qualquer) codificação de byte único, mas elas não precisam interpretar estes bytes como caracteres específicos. Este é por exemplo o caso das funções substr(), strpos(), strlen() ou strcmp(). Outra forma de refletir sobre essas funções é que elas operam em buffers de memória, isto é, elas trabalham com bytes e deslocamento de bytes.
• Outras funções recebem a codificação da string, possivelmente elas assumem um padrão se nenhuma informação lhes for passada. Este é o caso da função htmlentities() e da maioria das funções da extensão mbstring.
• Outras utilizam o idioma atual (veja setlocale()), mas elas operam byte-a-byte.
• Finalmente, elas podem simplesmente assumir que a string esteja utilizando uma codificação específica, geralmente UTF-8. Este é o caso da maioria das funções das extensões intl e PCRE (na segunda, somente quando o modificador u é utilizado).

Por fim, isso significa que escrever programas corretos utilizando Unicode depende de evitar cuidadosamente funções que não funcionam e que provavelmente irão corromper os dados e usar, em substituição, funções que se comportem corretamente, geralmente das extensões intl e mbstring. Entretanto, usar funções que manipulam codificações Unicode é somente o começo. Não importa as funções que a linguagem provê, é essencial saber a especificação Unicode. Por exemplo, um programa que supõem que só existem maiúsculas e mínusculas está fazendo uma suposição errada.

Strings usadas em contextos numéricos

Quando uma string precisa ser avaliada como número (por exemplo, operações aritméticas, declaração de tipo int, etc.), as seguintes etapas são executadas para determinar o resultado:

1. Se a string for numérica, resolva para um int se a string for uma string numérica inteira e se encaixar nos limites do tipo int (conforme definido por PHP_INT_MAX), caso contrário resolva para um float.
2. Se o contexto permitir strings numéricas iniciais e a string for uma, resolva para um int se a parte inicial da string for uma string numérica inteira e se encaixar nos limites do tipo int (conforme definido por PHP_INT_MAX), caso contrário resolva para um float. Além disso, um erro de nível E_WARNING é gerado.
3. A string não é numérica, lance um TypeError.

Comportamento antes do PHP 8.0.0

Antes do PHP 8.0.0, uma string era considerada numérica apenas se tivesse espaços em branco à esquerda, se tivesse espaços em branco à direita, a string era considerada numérica à esquerda.

Antes do PHP 8.0.0, quando uma string era usada em um contexto numérico, ela executava as mesmas etapas acima com as seguintes diferenças:

• O uso de uma sequência numérica inicial geraria um E_NOTICE em vez de um E_WARNING.
• Se a string não for numérica, um E_WARNING foi levantado e o valor 0 seria retornado.

Sintaxe

array(
    chave  => valor,
    chave2 => valor2,
    chave3 => valor3,
    ...
)

array(1) {
  [1]=>
  string(1) "d"
}

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hello"
  [3]=>
  string(5) "world"
}

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}

array(7) {
  [1]=>
  string(1) "g"
  [-1]=>
  string(1) "d"
  ["01"]=>
  string(1) "e"
  ["1.5"]=>
  string(1) "f"
  [0]=>
  string(1) "h"
  [""]=>
  string(1) "j"
  [2]=>
  string(1) "l"
}

string(3) "bar"
int(24)
string(3) "foo"

$arr[chave] = valor;
$arr[] = valor;
// chave pode ser tanto um int quanto uma string
// valor pode ser qualquer valor de qualquer tipo

Funções úteis

Há uma série de funções úteis para trabalhar com arrays. Veja a seção sobre funções para arrays.

Nota:

A função unset() permite apagar chaves de um array. Esteja avisado que o array não será reindexado. Se um comportamento como "remover e deslocar" é o desejado, o array poderá ser reindexado utilizando a função 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(0 => 'um', 1 =>'três')
?>

A estrutura de controle foreach existe especificamente para lidar com arrays. Ele provê uma maneira fácil de percorrer um array.

Array: faça e não faça