Permitiendo que Lighttpd lance procesos de php

Para configurar Lighttpd para que se conecte a php y lance procesos fastcgi, debe editar lighttpd.conf. Se recomienda utilizar sockets para conectar fastcgi a los procesos del 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
  ))
)

La directiva bin-path permite a lighttpd lanzar procesos fastcgi dinámicamente. PHP creará nuevos procesos hijos según se especifique en la variable de entorno PHP_FCGI_CHILDREN. La directiva "bin-environment" establece el entorno de los nuevos procesos. Cada vez que se alcance un determinado número de peticiones, determinado por PHP_FCGI_MAX_REQUEST, se matará un proceso. Las directivas "min-procs" y "max-procs" deben, por norma general, evitarse con PHP. PHP gestiona sus propios hijos, de forma que cachés como APC sólo estarán disponibles para los procesos gestionados por PHP. Si se establece "min-procs" a un número superior a 1, el número total de procesos oyentes en php se multiplicará por PHP_FCGI_CHILDREN (2 min-procs * 16 hijos produce 32 oyentes).

Lanzando procesos con spawn-fcgi

Lighttpd contiene el programa spawn-fcgi que facilita lanzar procesos fastcgi.

Lanzando procesos php-cgi

Pese a que es más laborioso, es posible lanzar procesos sin spawn-fcgi. La variable de entorno PHP_FCGI_CHILDREN controla cuántos procesos hijo de PHP se lanzarán para manejar las peticiones entrantes. PHP_FCGI_MAX_REQUESTS determinará el tiempo de vida (en peticiones) de cada proceso hijo. Aquí se muestra un script en bash que asiste en la creación de procesos php.

#!/bin/sh

# Ubicación del binario php-cgi
PHP=/usr/local/bin/php-cgi

# Ubicación del fichero PID
PHP_PID=/tmp/php.pid

# Enlazando a una dirección
#FCGI_BIND_ADDRESS=10.0.1.1:10000
# Enlazando a un socket de dominio
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"

Conexión a instancias FCGI remotas

Para poder tener aplicaciones escalables, pueden lanzarse instancias de fastcgi en múltiples equipos remotos.

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

Pruebas

Si has construido PHP como un programa CGI, puede probar su construcción escribiendo make test. Siempre es una buena idea probar su construcción. De esta manera usted puede encontrar un problema al principio con PHP en la plataforma, en lugar de tener que luchar con él más adelante.

Utilización de variables

Algunos servidores suministrando variables de entorno no se definen en las actuales » CGI/1.1 specification. Sólo las siguientes variables no se definen: 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, and SERVER_SOFTWARE. Todo lo demás debe ser tratado como "extensiones de proveedor".

Utilizando paquetes binarios

Utilizar paquetes binarios para instalar PHP sobre OpenBSD es el método más simple y recomendado. El paquete principal ha sido separado de los distintos módulos, y cada uno puede ser instalado removido independientemente de los otros. Los ficheros que se necesitan pueden ser encontrados en el CD de OpenBSD o en el sitio FTP.

El paquete principal que se necesita instalar es php4-core-4.3.8.tgz, que contiene el motor básico (además de gettext e iconv). Seguido, tómese un vistazo a los paquetes de módulos, tales como php4-mysql-4.3.8.tgz o php4-imap-4.3.8.tgz. Se necesita emplear el comando phpxs para activar y desactivar estos módulos en el fichero php.ini.

# 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
  (agregar mysql)
# pkg_add php4-mysql-4.3.8.tgz
# /usr/local/sbin/phpxs -a mysql
  (agregar imap)
# pkg_add php4-imap-4.3.8.tgz
# /usr/local/sbin/phpxs -a imap
  (quitar mysql a manera de prueba)
# pkg_delete php4-mysql-4.3.8
# /usr/local/sbin/phpxs -r mysql
  (instalar las librerías de PEAR)
# pkg_add php4-pear-4.3.8.tgz

Leer la página del manual » packages(7) para mas información sobre paquetes binarios en OpenBSD.

Utilizando portes

También se puede compilar PHP a partir de fuentes utilizando el » árbol de portes. Sin embargo, esto sólo se recomienda para usuarios familiarizados con OpenBSD. El porte de PHP 4 está dividido en dos subdirectorios: core y extensions. El directorio extensions genera subpaquetes para todos los módulos soportados de PHP. Si se encuentra que no se desea crear alguno de estos módulos, utilice el sabor o FLAVOR no_*. Por ejemplo, para evitar compilar el módulo imap, fijar el sabor o FLAVOR a no_imap.

Problemas comunes

• La instalación por omisión de Apache se ejecuta dentro de una » jaula chroot(2), que habrá de restringir a los script PHP el acceso a ficheros debajo de /var/www. Por lo tanto se requiere crear un directorio /var/www/tmp para que los ficheros de sesión de PHP sean almacenados, o utilizar un medio alternativo de almacenamiento de sesiones. Además, los sockets de base de datos necesitan colocarse dentro de la jaula o escuchar en la interfaz de localhost. Se se hace uso de funciones de red, algunos ficheros de /etc tales como /etc/resolv.conf y /etc/services tendrán que ser movidos a /var/www/etc. El paquete PEAR de OpenBSD automáticamente se instala dentro de los directorios correctos del chroot, así que no hace falta ninguna modificación especial ahí. Más información sobre el Apache de OpenBSD está disponible en las preguntas frecuentes OpenBSD.
• El paquete de OpenBSD 3.6 para la extensión » gd requiere que XFree86 sea instalado. Si no se desea utilizar algunas de las características de fuentes tipográficas que requieren de X11, es mejor instalar el paquete php4-gd-4.3.8-no_x11.tgz.

Ediciones antiguas

Ediciones antiguas de OpenBSD utilizaban el sistema FLAVORS para compilar un PHP enlazado estáticamente. Dado que es difícil generar paquetes binarios utilizando este método, ahora es depreciado. Aún es posible utilizar los viejos árboles estables de ports si así se desea, pero carecen de soporte por parte del equipo de OpenBSD. Si se tiene algún comentario al respecto, el responsable actual del port es Anil Madhavapeddy (avsm arroba openbsd punto org).

Software necesario

La instalacion Solaris carece con frecuencia de los compiladores de C y sus herramientas relacionadas. Lea las preguntas frecuentes para obtener información sobre porqué usar versiones GNU de algunas de estas herramientas.

Para descomprimir la distribución PHP se necesita

• tar
• gzip ó
• bzip2

Para compilar PHP se necesita

• gcc (recomendado, aunque puede que sirvan otros compiladores de C)
• make
• GNU sed

Para compilar extensiones adicionales o hackear el código PHP puede que se necesite también

• flex (versión PHP 5.2 o posterior)
• re2c
• bison
• m4
• autoconf
• automake

Empleo de paquetes

Se puede simplificar el procesao de intalación de Solaris mediante el uso de pkgadd para instalar la mayoría de sus componentes necesarios. El Sistema de Empaquetado de Imagen (IPS) para Solaris 11 Express contiene también la mayoría de los componentes requeridos para la instalación usando el comando pkg.

Utilizando APT

Primero, nótese que otros paquetes relacionados podrían ser deseables como libapache2-mod-php5 para integración con Apache 2, y php-pear para PEAR.

Segundo, antes de instalar un paquete, es sensato asegurarse de que la lista de paquetes está al día. Típicamente, esto se realiza ejecutando el comando apt-get update.

# apt-get install php5-common libapache2-mod-php5 php5-cli

APT instalará automáticamente el módulo PHP 5 para Apache 2 junto con todas sus dependencias, y luego lo activará. Apache debería reiniciarse para que los cambios tengan efecto. Por ejemplo:

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

Un mejor control de la configuración

En la sección anterior, PHP se instaló únicamente con los módulos principales. Es muy probable que se deseen módulos adicionales, tales como MySQL, cURL, GD, etc. Estos también pueden ser instalados vía el comando apt-get.

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

Los ejemplos mostrarán una gran cantidad de paquetes incluyendo varios específicos a PHP como php5-cgi, php5-cli y php5-dev. Determine cuales son necesarios e instálelos como cualquier otro ya sea con apt-get o aptitude. Y ya que Debian realiza revisión de dependencias, preguntará por ellos, así que por ejemplo para instalar MySQL y cURL:

# apt-get install php5-mysql php5-curl

APT agregará automáticamente las líneas apropiadas a los diferentes ficheros relacionados con php.ini como /etc/php5/apache2/php.ini, /etc/php5/conf.d/pdo.ini, etc. y dependiendo de la extensión, le agregará registros similares a extension=foo.so. De cualquier manera, reiniciar el servidor web (como es Apache) es requerido antes de que estos cambios tengan efecto.

Problemas Frecuentes

• Si los scripts de PHP no se están interpretando por el servidor web, entonces es probable que PHP no haya sido agregado al fichero de configuración del servidor web, que en Debian puede ser /etc/apache2/apache2.conf o algo semejante. Véase el manual de Debian para mayores detalles.
• Si una extensión fue aparentemente instalada y aún así las funciones no aparecen definidas, asegurar de que el fichero ini apropiado está siendo cargado y/o que el servidor web fue reiniciado después de la instalación.
• Hay dos comandos básicos para instalar paquetes en Debian (y otras variantes de linux): apt-get y aptitude. Pero, explicar las sutiles diferencias entre estos comandos va más allá del alcance de este manual.

Herramientas de instalación de PHP

Si quiere configurar PHP y está usando IIS, la forma más fácil es usar » El instalador de la plataforma web de Microsoft (WebPI).

» XAMPP, WampServer y BitNami configurarán las aplicaciones PHP para su uso con Apache en Windows.

La configuración de Nginx en Windows requiere un poco más de configuración. Vea la » documentación de Nginx para obtener ayuda adicional con la configuración.

OpCache

Se recomienda habilitar OpCache. Esta extensión está incluida en PHP para Windows. Compila y optimiza scripts de PHP y los almancena en memoria caché para así no tener que compilarlos cada vez que se cargue la página.

En el php.ini, establezca

zend_extension=php_opcache.dll
opcache.enable=On
opcache.cli_enable=On

WinCache

Se recomienda que se use WinCache si se utiliza IIS, especialmente en un entorno de alojamiento web compartido o si se utiliza el almacenamiento de ficheros en red (NAS). Tenga en cuenta que WinCache ya no es compatible con PHP 8.0.0. Todas las aplicaciones de PHP se benefician automáticamente de la funcionalidad de almancenamiento en caché de WinCache. Las operaciones en el sistema de ficheros se almacenan en memoria caché. WinCache también puede almacenar en memoria caché objetos de usuario y compartirlos entre procesos de php.exe o php-cgi.exe (objetos compartidos entre peticiones). Muchas de las grandes aplicaciones web tienen un complemento, extensión u opción de configuración para hacer uso de la caché de objetos de usuario de WinCache. Si lo que necesita es un alto rendimiento, debería utilizar la caché de objetos en sus aplicaciones. Véase: » http://pecl.php.net/package/WinCache para descargar una DLL (o tgz) de WinCache a su directorio de extensiones de PHP (extensions_dir en el php.ini). En el php.ini, establezca

extension=php_wincache.dll
wincache.fcenabled=1
wincache.ocenabled=1 ; eliminado a partir de 2.0.0.0

Configuración de IIS

En el Administrador de IIS, Instalar módulo FastCGI y añadir un manejador para `.php` a la ruta de PHP-CGI.exe (no de PHP.exe)

Puede usear la herramienta de línea de comandos APPCMD para configurar IIS.

Base de datos

Probablemente necesitará un servidor de bases de datos. Las bases de datos populares proporcionan extensiones de PHP para utillzarlas. Si su sitio web no tiene mucho tráfico, puede ejecutar el servidor de bases de datos en su mismo servidor web. Muchos servidores de bases de datos se ejecutan en Windows.

PHP incluye las extensiones mysqli y pdo_mysql.

Véase » https://dev.mysql.com/downloads/windows/

Elección del servidor web

@echo off

REM Descargar el fichero .ZIP o la compilación de PHP desde http://windows.php.net/downloads/
REM
REM Ruta al directorio donde se ha descomprimido el fichero .ZIP de PHP
set phpdir=c:\php


REM Limpiar los manejadores actuales de PHP
%windir%\system32\inetsrv\appcmd clear config /section:system.webServer/fastCGI
REM El siguiente comando generará un mensaje de error si PHP no está instalado. Esto puede ser ignorado.
%windir%\system32\inetsrv\appcmd set config /section:system.webServer/handlers /-[name='PHP_via_FastCGI']

REM Instalar el manejador de 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 Configurar las variables de 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']"

Elegir una compilación

Descargue las versiones de producción de PHP desde » http://windows.php.net/download/. Todas las compilaciones están optimizadas (PGO), y las versiones de QA y GA se prueban exhaustivamente.

Existen 4 tipos de compilación de PHP:

• Thread-Safe(TS) - usada para servidores web monoproceso, como Apache con mod_php

• Non-Thread-Safe(NTS) - usada para IIS y otros servidores web FastCGI (Apache con mod_fastcgi) y la recomendad para scripts de línea de comandos

• x86 - para sistemas de 32-bits.

• x64 - para sistemas de 64 bits.

Instalación como un controlador de Apache

Para cargar el módulo PHP en Apache 2.x las siguientes líneas en el fichero de configuración httpd.conf de Apache deben ser añadidas:

#
LoadModule php8_module "c:/php/php8apache2_4.dll"
AddHandler application/x-httpd-php .php
# configure the path to php.ini
PHPIniDir "C:/php"

Nota: Recuerde, la ruta real de PHP debe sustituirse por C:/php/ en los ejemplos anteriores. Asegúrese que el fichero al que hace referencia en la directiva LoadModule está en la ubicación especificada, y utilize php7apache2_4.dll para PHP 7, o php8apache2_4.dll para PHP 8.

The above configuration will enable PHP handling of any file that has a .php extension, even if there are other file extensions. For example, a file named example.php.txt will be executed by the PHP handler. To ensure that only files that end in .php are executed, use the following configuration instead: La configuración anterior permitirá el manejo de PHP de cualquier fichero que contenga la extensión .php, incluso si hay otras extensiones de fichero. Por ejemplo, el fichero llamado example.php.txt será ejecutado por el controlador PHP. Para garantizar que solo se ejecuten los ficheros que terminen en .php, utilice la siguiente configuración:

<FilesMatch \.php$>
    SetHandler application/x-httpd-php
</FilesMatch>

Ejecución de PHP como CGI

Se recomienda consultar la » documentación de Apache CGI para una comprensión más completa de la ejecución de CGI en Apache.

Para ejecutar PHP como CGI, deberá colocar los ficheros php-cgi en un directorio designado como directorio CGI utilizando la directiva ScriptAlias.

Será necesario colocar una línea #! en los ficheros PHP, que apunte a la ubicación del binario PHP:

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

Ejecutando PHP bajo FastCGI

Ejecutar PHP bajo FastCGI tiene una serie de ventajas con respecto a ejecutarlo bajo CGI. Configurarlo de esta manera es bastante sencillo:

Descargue mod_fcgid desde » https://www.apachelounge.com. Los binarios de Win32 están disponibles para descargar desde ese sitio. Instale el módulo de acuerdo con las instrucciones que lo acompañarán.

Configure su servidor web como se muestra a continuación, teniendo cuidado de ajustar cualquier ruta que reflejen la forma en que ha instalado las cosas en su sistema particular:

LoadModule fcgid_module modules/mod_fcgid.so
# ¿Dónde está el fichero php.ini?
FcgidInitialEnv PHPRC        "c:/php"
AddHandler fcgid-script .php
FcgidWrapper "c:/php/php-cgi.exe" .php

Comprobar los permisos del directorio temporal

Compilación desde el código fuente

Para habilitar FPM en la construcción de PHP, debe añadirse --enable-fpm a la línea de configuración.

Hay otras opciones de configuración específicas de FPM (todas ellas optativas):

• --with-fpm-user - Establecer el usuario de FPM (por omisión: nobody).

• --with-fpm-group - Establecer el grupo de FPM (por omisión: nobody).

• --with-fpm-systemd - Activar la integración del sistema (por omisión: no).

• --with-fpm-acl - Utilizar las listas de control de acceso de POSIX (por omisión: no). Desde 5.6.5

Lista de directivas globales de php-fpm.conf

pid string

Ruta al fichero PID. Valor por defecto: none.

error_log string

Ruta al fichero de registro de errores. Valor por defecto: #INSTALL_PREFIX#/log/php-fpm.log. Si se establece a "syslog", los registros son enviados a syslogd en lugar de escribir en un archivo local.

log_level string

Nivel de registro de errores. Posibles valores: alert, error, warning, notice, debug. Valor por defecto: notice.

log_limit int

Límite de registro para las líneas registradas que permite registrar mensajes de más de 1024 caracteres sin envolver. Valor por defecto: 1024. Disponible a partir de PHP 7.3.0.

log_buffering bool

Registro experimental sin almacenamiento adicional en el búfer. Valor por defecto: sí. Disponible a partir de PHP 7.3.0.

syslog.facility string

Usado para especificar qué tipo de programa está recibiendo los mensajes de registro. Valor por defecto: daemon.

syslog.ident string

Anteponer a cada mensaje. Si hay varias instancias FPM ejecutándose en el mismo servidor, puede cambiar el valor por defecto que debe adaptarse a sus necesidades. Valor por defecto: php-fpm.

emergency_restart_threshold int

Si este número de procesos termina con SIGSEGV o SIGBUS dentro del intervalo de tiempo establecido por emergency_restart_interval entonces FPM se reiniciará. Un valor de 0 corresponde a 'Off'. Valor por defecto: 0 (Off).

emergency_restart_interval mixed

Intervalo de tiempo usado por emergency_restart_interval para determinar cuando un reinicio agraciado será realizado. Esto puede ser útil trabajar sobre corrupciones accidentales in en acelerador de memoria compartida. Unidades disponibles:: s(segundos), m(inutos), h(oras), o d(ías). Unidad por defecto: segundos. Valor por defecto: 0 (Off).

process_control_timeout mixed

Límite de tiempo que un hilo de proceso espera por una señal maestra. Unidades disponibles: s(egundos), m(inutos), h(oras), o d(ías) Unidad por defecto: segundos. Valor por defecto: 0.

process.max int

El número máximo de procesos FPM creará. Esto ha sido diseñado para controlar el número global de procesos cuando se utiliza PM dinámico dentro de muchos pools. Utilícelo con precaución. Valor por defecto: 0.

process.priority int

Especifique la prioridad nice(2) que se aplicará al proceso maestro (sólo si se establece). El valor puede variar entre -19 (prioridad más alta) hasta 20 (prioridad más baja). Valor por defecto: no establecido.

daemonize boolean

Envía a FPM al background. Establezca a 'no' para mantener FPM en foreground para depuración. Valor por defecto: yes.

rlimit_files int

Establece el descriptor rlimit de archivos abiertos para el proceso maestro. Valor predeterminado: Establece el descriptor rlimit de archivos abiertos para el proceso maestro.

rlimit_core int

Establece el tamaño máximo del núcleo rlimit para el proceso maestro. Valor por defecto: 0.

events.mechanism string

Especifica el mecanismo de eventos que FPM utilizará. Los siguientes están disponibles: select, pool, epoll, kqueue (*BSD), port (Solaris). Valor por defecto: no establecido (auto-detección).

systemd_interval int

Cuando FPM es compilado con integración con systemd, especifique el intervalo, en segundos, entre notificaciones de reporte de salud a systemd. Coloque a 0 para deshabilitar. Valor por defecto: 10.

Lista de directivas de grupo

Con FPM usted puede correr varios grupos de procesos con diferentes ajustes. Estos son los parámetros que pueden ser ajustados por grupo.

listen string

La dirección sobre la cual desea aceptar peticiones FastCGI. Las sintaxis válidas son: 'ip.add.re.ss:port', 'port', '/path/to/unix/socket'. Esta opción es obligatoria por cada grupo.

listen.backlog int

Establece listen(2) backlog. Un valor de '-1' significa ilimitado. Valor por defecto: -1.

listen.allowed_clients string

Lista de direcciones ipv4 de clientes FastCGI que tienen permiso para conectarse. El equivalente a la variable de entorno FCGI_WEB_SERVER_ADDRS en el PHP FastCGI (5.2.2+) original. Tiene sentido solamente con un socket tcp escuchando. Cada dirección debe ser separada por coma. Si este valor es dejado en blanco, las conexiones serán aceptas desde cualquier dirección ip. Valor por defecto: any.

listen.owner string

Establece permisos para sockets unix, si uno es usado. En Linux, los permisos de lectura/escritura deben ser puestos a fin de permitir conexiones desde un servidor web. Muchos sistemas derivados de BSD permiten conexiones sin considerar los permisos. Valor por defecto: usuario y grupo son establecidos según el usuario ejecutor, permisos puestos a 0660.

listen.group string

Ver listen.owner.

listen.mode string

Ver listen.owner.

listen.acl_users string

Cuando las lsitas de control de acceso POSIX están soportadas, usted puede configurarlas usando esta opción. Cuando se establece, listen.owner y listen.group son ignoradas. El valor es una lista de nombres de usuario separado por comas. Desde PHP 5.6.5.

listen.acl_groups string

Ver listen.acl_users. El valor es una lista de nombres de grupo separado por comas. Desde PHP 5.6.5.

user string

Usuario Unix de procesos FPM. Esta opción es obligatoria.

group string

Grupo Unix group of FPM processes. Si no es establecido, el grupo del usuario por defecto será usado.

pm string

Seleccione cómo el manejador de procesos controlará el número de hilos de procesos. Valores posibles: static, ondemand, dynamic. Esta opción es obligatoria.

static - el número de hilos de proceso es fijo (pm.max_children).

ondemand - el proceso se lanza en demanda (cuando se solicita, al contrario que dynamic, donde pm.start_servers son iniciados cuando el servicio está iniciado.

dynamic - el número de hilos de proceso será basado dinámicamente basado en las siguientes directivas: pm.max_children, pm.start_servers, pm.min_spare_servers, pm.max_spare_servers.

pm.max_children int

El número de hilos de procesos a ser creados cuando pm es puesto a static y el máximo número de hilos de proceso a ser creados cuando pm es puesto a dynamic. Esta opción es obligatoria.

Esta opción establece el límite sobre el número de peticiones simultaneas que serán servidas. Equivale a la directiva ApacheMaxClients con mpm_prefork y a la variable de entorno PHP_FCGI_CHILDREN del PHP FastCGI original.

pm.start_servers int

Número de hilos de procesos creados al inicio. Usado solamente cuando pm es puesto a dynamic. Valor por defecto: min_spare_servers + (max_spare_servers - min_spare_servers) / 2.

pm.min_spare_servers int

El número mínimo deseado de procesos libres en el servidor. Usado sólo cuando pm es puesto a dynamic. También obligatorio en este caso.

pm.max_spare_servers int

El número máximo deseado de procesos libres en el servidor. usado sólo cuando pm es puesto a dynamic. También obligatorio en este caso.

pm.process_idle_timeout mixed

El número de segundos después de los cuales se matará un proceso inactivo. Usado sólo cuando pm está establecido como ondemand. Unidades disponibles: s(segundos)(predeterminado), m(inutos), h(horas), o d(ías). Valor por defecto: 10s.

pm.max_requests int

El número de pedidos que cada hilo de proceso debe ejecutar antes de reaparecer. Esto puede ser útil para evitar las fugas de memoria en librerías de terceros. para el procesamiento de solicitudes sin límites especifique '0'. Equivale a PHP_FCGI_MAX_REQUESTS. Valor por defecto: 0.

pm.status_path string

La dirección URI para ver la página de status FPM. Este valor debe comenzar con una barra inclinada (/). Si no se establece este valor, no se reconocerá ninguna URI como página de estado. Valor por defecto: ninguno. . Valor por defecto: none.

ping.path string

La dirección URI del ping para llamar a la página de monitor del FPM. Si este valor no es establecido, ninguna dirección URI será reconocida como página del ping. Esto debería ser usado para probar desde el exterior que el FPM está funcionando y respondiendo. Por favor, note que este valor debe empezar con un slash (/).

ping.response string

Esta directiva puede ser usada para personalizar las peticiones de respuestas a ping. La respuesta es formateada como text/plain con un código de respuesta 200. Valor por defecto: pong.

process.priority int

Especifique la prioridad nice(2) que se aplicará al proceso maestro (sólo si se establece). El valor puede variar entre -19 (prioridad más alta) hasta 20 (prioridad más baja). Valor por defecto: no establecido.

process.dumpable bool

Establece el indicador de proceso descargable (PR_SET_DUMPABLE prctl) incluso si el usuario o grupo del proceso o grupo es diferente al usuario del proceso maestro. Permite crear el proceso core dump y ptrace el proceso para el usuario del pool. Valor por defecto: no. Desde de PHP 7.0.29, 7.1.17 y 7.2.5.

prefix string

Establece un prefijo para la ruta de evaluación

request_terminate_timeout mixed

El tiempo de espera para servir una simple petición luego que el proceso worker sea eliminado. Esta opción debe ser usada cuando la opción 'max_execution_time' no detenga la ejecuciuón del script por cualquier razón. Un valor de '0' corresponde a 'Off'. Unidades disponibles: s(egundos)(por defecto), m(inutos), h(horas), or d(ías). Default value: 0.

request_slowlog_timeout mixed

El tiempo de espera para servir una simple petición después de que un backtrace PHP sea volcado al fichero 'slowlog'. Un valor de '0' corresponde a 'Off'. Unidades disponibles: s(egundos)(por defecto), m(inutos), h(oras), or d(ías). Valor por defecto: 0.

slowlog string

El fichero de registro para peticiones lentas. Valor por defecto: #INSTALL_PREFIX#/log/php-fpm.log.slow.

rlimit_files int

Establece el fichero descriptor rlimit. Valor por defecto: definido por el sistema.

rlimit_core int

Establece el tamaño máximo del rlimit. Valores posibles: 'unlimited' o un entero mayor o igualo a 0. Valor por defecto: definido por el sistema.

chroot string

Establece el Chroot (enjaulado) a este directorio al inicio. Este valor debe ser definido como una ruta absoluta. Cuando este valor no es establecido, el chroot no es usado.

chdir string

Establece el Chdir a este directorio al inicio. Este valor debe ser establecido como una ruta absoluta. Valor por defecto: directorio actual o / cuando está en chroot (enjaulado).

catch_workers_output boolean

Redirige los worker stdout y stderr en el fichero de registro principal. Sí no es establecido, stdout y stderr serán redirigidos a /dev/null de acuerdo a las especificaciones FastCGI. Valor por defecto: no.

decorate_workers_output bool

Habilitar la decoración de salida para la salida de los catch_workers_output si está activado. Valor por defecto: sí. Disponible a partir de PHP 7.3.0.

clear_env boolean

Entorno limpio in workers FPM. Evita que variables de entorno arbitrarias lleguen a los procesos FPM mediante la limpieza del entorno en los workers antes de que se añadan las variables env a las pools correspondientes a esta configuración. Desde PHP 5.4.27, 5.5.11, y 5.6.0. Valor por defecto: Yes.

security.limit_extensions string

Limita las extensiones del script principal que FPM procesará. Esto puede evitar errores de configuración del lado del servidor. Usted debería limitar su FPM a procesar unicamente extensiones .php para evitar que usuarios malintencionados usen diferentes extensiones para ejecutar código PHP. Valor por defecto: .php .phar

access.log string

Archivo de registro de acceso. Valor por defecto: no establecido

access.format string

Formato del archivo de registro de acceso. Valor por defecto: "%R - %u %t \"%m %r\" %s"

Opciones válidas

Placeholder	Descripción
%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	the glue between %q and %r
%r	request URI
%R	remote IP address
%s	status
%T	time
%t	time
%u	remote user

Es posible pasar las variables de entorno adicionales y actualizar los ajustes PHP de ciertos grupos. Para ello, se necesita agregar las siguientes opciones al fichero de configuración.

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

Ajustes definidos con php_admin_value and php_admin_flag cannot be anulados con ini_set().

Como 5.3.3, establecer los ajustes PHP es también posible como servidor web.

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: Los pools no son un mecanismo de seguridad, porque no proporcionan una separación total; por ejemplo, todos los pools utilizarían una única instancia de OPcache.

¿Dónde encontrar una extensión?

Las extensiones de PHP generalmente se llaman "php_*.dll" (donde el asterisco representa el nombre de la extensión) y se localizan bajo la carpeta "PHP\ext".

PHP se distribuye con las extensiones más útiles para la mayoría de desarrolladores. Se les llama extensiones del "núcleo".

En cualquier caso, si necesita una funcionalidad que no proporciona ninguna de las extensiones del núcleo, podrá buscarla en PECL. La Biblioteca de la Comunidad de Extensiones de PHP (PECL) es un repositorio de extensiones PHP, que proporciona un directorio de todas las extensiones conocidas, y aloja utilidades para descargar y desarrollar extensiones de PHP.

Si usted ha desarrollado una extensión para su propio uso, quizá quiera considerar alojarla en PECL, de forma que otros desarrolladores con las mismas necesidades puedan verse beneficiados de su tiempo. Una de las ventajas es que tendrá la oportunidad de recibir colaboración, (ojalá) agradecimientos, informes de errores, e incluso parches/correcciones. Antes de enviar su extensión para ser alojada en PECL, por favor, lea » el envío a PECL.

¿Qué extensión descargar?

A menudo, encontrará varias versiones de cada DLL:

• Números de versión diferentes (al menos los dos primeros números deben coincidir)
• Diferentes ajustes de seguridad en hilos
• Diferentes arquitecturas de procesadores (x86, x64, ...)
• Diferentes ajustes de depuración
• etc.

Debe tener en cuenta que los ajustes de su extensión deben coincidir con la configuración del ejecutable de PHP que está utilizando. El siguiente script de PHP le dirá todo sobre sus ajustes de PHP:

O ejecute desde la línea de comandos:

drive:\\path\to\php\executable\php.exe -i

Cargando una extensión

La forma más común de cargar una extensión PHP consiste en incluirla en el fichero de configuración php.ini. Por favor, tenga en cuenta que ya hay muchas extensiones presentes en el fichero php.ini y que sólo es necesario eliminar el punto y coma para activarlas.

Observe que en versiones de PHP 7.2.0 y superiores, se podría utilizar el nombre de extensión en lugar del nombre de fichero de la extensión. Ya que esto es independiente del SO y más sencillo, especialmente para recién llegados, se convierte en la forma recomendada de especificar estensiones a cargar. El soporte para nombres de ficheros permanece por compatibilidad con versiones anteriores.

;extension=php_extname.dll

extension=php_extname.dll

; On PHP version 7.2 and up, prefer :
extension=extname
zend_extension=another_extension

Sin embargo, algunos servidores web puede resultar confusos, dado que no utilizan el php.ini ubicado junto al ejecutable de PHP. Para averiguar dónde se localiza el php.ini en uso, consulte su ruta usando phpinfo():

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

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

Tras activar una extensión, guarde el fichero php.ini, reinicie el servidor web y vuelva a comprobar phpinfo(). La nueva extensión debe ahora tener su propia sección.

Resolviendo problemas

Si la extensión no aparece en phpinfo(), compruebe los registro de errores para conocer qué provoca el problema.

Si está utilizando PHP desde la línea de comandos (CLI), podrá leer directamente en pantalla el error en la carga de la extensión.

Si está usando PHP en un servidor web, la localización y formato de los registros vería en función de su software. Por favor, lea la documentación de su servidor web para localizar los registros, dado que esto no lo gestiona el propio ejecutable de PHP.

Los problemas más comunes son la ubicación del fichero DLL, el valor de " extension_dir" en php.ini, y desajustes de configuración en tiempo de compilación.

Si el problema reside en desajustes de configuración en tiempo de compilación, seguramente se deba a que no se ha descargado el fichero DLL correcto. Pruebe a descargar de nuevo la extensión con los ajustes correctos. De nuevo, phpinfo() puede resultar de gran ayuda.

Directorios de búsqueda

Es posible configurar PHP para que busque ficheros .ini en un directorio después de leer php.ini. Esto se puede realizar durante la compilación estableciento la opción --with-config-file-scan-dir. En PHP 5.2.0 y posteriores, el directorio de búsqueda puede ser sobrescrito durante la ejecución estableciendo la vairable de entorno PHP_INI_SCAN_DIR.

Es posible buscar en varios directorios separándolos con el separador de rutas específico de cada plataforma (; en Windows, NetWare y RISC OS; : en las demás plataformas; el valor que PHP emplea está disponible como la constante PATH_SEPARATOR). Si se proporciona a PHP_INI_SCAN_DIR un directorio en blanco, PHP también buscará en el directorio dado durante la compilación mediante --with-config-file-scan-dir.

PHP buscará dentro de cada directorio todos los ficheros que finalicen en .ini en orden alfabético. Se puede obtener una lista de los ficheros cargados, y en qué orden, llamando a php_ini_scanned_files(), o ejecutando PHP con la opción --ini.

Se asumen que PHP está configurado con --with-config-file-scan-dir=/etc/php.d,
y que el separador de rutas es :...

$ php
  PHP cargará todos los ficheros de /etc/php.d/*.ini como ficheros de configuración.

$ PHP_INI_SCAN_DIR=/usr/local/etc/php.d php
  PHP cargará todos los ficheros de /usr/local/etc/php.d/*.ini como
  ficheros de configuración.

$ PHP_INI_SCAN_DIR=:/usr/local/etc/php.d php
  PHP cargará todos los ficheros de /etc/php.d/*.ini, y luego de
  /usr/local/etc/php.d/*.ini como ficheros de configuración.

$ PHP_INI_SCAN_DIR=/usr/local/etc/php.d: php
  PHP cargará todos los ficheros de /usr/local/etc/php.d/*.ini, y luego de
  /etc/php.d/*.ini como ficheros de configuración.

Historial de cambios

Ejecutar PHP como un módulo de Apache

Cuando se usa PHP como un módulo de Apache, se pueden cambiar los ajustes de configuración usando directivas en los ficheros de configuración de Apache (p.ej. httpd.conf) y en los ficheros .htaccess. Se necesitarán los privilegios "AllowOverride Options" o "AllowOverride All" para poder hacerlo.

Existen varias directivas de Apache que permiten cambiar la configuración de PHP desde los propios ficheros de configuración de Apache. Para un listado las directivas que son INI_ALL, INI_PERDIR, o INI_SYSTEM, consulte el apéndice de la Lista de directivas de php.ini.

php_value nombre valor

Establece el valor de la directiva especificada. Sólo puede usarse con las directivas de tipo INI_ALL y INI_PERDIR. Para borrar un valor previamente establecido, use none como valor.

Nota: No use php_value para establecer valores boolean. Debe usarse en su lugar php_flag (ver más abajo).

php_flag nombre on|off

Usado para establecer una directiva de configuración de tipo boolean. Sólo puede usarse con las directivas de tipo INI_ALL y INI_PERDIR.

php_admin_value nombre valor

Establece el valor de la directiva especificada. Esto no se puede usar en ficheros .htaccess. Ninguna directiva establecida con php_admin_value podrá ser sobrescrita por .htaccess o por ini_set(). Para borrar un valor establecido previamente use none como valor.

php_admin_flag nombre on|off

Usado para establecer una directiva de configuración de tipo boolean. Esto no se puede usar en ficheros .htaccess. Ninguna directiva establecida con php_admin_flag podrá ser sobrescrita por .htaccess o por 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>

Cambiar la configuración de PHP a través del registro de Windows

Cuando se ejecuta PHP en Windows, se pueden modificar los valores de configuración a nivel de directorio usando el registro de Windows. Los valores de configuración se almacenan en la clave de registro HKLM\SOFTWARE\PHP\Per Directory Values, en las subclaves correspondientes a los nombres de ruta. Por ejemplo, los valores de configuración para el directorio c:\inetpub\wwwroot se almacenarían en la clave HKLM\SOFTWARE\PHP\Per Directory Values\c\inetpub\wwwroot. Los ajustes para el directorio estarán activos para cualquier script dentro de este directorio o en cualquiera de sus subdirectorios. Los valores bajo esta clave deberían tener el nombre de la directiva de configuración de PHP y el valor como string. Las constantes de PHP usadas como valor no serán procesadas. En cualquier caso, únicamente los valores de configuración modificables de INI_USER podrán establecerse con este método, mientras que los valores de INI_PERDIR no.

Otras interfaces a PHP

Independientemente de cómo ejecute PHP, se pueden cambiar determinados valores de los scripts en tiempo de ejecución mediante ini_set(). Consulte la documentación de la página ini_set() para más información.

Si está interesado en una lista completa de los ajustes de configuración en su sistema con sus valores actuales, puede ejecutar la función phpinfo(), y consultar la página mostrada. Puede también acceder a los valores de directivas de configuración concretas usando ini_get() o get_cfg_var().

Atomic types

Some atomic types are built-in types which are tightly integrated with the language and cannot be reproduced with user defined types.

The list of base types is:

• Built-in types
  • null type
  • Scalar types:
    • bool type
    • int type
    • float type
    • string type
  • array type
  • object type
  • resource type
  • never type
  • void type
  • Relative class types: self, parent, and static
• Value types
  • false
  • true
• User-defined types (generally referred to as class-types)
  • Interfaces
  • Classes
  • Enumerations
• callable type

Composite types

It is possible to combine multiple atomic types into composite types. PHP allows types to be combined in the following ways:

• Intersection of class-types (interfaces and class names).
• Union of types.

Type aliases

PHP supports two type aliases: mixed and iterable which corresponds to the union type of object|resource|array|string|float|int|bool|null and Traversable|array respectively.

Nota: PHP does not support user-defined type aliases.

Sintaxis

No hay más que un valor de tipo null, y es la constante null insensible a mayúsculas/minúsculas.

Véase también las funciones is_null() y unset().

La conversión a null

Convertir una variable a null usando (unset) $var no eliminará la variable ni destruirá su valor. Sólo retornará un valor null.

Sintaxis

Para especificar un literal de tipo boolean se emplean las constantes true o false. Ambas no son susceptibles a mayúsculas y minúsculas.

Usualmente, el resultado de un operador que devuelve un valor de tipo boolean es pasado a una estructura de control.

Conversión a booleano

Para convertir explícitamente un valor al tipo boolean, use los amoldamientos (bool) o (boolean). Sin embargo, en la mayoría de casos es innecesario el amoldamiento, ya que un valor será convertido automáticamente si un operador, función o estructura de control requiere un argumento de tipo boolean.

Véase también la Manipulación de tipos.

Cuando se realizan conversiones a boolean, los siguientes valores se consideran false:

• el boolean false mismo
• el integer 0 y -0 (cero)
• el float 0.0 y -0.0 (cero)
• el valor string vacío, y el string "0"
• un array con cero elementos
• el tipo especial NULL (incluidas variables no establecidas)
• objetos SimpleXML creados desde etiquetas vacías

Cualquier otro valor se considera como true (incluido cualquier resource y NAN).

Sintaxis

Los integer pueden especificarse mediante notación decimal (base 10), hexadecimal (base 16), octal (base 8) o binaria (base 2), opcionalmente precedidos por un signo (- o +).

Los literales de tipo integer binarios están disponibles desde PHP 5.4.0.

Para utilizar la notación octal, se antepone al número un 0 (cero). Para utilizar la notación hexadecimal, se antepone al número 0x. Para utilizar la notación binaria, se antepone al número 0b.

Formalmente, la estructura de los literales de tipo integer es:

decimal     : [1-9][0-9]*
            | 0

hexadecimal : 0[xX][0-9a-fA-F]+

octal       : 0[0-7]+

binario     : 0b[01]+

entero      : [+-]?decimal
            | [+-]?hexadecimal
            | [+-]?octal
            | [+-]?binario

El tamaño de un integer depende de la plataforma, aunque el valor usual es un valor máximo de aproximadamente dos mil millones (esto es, 32 bits con signo). Las plataformas de 64 bits normalmente tienen un valor máximo de aproximadamente 9E18, excepto en Windows antes de PHP 7, que siempre es de 32 bits. PHP no tiene soporte para el tipo integer sin signo. El tamaño de un integer se puede determinar mediante la constante PHP_INT_SIZE, y el valor máximo mediante la constante PHP_INT_MAX desde PHP 4.4.0 y PHP 5.0.5, y el valor mínimo mediante la constante PHP_INT_MIN desde PHP 7.0.0.

Desbordamiento de enteros

Si PHP encuentra un número fuera de los límites de un integer, se interpretará en su lugar como un valor de tipo float. También, una operación cuyo resultado sea un número fuera de los límites de un integer devolverá en su lugar un valor de tipo float.

No existe el operador de división de integer en PHP. 1/2 produce el float 0.5. El valor puede ser convertido a un integer redondeándolo a cero, o mediante la función round() que permite un mayor control sobre el redondeo.

Conversión a números enteros

Para convertir explícitamente un valor al tipo integer se puede emplear tanto (int) como (integer). Sin embargo, la mayoría de las veces la conversión no es necesaria, ya que un valor es convertido de forma automática cuando un operador, función o estructura de control requiera un argumento de tipo integer. Un valor también puede ser convertido al tipo integer mediante la función intval().

Si un resource es convertido a un integer, el resultado será el número de recurso único asignado al resource por PHP durante la ejecución.

Consulte también la Manipulación de tipos.

Conversión al tipo float

Para más información sobre las conversiones de string a float, véase la Conversión de cadenas a números. Para valores de otros tipos, la conversión es la misma que si el valor hubiese sido convertido primero a integer y luego a float. Véase la Conversión a al tipo integer para más información. A partir de PHP 5, se genera un aviso si se intenta convertir un object a float.

Comparación del tipo float

Como se indica en la advertencia anterior, comprobar la igualdad de valores de punto flotante es problemático debido a la forma en que se representan internamente. Sin embargo, hay maneras de hacer comparaciones de los valores de punto flotante que evitan estas limitaciones.

Para comprobar la igualdad de valores de punto flotante, se utiliza un límite superior en el error relativo debido al redondeo. Este valor se conoce como el épsilon de la máquina o unidad de redondeo, y es la menor diferencia aceptable en los cálculos.

NaN

Algunas operaciones numéricas pueden resultar en un valor representado por la constante NAN. Este resultado representa un valor no definido o no representable mediante cálculos de punto flotante. Cualquier comparación, ya sea estricta o no, de este valor con cualquier otro valor, incluido él mismo, pero excepto true, tendrá un resultado de false.

Ya que NAN representa cualquier número de diferentes valores, NAN no debería compararse con otros valores, incluido él mismo; en su lugar debería comprobarse usando la función is_nan().

Sintaxis

Un literal de tipo string se puede especificar de cuatro formas diferentes:

• entrecomillado simple
• entrecomillado doble
• sintaxis heredoc
• sintaxis nowdoc (desde PHP 5.3.0)

Mi nombre es "MiNombre". Estoy escribiendo un poco de Foo.
Ahora, estoy escribiendo un poco de Bar2.
Esto debería mostrar una 'A' mayúscula: A

Mi nombre es "$nombre". Estoy escribiendo un poco de $foo->foo.
Ahora, estoy escribiendo un poco de {$foo->bar[1]}.
Esto debería mostrar una 'A' mayúscula: \x41

Él tomó algo de jugo de manzana.
Él tomó algo de jugo hecho de .
Él tomó algo de jugo hecho de manzanas.

Él tomó algo de jugo de manzana.
Él tomó algo de jugo de naranja.
Él tomó algo de jugo púrpura.
John Smith tomó algo de jugo de manzana.
John Smith entonces dijo hola a Jane Smith.
La esposa de John Smith saludó a Robert Paulsen.
Robert Paulsen saludó a los dos .

Soy bar.
Soy bar.

string(1) "b"
bool(true)
string(1) "b"
bool(true)
string(1) "a"
bool(true)
string(1) "b"
bool(true)

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)

Funciones y operadores útiles

Los string pueden ser concatenados empleando el operador '.' (punto). Fíjese que el operador '+' (suma) no servirá para concatenar. Consulte los operadores de string para más información.

Hay una serie de funciones útiles para la manipulación de string.

Consulte la sección de funciones de string para funciones generales, y las funciones de expresiones regulares compatibles con Perl para características avanzadas de búsqueda y sustitución.

También existen funciones para string de URL, y funciones para encriptar/desencriptar string (mcrypt y mhash).

Finalmente, también existen las funciones para el tipo carácter.

Conversión a string

Un valor puede convertirse a un string empleando el molde (string) o mediante la función strval(). La conversión automática a string tiene lugar en el ámbito de una expresión donde sea necesario un string. Esto ocurre cuando se utilizan las funciones echo o print, o cuando se compara una variable con un string. Las secciones sobre Tipos y Manipulación de tipos lo aclararán. Consulte también la función settype().

El valor true del tipo boolean es convertido al string "1". El valor false del tipo boolean es convertido al string "" (el string vacío). Esto permite la conversión en ambos sentidos entre los valores de los tipos boolean y string.

Un integer o float es convertido a un string que representa textualmente el número (incluyendo la parte exponencial para los float. Los números de punto flotante pueden ser convertidos mediante la notación exponencial (4.1E+6).

Nota:

El carácter para el punto decimal se define en el localismo del script (categoría LC_NUMERIC). Consulte la función setlocale().

Los arrays siempre son convertidos al string "Array". Debido a esto, echo y print no pueden por sí mismos mostrar el contenido de un array. Para ver un único elemento individualmente, utilice una construcción como echo $arr['foo']. Vea los consejos de más abajo para mostrar el contenido completo.

Los object en PHP 4 siempre son convertidos al string "Object". Para mostrar los valores de las propiedades de un objeto para su depuración, lea los párrafos siguientes. Para obtener el nombre de la clase de un objeto, emplee la función get_class(). A partir de PHP 5, se puede emplear el método __toString cuando sea relevante.

Un resource siempre es convertido a string con la estructura "Resource id #1", donde 1 es el número de recurso asignado al resource por PHP durante la ejecución. A pesar de que no se debe depender de la estructura exacta, debido a que está sujeta a cambios, siempre será única para un recurso dado dentro del tiempo de vida de un script en ejecución (es decir, una petición web o proceso CLI), por lo que no será reutilizada. Para obtener el tipo de un resource, emplee la función get_resource_type().

null siempre es convertido a un string vacío.

Como se indicó anteriormente, la conversión directa de un array, object o resource a un string no proporciona información útil acerca del valor más allá de su tipo. Consulte las funciones print_r() y var_dump() para ver medios más efectivos de inspeccionar el contenido de estos tipos.

La mayoría de los valores de PHP pueden ser convertidos a un string para su almacenamiento permanente. Este método se denomina serialización, y es realizado mediante la función serialize(). Si el motor de PHP se construyó con soporte para WDDX, los valores de PHP también pueden ser serializacos como texto XML bien formado.

Conversión de string a números

Cuando un string es evaluado en un contexto numérico, el valor resultante y el tipo se determina como se explica a continuación.

Si el string no contiene ninguno de los caracteres '.', 'e', o 'E', y el valor numérico está entre los límites del tipo integer (tal como está definido por PHP_INT_MAX), el string será evaluado como un integer. En todos los demás casos será evaluado como un float.

El valor es dado por la parte inicial del string. Si el string empieza con un dato numérico válido, éste será el valor empleado. De lo contrario, el valor será 0 (cero). Un dato numérico válido es un signo opcional, seguido de uno o más dígitos (opcionalmente puede contener un punto decimal), seguido de un exponente opcional. El exponente es una 'e' o 'E' seguida de uno o más dígitos.

Para más información sobre esta conversión, consulte la página del manual de Unix para a strtod(3).

Para probar cualesquiera de los ejemplos de esta sección, copie y péguelos e incluya la siguiente línea para ver lo que está sucediendo:

No espere obtener el código de un carácter convirtiéndolo a un integer, como ocurre en C. Emplee las funciones ord() y chr() para convertir entre código códigos ASCII y caracteres.

Detalles del tipo string

En PHP, los string se implementan como un array de bytes y con un número entero que indica la longitud del búfer. No posee ninguna información sobre cómo traducir esos bytes a caracteres, relegando esa tarea al programador. No existe ninguna limitación sobre los valores que pueden componer un string; en concreto, está permitido colocar bytes con valor 0 (“bytes NUL”) en cualquier posición del string (aunque existen algunas funciones, citadas en este manual como “no seguras a nivel binario”, que podrían rechazar estos string para aquellas bibliotecas que ignoren los datos que siguen a un byte NUL.)

Este comportamiento del tipo string justifica que no exista un tipo de dato "byte" en PHP – los string se encargan de esto. Las funciones que no devuelven datos de texto – por ejemplo, cualquier dato leído a partir de un socket de red – devolverán valores de tipo string.

Dado que PHP no obliga a utilizar ninguna condificación en particular, uno podría preguntarse cómo se codifican los literales de tipo string. Por ejemplo, ¿es el string "á" equivalente a "\xE1" (ISO-8859-1), "\xC3\xA1" (UTF-8, forma C), "\x61\xCC\x81" (UTF-8, forma D) o cualquier otra representación posible? La respuesta es que un string será codificado en cualquiera forma en que estuviera codificado el fichero del script. Por tanto, si un script estuviera escrito en ISO-8859-1, el string se codificará en ISO-8859-1, etc. Sin embargo, esto no es aplicable si está habilitado Zend Multibyte; en ese caso, el script podría estar escrito en cualquier codificación (la cual es declarada explícitamente o es detectada) para después convertirse a una determinada codificación interna, que será entonces la codificación usada para los literales de tipo string. Tenga presente que existen algunas limitaciones sobre la codificación del script (o en la codificación interna, si Zend Multibyte estuviera habilitado); esto suele significar que dicha codificación debería ser compatible con un superconjunto de ASCII, tal como UTF-8 o ISO-8859-1. Por contra, las codificaciones dependientes del estado donde se pueden utilizar los mismos valores de byte en estados de desplazamiento iniciales y no iniciales, podrían generar problemas.

Por supuesto, para poder ser útiles, las funciones que operen con texto podrían partir de unos supuestos sobre cómo está codificado el string. Desafortunadamente, respecto a esto existen muchas variaciones en las funciones de PHP:

• Algunas funciones asumen que el string está codificado con una codificación de un único byte, por lo que no es necesario interpretar estos bytes como caracteres específicos. Este es el caso de, por ejemplo, substr(), strpos(), strlen() o strcmp(). Otra forma de entender estas funciones es pensando que operan sobre búferes de memoria, es decir, trabajan con bytes y con índices de bytes.
• A otras funciones se les proporciona la codificación del string, si bien es posible que asuman una codificación predeterminada si no se proporciona ninguna. Este es el caso de htmlentities() y la mayoría de funciones de la extensión mbstring.
• Otras utilizan el localismo en uso (véase setlocale()), pero operan byte a byte. Este es el caso de strcasecmp(), strtoupper() y ucfirst(). Esto significa que sólo se pueden usar con codificaciones de un byte, siempre y cuando la codificación coincida con la del localismo. Por ejemplo, strtoupper("á") podría devolver "Á" si el localismo está correctamente establecido y á está codificado con un único byte. Si está codificado en UTF-8, no se devolverá un resultado correcto, y el string resultante podría devolverse corrupto, en función del localismo en uso.
• Por último, las funciones podrán también asumir que se utiliza una codificación en particular, usualmente UTF-8. Este es el caso de la mayoría de las funciones de la extensión intl y de la extensión PCRE (en este último caso, sólo cuando se utiliza el modificador u). Debido a su propósito especial, la función utf8_decode() asume una codificación UTF-8, mientras que la función utf8_encode() asume una codificación ISO-8859-1.

En resumen, para escribir programas de forma correcta usando Unicode hay que evitar cuidadosamente las funciones que puedan fallar y que muy probablemente corrompan los datos, y utilizar en su lugar las funciones que se comporten de forma correcta, generalmente las de las extensiones intl y mbstring. Sin embargo, el uso de funciones que pueden manejar codificaciones Unicode es sólo el principio. No importa qué funciones incorpore el lenguaje; es primordial conocer la especificación Unicode. Por ejemplo, un programa que asuma que sólo hay mayúsculas y minúsculas estará haciendo una suposición errónea.

Strings used in numeric contexts

When a string needs to be evaluated as number (e.g. arithmetic operations, int type declaration, etc.) the following steps are taken to determine the outcome:

1. If the string is numeric, resolve to an int if the string is an integer numeric string and fits into the limits of the int type limits (as defined by PHP_INT_MAX), otherwise resolve to a float.
2. If the context allows leading numeric strings and the string is one, resolve to an int if the leading part of the string is an integer numeric string and fits into the limits of the int type limits (as defined by PHP_INT_MAX), otherwise resolve to a float. Additionally an error of level E_WARNING is raised.
3. The string is not numeric, throw a TypeError.

Behavior prior to PHP 8.0.0

Prior to PHP 8.0.0, a string was considered numeric only if it had leading whitespaces, if it had trailing whitespaces then the string was considered to be leading numeric.

Prior to PHP 8.0.0, when a string was used in a numeric context it would perform the same steps as above with the following differences:

• The usage of a leading numeric string would raise an E_NOTICE instead of an E_WARNING.
• If the string is not numeric, an E_WARNING was raised and the value 0 would be returned.

Sintaxis

    array(
    clave  => valor,
    clave2 => valor2,
    clave3 => 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"
}

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

    $arr[clave] = valor;
    $arr[] = valor;
    // clave puede ser un integer o un string
    // valor puede ser cualquier valor de cualquier tipo

Funciones útiles

Hay un buen número de funciones útiles para trabajar con arrays. Véase la sección funciones de array.

Nota:

La función unset() permite remover claves de un array. Tenga en cuenta que el array no es re-indexado. Si se desea un verdadero comportamiento "eliminar y desplazar", el array puede ser re-indexado usando la función array_values().

<?php
$a = array(1 => 'uno', 2 => 'dos', 3 => 'tres');
unset($a[2]);
/* producirá un array que se ha definido como
$a = array(1 => 'uno', 3 => 'tres');
y NO
$a = array(1 => 'uno', 2 =>'tres');
*/

$b = array_values($a);
// Ahora $b es array(0 => 'uno', 1 =>'tres')
?>

La estructura de control foreach existe específicamente para arrays. Ésta provee una manera fácil de recorrer un array.

Recomendaciones sobre arrays y cosas a evitar

Conversión a array

Para cualquiera de los tipos integer, float, string, boolean y resource, convertir un valor a un array resulta en un array con un solo elemento, con índice 0, y el valor del escalar que fue convertido. En otras palabras, (array)$scalarValue es exactamente lo mismo que array($scalarValue).

Si convierte un object a un array, el resultado es un array cuyos elementos son las propiedades del object. Las claves son los nombres de las variables miembro, con algunas excepciones notables: las variables privadas tienen el nombre de la clase al comienzo del nombre de la variable; las variables protegidas tienen un caracter '*' al comienzo del nombre de la variable. Estos valores adicionados al inicio tienen bytes NUL a los lados. Las propiedades tipificadas no inicializadas se descartan silenciosamente.

En el ejemplo anterior parecerá que se tienen dos claves llamadas 'AA', aunque en realidad una de ellas se llama '\0A\0A'.

Si convierte un valor null a array, obtiene un array vacío.

Comparación

Es posible comparar arrays con la función array_diff() y mediante operadores de arrays.

Array unpacking

An array prefixed by ... will be expanded in place during array definition. Only arrays and objects which implement Traversable can be expanded. Array unpacking with ... is available as of PHP 7.4.0.

It's possible to expand multiple times, and add normal elements before or after the ... operator:

Unpacking an array with the ... operator follows the semantics of the array_merge() function. That is, later string keys overwrite earlier ones and integer keys are renumbered:

Nota:

Keys that are neither integers nor strings throw a TypeError. Such keys can only be generated by a Traversable object.

Nota:

Prior to PHP 8.1, unpacking an array which has a string key is not supported:

<?php

$arr1 = [1, 2, 3];
$arr2 = ['a' => 4];
$arr3 = [...$arr1, ...$arr2];
// Fatal error: Uncaught Error: Cannot unpack array with string keys in example.php:5

$arr4 = [1, 2, 3];
$arr5 = [4, 5];
$arr6 = [...$arr4, ...$arr5]; // works. [1, 2, 3, 4, 5]
?>

Ejemplos

El tipo array en PHP es bastante versátil. Aquí hay algunos ejempos: