Appel de PHP par Lighttpd

Pour configurer Lighttpd afin qu'il se connecte à PHP et appelle le processus FastCGI, vous devez éditez le fichier lighttpd.conf. Une connexion par sockets est la solution préférée pour les systèmes locaux.

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 directive bin-path permet à lighttpd d'appeler le processus FastCGI dynamiquement. PHP appellera les fils suivant la variable d'environnement PHP_FCGI_CHILDREN. La directive bin-environment définit l'environnement pour les processus appelés. PHP terminera un processus fils lorsque le nombre de requêtes spécifié par PHP_FCGI_MAX_REQUESTS a été atteint. Les directives min-procs et max-procs peuvent généralement être ignorées avec PHP. PHP gère ces propres fils et caches opcode comme APC qui partage uniquement les fils gérés par PHP. Si min-procs est défini à quelque chose de supérieur à 1, le nombre total de réponses PHP sera multiplié par PHP_FCGI_CHILDREN (2 min-procs * 16 fils, donne 32 réponses).

Appel avec spawn-fcgi

Lighttpd fournit un programme appelé spawn-fcgi afin de rendre plus facile les appels des processus FastCGI.

Appel de php-cgi

Il est possible d'appeler des processus sans spawn-fcgi, avec un minimum de configuration. La variable d'environnement PHP_FCGI_CHILDREN contrôle le nombre de fils que PHP appelle pour gérer les demandes. La variable d'environnement PHP_FCGI_MAX_REQUESTS détermine la durée de vie, en nombre de requêtes, de chaque fils. Voici un script bash simple qui permet d'aider les appels aux répondeurs PHP.

#!/bin/sh

# Localisation du binaire php-cgi
PHP=/usr/local/bin/php-cgi

# Localisation  du fichier PID
PHP_PID=/tmp/php.pid

# Liaison à une adresse
#FCGI_BIND_ADDRESS=10.0.1.1:10000
# Liaison à un socket du domaine
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"

Connexion à des instances FCGI distantes

Les instances FastCGI peuvent être appelées sur plusieurs machines distantes afin de répartir les applications.

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

Tests

Si vous avez compilé PHP comme programme CGI, vous pouvez tester votre produit en tapant : make test. C'est toujours une bonne chose de tester le résultat d'une compilation. Cela vous permet de repérer des problèmes entre PHP et votre plate-forme, plutôt que d'attendre qu'ils surviennent.

Utiliser les variables prédéfinies

Certaines variables d'environnement fournies par les serveurs Web ne sont pas disponibles dans les » spécifications CGI/1.1 actuelles. Seules les variables suivantes sont définies, et les autres doivent être considérées comme spécifiques aux serveurs Web : 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 et SERVER_SOFTWARE.

Utilisation des paquets binaires

Cette méthode est la méthode recommandée pour installer PHP sur OpenBSD. C'est aussi la méthode la plus simple. Le paquet core a été séparé des modules et chacun d'entre eux peut être installé et supprimé indépendamment des autres. Les fichiers dont vous avez besoin sont sur le CD OpenBSD ou sur le site FTP.

Le paquet principal que vous devez installer est php, qui contient le moteur de base (en plus de fpm, gettext et iconv) et pourrait etre disponible sous plusieurs versions au choix. Puis, jetez un oeil aux paquets de module, comme php-mysqli ou php-imap. Vous devez utiliser la commande phpxs pour activer et désactiver ces modules dans votre php.ini.

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

Follow the instructions shown with each package!

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

Lisez la page de manuel Unix » packages(7) pour plus de détails sur les packages binaires d'OpenBSD.

Utilisation des ports

Vous pouvez aussi compiler PHP en utilisant » l'arbre des ports. Cette méthode est recommandée aux utilisateurs expérimentés de OpenBSD. Le port PHP est divisé en core et extensions. Le dossier extensions génère les sous paquets de tous les modules PHP. Si vous souhaitez ne pas créer ces modules, vous pouvez utiliser la commande en ligne no_* FLAVOR. Par exemple, pour ne pas compiler le module imap, utilisez FLAVOR avec la valeur no_imap.

Problèmes courants

• Apache et Nginx ne sont plus le serveur par défaut sur OpenBSD, mais ils peuvent être facilement trouvés dans les ports et les packages. Le nouveau serveur par défaut est également appelé 'httpd'.
• L'installation par défaut d'Apache fonctionne dans un » contexte chroot(2), qui va limiter l'accès des scripts PHP au dossier /var/www. Vous devez donc créer un dossier /var/www/tmp pour que les sessions PHP soient stockées, ou bien utiliser une autre solution de sauvegarde. De plus, les sockets de bases de données doivent être placés dans ce dossier, ou bien utiliser l'interface localhost. Si vous utilisez des fonctions de réseau avec des fichiers comme /etc, par exemple /etc/resolv.conf, et /etc/services, vous devrez les rendre accessibles aussi dans /var/www/etc. Le paquet OpenBSD PEAR installe automatiquement les bons dossiers.
• Le paquet OpenBSD pour l'extension » gd requiert Xorg. A moins d'être déjà inclue après l'installation en ajoutant le jeu de fichiers xbase.tgz, cela peut être ajouté a posteriori (voir » OpenBSD FAQ#4).

Logiciels nécessaires

L'installation Solaris oublie généralement les compilateurs C, et leurs utilitaires. Lisez cette FAQ pour savoir pourquoi est-ce que les versions GNU de certains de ces outils sont nécessaires.

Pour décompresser la distribution PHP, vous avez besoin de

• tar
• gzip ou
• bzip2

Pour compiler PHP, vous avez besoin de

• gcc (recommandé, les autres compilateurs C peuvent aussi fonctionner)
• make
• GNU sed

Pour construire les extensions additionnelles ou modifier le code de PHP, vous pouvez également avoir besoin de

• re2c
• bison
• m4
• autoconf
• automake

Utilisation des paquets

Vous pouvez simplifier l'installation Solaris en utilisant pkgadd pour installer la plupart des composants. Le système de paquets des images (IPS) pour Solaris 11 Express contient également les composants nécessaires pour l'installation utilisant la commande pkg.

Utilisation de APT

Tout d'abord, veuillez noter que d'autres paquets peuvent être souhaitables, comme libapache-mod-php pour l'intégration avec Apache 2, et php-pear pour PEAR.

Ensuite, avant d'installer un paquet, il est sage de s'assurer que la liste des paquets est à jour. D'habitude, on le fait en utilisant la commande apt update.

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

APT installera et activera automatiquement le module PHP pour Apache 2, ainsi que toutes ses dépendances. Apache devra être relancé pour que les changements soient effectifs. Par exemple :

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

Un meilleur contrôle de la configuration

Dans l'exemple précédent, PHP a été installé avec juste les composants principaux. Il y a fort à parier que des modules supplémentaires soient nécessaires, tels que MySQL, cURL, GD, etc. Ils peuvent aussi être installés via la commande apt.

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

Ces exemples montreront de nombreux paquets, donc beaucoup spécifiques à PHP, comme php-cgi, php-cli et php-dev. Déterminez ceux qui sont nécessaires et installez les comme n'importe quel autre en utilisant apt ou aptitude. Et vu que Debian effectue une vérification des dépendances, on vous avertira de ces dernières, comme pour installer MySQL et cURL :

# apt install php-mysql php-curl

APT ajoutera automatiquement les bonnes lignes aux fichiers connexes à php.ini, comme /etc/php/7.4/php.ini, /etc/php/7.4/conf.d/*.ini, etc. et selon l'extension, il ajoutera des entrées semblables à extension=foo.so. De plus, redémarrer le serveur web (Apache, par exemple) est nécessaire pour que ces changements soient effectifs.

Problèmes courants

• Si les scripts PHP ne sont pas interprétés par le serveur web, il est probable que PHP n'ait pas été ajouté aux fichier de configuration du serveur web, c'est-à-dire, sous Debian, /etc/apache2/apache2.conf ou équivalent. Consultez le manuel Debian pour davantage de détails.
• Si une extension a apparemment été installée mais que ses fonctions ne sont pas définies, assurez vous que les lignes adéquates ont été insérées dans les fichiers .ini et/ou que le serveur web a été redémarré après l'installation.
• Il y a deux commandes de base pour installer des paquets sous Debian (et d'autres variantes de Linux) : apt et aptitude. Expliquer les différences subtiles entre les deux sort du cadre de ce manuel.

Outils d'installation de PHP

» XAMPP, WampServer et BitNami installera des applications PHP pour une utilisation avec Apache sous Windows.

Installer et configurer Nginx sur Windows nécessite un peu plus de configuration. Voir la » documentation d'Nginx pour obtenir une aide d'installation supplémentaire.

OpCache

Il est fortement recommandé d'activer OpCache. Cette extension est incluse avec PHP pour Windows. Il compile et optimise les scripts PHP et les met en cache mémoire afin qu'ils ne soient pas compilés chaque fois que la page est chargée.

Définir le php.ini à :

opcache.enable=On
opcache.enable_cli=On

WinCache

Il est recommandé d'utiliser WinCache lors de l'utilisation d'ISS, surtout si dans un environnement d'hébergement Web partagé ou en utilisant le stockage de fichiers en réseau (NAS). Il est à noter que WinCache n'est plus supporté à partir de PHP 8.0.0. Toutes les applications PHP bénéficient automatiquement de la fonctionnalité de cache de fichiers de WinCache. Les opérations du système de fichiers sont mises en cache en mémoire. WinCache peut également mettre en cache mémoire des objets de l'utilisateur et les partager entre les processus php.exe ou php-cgi.exe (partager des objets entre les requêtes). De nombreuses applications Web majeures ont un plugin ou une extension ou une option de configuration pour utiliser le cache d'objet de l'utilisateur de WinCache. Si vous avez besoin de hautes performances, vous devriez utiliser le cache d'objets dans vos applications. Voir : » http://pecl.php.net/package/WinCache pour télécharger WinCache DLL (ou tgz) vers votre dossier d'extension PHP (extensions_dir dans votre php.ini). Définir le php.ini à :

extension=php_wincache.dll
wincache.fcenabled=1
wincache.ocenabled=1 ; removed as of wincache 2.0.0.0 

Configuration IIS

Dans la console d'administration de IIS, installer le module FastCGI et ajouter le mappage du gestionnaire pour `.php` vers le chemin d'accès à PHP-CGI.exe (pas PHP.exe)

Vous pouvez utiliser l'outil de ligne de commande APPCMD pour scripter la configuration IIS.

Base de données

Vous aurez probablement besoin d'un serveur de base de données. Les bases de données populaires fournissent des extensions PHP pour les utiliser. Si votre site Web n'a pas beaucoup de trafic, vous pouvez exécuter votre serveur de base de données sur le même serveur que votre serveur Web. De nombreux serveurs de base de données populaires s'exécutent sous Windows.

PHP inclut les extensions mysqli et PDO_MYSQL.

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

Choix du serveur Web

@echo off

REM download .ZIP file of PHP build from http://windows.php.net/downloads/

REM path to directory you decompressed PHP .ZIP file into (no trailing \)
set phppath=c:\php


REM Clear current PHP handlers
%windir%\system32\inetsrv\appcmd clear config /section:system.webServer/fastCGI
REM The following command will generate an error message if PHP is not installed. This can be ignored.
%windir%\system32\inetsrv\appcmd set config /section:system.webServer/handlers /-[name='PHP_via_FastCGI']

REM Set up the PHP handler
%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 FastCGI Variables
%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']"

Choix de la version

Téléchargez la version de production de PHP pour Windows depuis » http://windows.php.net/download/. Toutes les versions sont optimisées (PGO), et les versions QA et GA sont minutieusement testées.

Il y a 4 types de versions de PHP :

• Thread-Safe(TS) - utilisé pour des serveurs web n'ayant qu'un seul processus, comme Apache avec mod_php

• Non-Thread-Safe(NTS) - utilisé pour IIS et les autres serveurs web FastCGI (Apache avec mod_fastcgi) et c'est la version recommandée pour les scripts en ligne de commande

• x86 - pour système 32-bits.

• x64 - pour système 64-bits.

Installing as an Apache handler

To load the PHP module for Apache 2.x, the following lines in the Apache httpd.conf configuration file must be inserted:

# before PHP 8.0.0 the name of the module was php7_module
LoadModule php_module "c:/php/php8apache2_4.dll"
<FilesMatch \.php$>
    SetHandler application/x-httpd-php
</FilesMatch>
# configure the path to php.ini
PHPIniDir "C:/php"

Note: The actual path to PHP must be substituted instead of C:/php/ in the above examples. Make sure that the file referenced in the LoadModule directive is at the specified location. Use php7apache2_4.dll for PHP 7, or php8apache2_4.dll for PHP 8.

Running PHP as CGI

It is strongly recommended to consult the » Apache CGI documentation for a more complete understanding of running CGI on Apache.

To run PHP as CGI, the php-cgi files will need to be placed in a directory designated as a CGI directory using the ScriptAlias directive.

A #! line will need to be placed in the PHP files, which point to the location of the PHP binary:

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

Running PHP under FastCGI

Running PHP under FastCGI has a number of advantages over running it as a CGI. Setting it up this way is fairly straightforward:

Obtain mod_fcgid from » https://www.apachelounge.com. Win32 binaries are available for download from that site. Install the module according to the instructions that will come with it.

Configure your web server as shown below, taking care to adjust any paths to reflect how you have installed things on your particular system:

LoadModule fcgid_module modules/mod_fcgid.so
# Where is your php.ini file?
FcgidInitialEnv PHPRC        "c:/php"
<FilesMatch \.php$>
    SetHandler fcgid-script
</FilesMatch>
FcgidWrapper "c:/php/php-cgi.exe" .php

Vérifier les autorisations du répertoire Temp

WinCache

WinCache est activé par défaut sur Azure App Services et il est recommandé de le laisser activé. Si vous installez votre propre verison de PHP, vous devez activer WinCache.

Build personnalisée de PHP

Vous pouvez télécharger votre propre version de PHP dans votre D:\Home (C:\ n'est pas accessible en écriture). Ensuite, dans le portail Azure, définissez SCRIPT_PROCESSOR pour .php sur le chemin d'accès absolu au fichier php-cgi.exe dans votre build personnalisée.

Compiler depuis les sources

Pour activer FPM dans votre construction de PHP vous devez ajouter la ligne --enable-fpm à votre ligne de configuration.

Il existe de multiples options de configuration pour FPM (toutes optionnelles):

• --with-fpm-user - l'utilisateur FPM (defaut - nobody).

• --with-fpm-group - le groupe FPM (defaut - nobody).

• --with-fpm-systemd - Active l'intégration de systemd (par défaut - no).

• --with-fpm-acl - Utiliser POSIX Access Control Lists (par défaut - no).

• --with-fpm-apparmor - Active l'intégration d'AppArmor (par défaut - no).

• --with-fpm-selinux - Active l'intégration SELinux (par défaut - no).

Historique

Liste des directives globales de php-fpm.conf

pid chaîne de caractères

Chemin vers le fichier PID. Par défaut : none.

error_log chaîne de caractères

Chemin vers le fichier de journal. Par défaut: #INSTALL_PREFIX#/log/php-fpm.log. Si défini à "syslog", le journal est envoyé vers syslogd au lieu d'être écrit dans un fichier local.

log_level chaîne de caractères

Niveau de journalisation d'erreur. Valeurs possibles : alert, error, warning, notice, debug. Par défaut : notice.

log_limit entier

Limite d'historique pour les lignes enregistrés qui permet des messages d'événements plus long que 1024 caractères sans s'emballer. Valeur par default : 1024 Disponible à partir de PHP 7.3.0.

log_buffering booléen

Historique expérimental sans tampon. Valeur par default : yes. Disponible à partir de PHP 7.3.0.

syslog.facility chaîne de caractères

Utilisé pour spécifier quel type de programme écrit le message. Valeur par défaut : daemon.

syslog.ident chaîne de caractères

Ajoute au début de chaque message. Si vous avez de multiples instances FPM s'exécutant sur le même serveur, vous pouvez changer la valeur par défaut afin qu'elle convienne à vos besoins. Valeur par défaut : php-fpm.

emergency_restart_threshold entier

Si ce nombre de processus fils terminent avec un SIGSEGV ou SIGBUS dans l'intervalle de temps précisé dans emergency_restart_interval, alors FPM redémarrera. Une valeur de 0 signifie 'Off'. Valeur par défaut : 0 (Off).

emergency_restart_interval mixed

Intervalle de temps utilisé par emergency_restart_interval pour determiner lorsqu'un redémarrage doux doit être lancé. Ceci peut être utile pour contourner des corruptions accidentelles dans la mémoire partagée d'un accelérateur. Unités disponibles : s(econdes), m(inutes), h(eures), ou d(ays). Unité par défaut : secondes. Valeur par défaut : 0 (Off).

process_control_timeout mixed

Temps limite qu'attendront les processus fils pour réagir aux signaux du père. Unités disponibles : s(econdes), m(inutes), h(eures), ou d(ays) Unité par défaut : secondes. Valeur par défaut : 0.

process.max entier

Le nombre maximum de processus que FPM va forker. Ceci a été conçu pour contrôler le nombre global de processus lors de l'utilisation d'un gestionnaire de processus dynamique avec beaucoup de pools. À utiliser avec attention. Valeur par défaut : 0.

process.priority entier

Défini la priorité nice(2) à appliquer au processus principal (uniquement si défini) La valeur peut varier de -19 (priorité haute) à 20 (priorité basse). Valeur par défaut : non défini.

daemonize booléen

Envoie FPM en arrière-plan. Mettez 'no' pour garder FPM au premier plan lors du débogage. Valeur par défaut : yes.

rlimit_files entier

Défini la rlimit pour les descripteurs de fichiers ouverts pour le processus principal. Valeur par défaut : valeur définie par le système.

rlimit_core entier

Défini la taille maximale de rlimit pour le processus principal. Valeur par défaut : 0.

events.mechanism chaîne de caractères

Spécifie le gestionnaire d’événement que FPM va utiliser. Sont disponibles : select, pool, epoll, kqueue (*BSD), port (Solaris). Valeur par défaut : non défini (détection automatique).

systemd_interval entier

Quand FPM est construit avec le support de systemd, spécifie l'intervalle en seconde, entre les notifications de rapport de santé envoyé à systemd. Définir à 0 pour désactiver. Valeur par défaut : 10.

Liste des directives de pool

Avec FPM vous pouvez exécuter plusieurs pools de processus avec des paramètres différents. Voici les paramètres qui peuvent être ajustés par pool.

listen chaîne de caractères

L'adresse pour accepter des requêtes FastCGI. Syntaxes valides : 'ip.add.re.ss:port', 'port', '/path/to/unix/socket'. Cette option est obligatoire pour chaque pool.

listen.backlog entier

Affecte listen(2) backlog. Une valeur de -1 signifie le maximum sur les systèmes BSD. Valeur par défaut : -1 (FreeBSD ou OpenBSD) ou 511 (Linux et autres plateformes).

listen.allowed_clients chaîne de caractères

Liste des adresses IPv4 ou IPv6 des clients FastCGI autorisés à se connecter. C'est équivalent à la variable d'environnement FCGI_WEB_SERVER_ADDRS dans le système FastCGI original de PHP (5.2.2+). N'a de sens qu'avec un socket tcp en écoute. Chaque adresse doit être séparée par une virgule. Si cette valeur n'est pas précisée, les connexions seront acceptées depuis toute adresse ip. Valeur par défaut: non définie (toute adresse IP acceptée).

listen.owner chaîne de caractères

Affecte les permissions pour le socket Unix si utilisé. Sous Linux, les permissions read/write doivent être affectées pour autoriser des connexions depuis un serveur web. Beaucoup de systèmes dérivés BSD autorisent les connexions quelles que soient les permissions. Valeurs par défaut : user et group sont ceux de l'utilisateur courant, le mode est 0660.

listen.group chaîne de caractères

Voyez listen.owner.

listen.mode chaîne de caractères

Voyez listen.owner.

listen.acl_users chaîne de caractères

Quand les listes de contrôle d'accès POSIX sont supportées, vous pouvez les définir en utilisant cette option. Quand défini, listen.owner et listen.group sont ignorés. La valeur est une liste de noms d'utilisateurs séparés par des virgules.

listen.acl_groups chaîne de caractères

Voir listen.acl_users. La valeur est une liste de noms de groupes séparés par des virgules.

user chaîne de caractères

Utilisateur Unix des processus FPM. Cette option est obligatoire.

group chaîne de caractères

Groupe Unix des processus FPM. Si non précisé, le groupe de l'utilisateur est utilisé.

pm chaîne de caractères

Choisi comment le gestionnaire de processus va contrôler le nombre de processus fils. Valeurs possibles : static, ondemand, dynamic. Option obligatoire.

static - nombre de processus fils fixés (pm.max_children).

ondemand - le processus se réactive à la demande (lorsque demandé, c'est l'opposé de dynamique où pm.start_servers sont démarrés lorsque le service démarre).

dynamic - nombre de processus fils dynamiques basé sur les directives suivantes: pm.max_children, pm.start_servers, pm.min_spare_servers, pm.max_spare_servers.

pm.max_children entier

Nombre de processus fils à créer lorsque pm est réglé sur static. Nombre maximum de processus fils à créer lorsque pm est réglé sur dynamic. Option obligatoire.

Cette option affecte la limite du nombre de requêtes simultanées qui seront servies. Equivalent à ApacheMaxClients avec mpm_prefork et à PHP_FCGI_CHILDREN dans l'implémentation originale de FastCGI de PHP.

pm.start_servers entier

Nombre de processus fils à créer au démarrage. Utilisé seulement si pm est réglé sur dynamic. Valeur par défaut : min_spare_servers + (max_spare_servers - min_spare_servers) / 2.

pm.min_spare_servers entier

Nombre minimum de processus au repos (idle) voulus. Utilisé seulement si pm est réglé sur dynamic. Obligatoire dans ce cas.

pm.max_spare_servers entier

Nombre maximum de processus au repos (idle) voulus. Utilisé seulement si pm est réglé sur dynamic. Obligatoire dans ce cas.

pm.max_spawn_rate int

Nombre maximum de taux de génération de processus enfants simultanés. Utilisé seulement si pm est défini à dynamic.

pm.process_idle_timeout mixed

Nombre de secondes après lesquelles un processus d'inactif sera tué. Utilisé uniquelent quand pm est défini à ondemand. Unité disponible : s (secondes)(par défaut), m (minutes), h (heure), ou d (jourd). Valeur par défaut : 10s.

pm.max_requests entier

Nombre de requête que chaque processus fils devrait exécuter avant de renaitre. Ceci peut être utile pour contourner des fuites mémoires dans des librairies tierces. Pour un traitement sans fin des requêtes, précisez '0'. Equivalent à PHP_FCGI_MAX_REQUESTS. Par défaut : 0.

pm.status_listen string

L'adresse sur laquelle accepter la demande de statut FastCGI. Cela crée un nouveau pool invisible qui peut traiter les requêtes indépendamment. Ceci est utile si le pool principal est occupé par des requêtes de longue durée car il est toujours possible d'obtenir le statut FPM status page tant qu'elles ne sont pas terminées. La syntaxe est la même que pour la directive listen. Valeur par défaut : none.

pm.status_path chaîne de caractères

L'URI vers la page de statut de FPM. Cette valeur doit commencer par une barre oblique (/). Si cette valeur n'est pas définie, aucun URI ne sera reconnu en tant qu'une page d'état. Valeur par défaut : none.

ping.path chaîne de caractères

L'URI de ping pour appeler la page de monitoring de FPM. Si aucune valeur n'est précisée, aucune page de ping ne sera disponible. Ceci pourrait être utilisé pour tester depuis l'extérieur si FPM est toujours disponible et prêt à répondre. Notez que la valeur doit commencer par un slash (/).

ping.response chaîne de caractères

Cette directive est utile pour personnaliser la réponse à une requête de ping. La réponse est formatée comme text/plain avec un code de réponse de 200. Valeur par défaut : pong.

process.priority entier

Spécifiez la priorité nice(2) à appliquer au processus de travail (uniquement s'il est défini). La valeur peut varier de -19 (priorité la plus élevée) à 20 (priorité la plus basse). Valeur par défaut: non définie.

process.dumpable booléen

Défini l'indicateur de processus dumpable (PR_SET_DUMPABLE prctl) même si l'utilisateur ou le groupe de processus est différent de l'utilisateur du processus maître. Il permet de créer un core dump du processus et ptrace le processus pour l'utilisateur de pool. Valeur par défaut : no. Depuis PHP 7.0.29, 7.1.17 et 7.2.5.

prefix chaîne de caractères

Spécifier le préfixe pour l'évaluation du chemin

request_terminate_timeout_track_finished bool

Le timeout défini par request_terminate_timeout n'est pas engagé après un fastcgi_finish_request ou lorsque l'application s'est terminée et que les fonctions internes d'arrêt sont appelées. Cette directive permet d'appliquer la limite de temps sans condition. Valeur par défaut : no. À partir de PHP 7.3.0.

request_terminate_timeout mixed

Le timeout pour servir une requête après lequel le processus concerné sera tué. Cette option devrait être utilisée lorsque l'option 'max_execution_time' n'arrête pas l'exécution du script pour une raison quelconque. Une valeur de '0' signifie 'Off'. Unités disponibles : s(econdes)(défaut), m(inutes), h(eures), ou d(ays). Par défaut : 0.

request_slowlog_timeout mixed

Le timeout pour servir une requête dans laquelle la backtrace PHP sera vidée dans le fichier 'slowlog'. Une valeur de '0' signifie 'Off'. Unités disponibles : s(econdes)(défaut), m(inutes), h(eures), ou d(ays). Par défaut : 0.

request_slowlog_trace_depth int

Le niveau de profondeur de la trace de la pile de log slowlog. Valeur par défaut : 20. À partir de PHP 7.2.0.

slowlog chaîne de caractères

Le journal pour les requêtes lentes, par défaut: #INSTALL_PREFIX#/log/php-fpm.log.slow.

rlimit_files entier

Affecte la rlimit pour les descripteurs de fichiers ouverts des processus enfants de ce pool. Valeur par défaut : valeur du système.

rlimit_core entier

Affecte la taille maximale de rlimit des processus enfants de ce pool. Valeurs possibles : 'unlimited' ou un entier plus grand ou égal à 0. Valeur par défaut : valeur définie par le système.

chroot chaîne de caractères

Chroot vers ce dossier au démarrage. Cette valeur doit être un chemin absolu. Si cette valeur n'est pas définie, chroot n'est pas utilisé.

chdir chaîne de caractères

Chdir vers ce dossier au démarrage. Cette valeur doit être un chemin absolu. Valeur par défaut : dossier courant ou / si chroot.

catch_workers_output booléen

Redirige stdout et stderr vers le journal d'erreur principal. Si non précisé, stdout et stderr seront redirigés vers /dev/null selon les specifications FastCGI. Valeur par défaut: no.

decorate_workers_output booléen

Active la décoration de sortie pour les travailleurs de sortie quand catch_workers_output est activé. Valeur par défaut : yes. Disponible à partir de PHP 7.3.0.

clear_env booléen

Nettoie l’environnent des agents FPM. Prévient que des variables d’environnement arbitraire puissent atteindre les processus FPM par le nettoyage de l'environnement de ces agents avant que les variables d’environnement spécifié dans la configuration du pool ne soient ajoutées.

security.limit_extensions chaîne de caractères

Limite les extensions que le script principal FPM va être autorisé à analyser. Ceci peut prévenir les erreurs de configuration coté serveur. Vous pouvez limiter FPM à exécuter seulement les extensions .php pour prévenir que des utilisateurs malicieux utilisent d'autres extensions pour exécuter du code. Valeur par défaut : .php .phar

apparmor_hat string

Si AppArmor est activé, permet de changer un hat (chapeau). Valeur par défaut : non défini

access.log chaîne de caractères

Le fichier journal d'accès. Valeur par défaut : non définie

access.format chaîne de caractères

Le format du journal d'accès. Valeur par défaut : "%R - %u %t \"%m %r\" %s":

Options valide

Placeholder	Description
%C	%CPU
%d	durée µ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	la "colle" entre %q et %r
%r	requête URI
%R	adresse IP remote
%s	statut
%T	time
%t	time
%u	remote user

Il est possible de passer des variables d'environnement additionnelles et mettre à jour les paramètres de PHP d'un pool. Pour ce faire, vous devez ajouter les options suivantes au fichier de configuration de la file d'attente.

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

Les paramètres définis avec php_admin_value et php_admin_flag ne peuvent être surchargés via ini_set().

Les paramètres de PHP peuvent être définis dans le serveur 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";

Note: Les pools ne sont pas un mécanisme de sécurité, car elles ne fournissent pas une séparation totale ; par exemple toutes les pools utiliserait une seule instance OPcache.

Où trouver une extension ?

Les extensions PHP sont généralement appelées php_*.dll (où les astérisques représentent le nom de l'extension) et elles sont rangées dans le dossier PHP\ext.

PHP est livré avec les extensions qui sont les plus utiles à la majorité des utilisateurs. Elles sont appelées des extensions intégrées, ou bundled.

Cependant, si les extensions intégrées ne fournissent pas la fonctionnalité nécessaire, une extension qui le fait peut être trouvée dans » PECL. Le PHP Extension Community Library (PECL, aussi dit Bibliothèque d'Extensions Communautaires de PHP) est un dépôt pour les extensions PHP, fournissant un répertoire de toutes les extensions connues et des facilités d'hébergement pour le téléchargement et le développement d'extensions PHP.

Si une extension a été développée pour un usage particulier, elle peut être hébergée sur PECL afin que d'autres personnes ayant les mêmes besoins puissent en bénéficier. Un effet secondaire intéressant est que c'est une bonne occasion de recevoir des commentaires, (avec un peu de chance) des remerciements, des rapports de bogues et même des correctifs. Avant de soumettre une extension pour hébergement sur PECL, merci de lire » PECL submit.

Quelles extensions télécharger ?

Il existe souvent plusieurs versions de chaque DLL :

• Différents numéros de versions (au moins, les deux premiers chiffres doivent être les mêmes)
• Différentes configurations de sécurité de threads
• Différentes architectures de processeurs (x86, x64...)
• Différentes configurations de débogage
• etc.

Il est recommandé de choisir les extensions pour qu'elles soient adaptées à la machine serveur sur laquelle PHP est utilisé. Le script suivant va afficher toutes les configurations PHP :

Ou bien, en ligne de commande :

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

Charger une extension

Le moyen le plus courant pour charger une extension PHP est de l'inclure dans le fichier de configuration php.ini. Il est à noter que de nombreuses extensions sont déjà présentes dans le fichier php.ini et qu'il suffit simplement de supprimer le point-virgule pour les activer.

À partir de PHP 7.2.0, le nom de l'extension peut être utilisé à la place du nom de l'extension. Comme il est indépendant de l'os et plus facile, en particulier pour les nouveaux arrivants, il devient la manière recommandée de spécifier des extensions à charger. Les noms de fichiers restent pris en charge pour la compatibilité avec les versions antérieures.

;extension=php_extname.dll

extension=php_extname.dll

; À partir de PHP 7.2, favoriser :
extension=extname
zend_extension=another_extension

Cependant, certains serveurs Web sont déroutants, car ils n'utilisent pas le fichier php.ini rangé avec l'exécutable PHP. Pour en savoir plus sur le véritable php.ini utilisé, il est possible de rechercher son emplacement à l'aide de phpinfo():

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

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

Après activation d'une extension, sauvegardez le fichier php.ini, et relancez le serveur Web, puis vérifiez à nouveau le fichier phpinfo(). La nouvelle extension devrait y avoir sa section.

Résolution de problèmes

Si l'extension n'apparaît pas dans phpinfo(), il convient de vérifier les logs pour savoir d'où vient le problème.

Si PHP est utilisé en ligne de commande (CLI), l'erreur de chargement de l'extension devrait être lisible directement sur l'écran.

Si PHP est utilisé sur un serveur Web, la position et le format des logs varient grandement d'un serveur à l'autre. Lire la documentation du serveur Web pour savoir où ils sont : PHP n'a aucun control sur cet emplacement.

Les problèmes les plus courants sont la localisation du fichier DLL et les DLLs dont il dépend, la valeur de la directive "extension_dir" dans le php.ini et les incohérences de compilations.

Si le problème est une incohérence de compilation, la DLL téléchargée n'est probablement pas la bonne. Essayez d'en télécharger une nouvelle, avec les bonnes configurations du serveur. phpinfo() sera fortement utile.

Lire un répertoire

Il est possible de configurer PHP pour lire les fichiers .ini présent dans un dossier. après la lecture de php.ini. Cela est réglé lors de la compilation avec l'argument --with-config-file-scan-dir. Le dossier à lire peut être modifié lors de l'exécution par la définition de la variable d'environnement PHP_INI_SCAN_DIR.

Il est possible de lire plusieurs dossiers en les séparant avec un séparateur de chemin spécifique à la plateforme (; pour Windows, NetWare et RISC OS; : pour toutes les autres plateforme; la valeur utilisée par PHP est disponible dans la contante PATH_SEPARATOR). Si un dossier vide est fourni dans PHP_INI_SCAN_DIR, PHP lira également le dossier fournis à la compilation via --with-config-file-scan-dir.

Dans chaque répertoire, PHP lira tous les fichiers terminant par .ini dans l'ordre alphabétique. Une liste des fichiers qui ont été chargé et dans quel ordre est disponible en appelant la fonction php_ini_scanned_files(), ou en exécutant PHP avec l'option --ini.

Assuming PHP is configured with --with-config-file-scan-dir=/etc/php.d,
and that the path separator is :...

$ php
  PHP va charger tous les fichiers présent dans /etc/php.d/*.ini comme fichier 
  de configuration.

$ PHP_INI_SCAN_DIR=/usr/local/etc/php.d php
  PHP va charger tous les fichiers présent dans /usr/local/etc/php.d/*.ini 
  comme fichier de configuration.

$ PHP_INI_SCAN_DIR=:/usr/local/etc/php.d php
  PHP va charger tous les fichiers présent dans /etc/php.d/*.ini, puis
  /usr/local/etc/php.d/*.ini comme fichier de configuration.

$ PHP_INI_SCAN_DIR=/usr/local/etc/php.d: php
  PHP va charger tous les fichiers présent dans /usr/local/etc/php.d/*.ini, puis dans
  /etc/php.d/*.ini comme fichier de configuration.

Exécuter PHP comme module Apache

Lorsque vous utilisez le module Apache, vous pouvez aussi changer les paramètres de configuration en utilisant les directives dans les fichiers de configuration d'Apache (httpd.conf) et dans les fichiers .htaccess. Vous aurez besoin des privilèges "AllowOverride Options" ou "AllowOverride All".

Il y a de nombreuses directives Apache qui vous permettent de modifier la configuration de PHP à partir des fichiers de configuration Apache. Pour une liste des directives qui sont INI_ALL, INI_PERDIR ou INI_SYSTEM reportez-vous à l'annexe Liste des directives du php.ini.

php_value nom valeur

Modifie la valeur de la directive spécifiée. Cette instruction n'est utilisable qu'avec les directives PHP de type INI_ALL et INI_PERDIR. Pour annuler une valeur qui aurait été modifiée au préalable, utilisez la valeur none.

Note: N'utilisez pas php_value pour configurer des valeurs booléennes. php_flag (voir plus bas) doit être utilisée.

php_flag nom on|off

Cette instruction est utilisée pour activer ou désactiver une option. Cette instruction n'est utilisable qu'avec les directives PHP de type INI_ALL et INI_PERDIR.

php_admin_value nom valeur

Cette instruction affecte une valeur à la variable spécifiée. Cette instruction NE peut PAS être utilisée dans un fichier .htaccess. Toute directive de PHP configurée avec le type php_admin_value ne peut pas être modifiée en utilisant le fichier .htaccess ou la fonction ini_set(). Pour annuler une valeur qui aurait été modifiée au préalable, utilisez la valeur none.

php_admin_flag name on|off

Cette directive est utilisée pour activer ou désactiver une option. Cette instruction NE peut PAS être utilisée dans un fichier .htaccess. Toute directive de PHP configurée avec le type php_admin_flag ne peut pas être modifiée en utilisant le fichier .htaccess ou par la fonction 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>

Modifier la configuration de PHP via la base de registre Windows

Lorsque vous utilisez PHP sur Windows, la configuration peut être modifiée dossier par dossier en utilisant la base de registres de Windows. Les valeurs de configuration sont stockées avec la clé de registre HKLM\SOFTWARE\PHP\Per Directory Values, dans les sous-clés correspondantes aux noms de dossier. Par exemple, la valeur d'une option dans le dossier c:\inetpub\wwwroot sera stockée dans la clé HKLM\SOFTWARE\PHP\Per Directory Values\c\inetpub\wwwroot. La valeur de cette option sera utilisée pour tous les scripts qui fonctionnent dans ce dossier ou ses sous-dossiers. Les valeurs sous la clé doivent avoir le nom d'une direction de configuration PHP, et la valeur correspondante. Les constantes PHP ne sont pas utilisables : il faut mettre la valeur entière. Cependant, seules les valeurs des configurations dans INI_USER peuvent être fixées de cette manière, celles dans INI_PERDIR ne peuvent l'être, car ces valeurs de configurations sont relues à chaque requête.

Autres interfaces de configuration de PHP

Suivant la façon dont vous exécutez PHP, vous pouvez changer certaines valeurs durant l'exécution de vos scripts en utilisant ini_set(). Voir la documentation de la fonction ini_set() pour plus d'informations.

Si vous êtes intéressé par une liste complète des options configurées sur votre système avec leurs valeurs courantes, vous pouvez exécuter la fonction phpinfo() et consulter la page résultante. Vous pouvez aussi accéder individuellement aux directives de configuration pendant l'exécution de vos scripts en utilisant soit la fonction ini_get(), soit la fonction get_cfg_var().

Types atomiques

Certains types atomiques sont des types qui sont étroitement intégrés au langage et ne peuvent être reproduits avec des types définis par l'utilisateur.

La liste des types de base est la suivante :

• Types intégrés
  • type null
  • Types scalaires :
    • type bool
    • type int
    • type float
    • type string
  • type array
  • type object
  • type resource
  • type never
  • type void
  • Types de classes relatives: self, parent, et static
• Types de valeur
  • false
  • true
• Types définis par l'utilisateur (généralement appelés classes-types)
  • Interfaces
  • Classes
  • Énumérations
• type callable

Types composites

Il est possible de combiner plusieurs types atomiques en des types composites. PHP permet de combiner les types de la manière suivante :

• Intersection de classes-types (interfaces et noms de classes).
• Union de types.

Alias de type

PHP supporte deux alias de type : mixed et iterable qui correspond au type type d'union de object|resource|array|string|float|int|bool|null et Traversable|array respectivement.

Note: PHP ne supporte pas les alias de type définis par l'utilisateur.

Syntaxe

Il y a une seule valeur de type null, et c'est la constante insensible à la casse null.

Transtyper vers null

Transtyper une variable vers null en utilisant la syntaxe (unset) $var n'effacera pas la variable, ni écrasera sa valeur. Ca ne fera que retourner la valeur null.

Voir aussi

• is_null()
• unset()

Syntaxe

Pour spécifier un booléen littéral, utilisez la constante true ou false. Les deux sont insensibles à la casse.

Typiquement, le résultat d'un opérateur qui retourne un booléen, passé ensuite à une structure de contrôle.

Conversion en booléen

Pour convertir explicitement une valeur en bool, utilisez le cast (bool). Généralement, cela n'est pas nécessaire car lorsqu'une valeur est utilisée dans un contexte logique, elle sera automatiquement interprétée comme une valeur de type bool. Pour plus d'informations, voir le page Type Juggling.

Lors d'une conversion en booléen, les valeurs suivantes sont considérées comme false :

• le booléen false, lui-même
• l'entier 0 (zéro)
• les nombres à virgule flottante 0.0 et -0.0 (zéro)
• la chaîne vide "", et la chaîne "0"
• un tableau avec aucun élément
• le type unité NULL (incluant les variables non définies)
• les objets internes qui surchargent leur comportement de casting en booléen. Par exemple : les objets SimpleXML créés à partir d'éléments vides sans attributs.

Toutes les autres valeurs sont considérées comme true (y compris les ressources et NAN).

Voir aussi

• Les nombres à virgule flottante
• Les précisions arbitraires / BCMath
• Les entiers de longueur arbitraire / GMP

Syntaxe

Les entiers peuvent être spécifiés en notation décimale (base 10), hexadécimale (base 16), octale (base 8), ou binaire (base 2). L'opérateur de négation peut être utilisé pour désigner un entier négatif.

Pour utiliser la notation octale, précédez le nombre d'un 0 (zéro). À partir PHP 8.1.0, la notation octale peut être précédé avec 0o ou 0O. Pour utiliser la notation hexadécimale, précédez le nombre de 0x. Pour utiliser la notation binaire, précédez le nombre de 0b.

À partir de PHP 7.4.0, les entiers littéraux peuvent contenir des underscores (_) entre les chiffres, pour une meilleure lisibilité des littéraux. Ces underscores sont supprimés par le scanner de PHP.

Formellement, la structure d'un entier littéral est à partir de PHP 8.1.0 (auparavant, les préfixes octaux 0o ou 0O n'étaient pas autorisés, et avant PHP 7.4.0, les underscores n'étaient pas autorisés.

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

La taille d'un entier est dépendante de la plate-forme, cependant, une valeur maximale d'environ 2 milliards est habituelle (cela correspond à 32 bits signés). Les plateformes 64-bit ont habituellement une valeur maximale d'environ 9E18. PHP ne supporte pas les entiers non-signés. La taille d'un entier peut être déterminée en utilisant la constante PHP_INT_SIZE, la valeur maximale, en utilisant la constante PHP_INT_MAX, et la valeur minimale en utilisant la constante PHP_INT_MIN.

Débordement d'entier

Si PHP rencontre un nombre supérieur au maximal d'un entier, il sera interprété comme un nombre décimal. De la même façon, une opération qui résulte en un nombre en dehors de l'intervalles du type entier retournera un nombre décimal.

Il n'y a pas d'opérateur de division d'entier en PHP, pour accomplir ceci utiliser la fonction intdiv(). 1/2 produit le nombre décimal (0.5). La valeur peut être transtypé en un entier pour l'arrondir vers zéro, ou en utilisant la fonction round() pour avoir un contrôle plus fin sur la façon dont l'arrondi est exécuté.

Conversion en entier

Pour convertir explicitement une valeur en un entier, utiliser soit le mot-clé (int), soit (integer). Cependant, dans la plupart des cas, ce mot-clé n'est pas nécessaire vu qu'une valeur sera automatiquement convertie si un opérateur, une fonction ou une structure de contrôle demande un entier en guise d'argument. Une valeur peut également être convertie en un entier en utilisant la fonction intval().

Si une ressource est convertie vers un entier, alors le résultat sera l'identifiant unique de la ressource assigné par PHP à l'exécution.

Voir aussi le transtypage.

Convertir en un nombre flottant

Comparaison de nombres flottants

Comme dit dans la note ci-dessus, le test d'égalité des valeurs de nombres flottants est problématique, en raison de la façon dont ils sont représentés en interne. Cependant, il existe des façons de réaliser cette comparaison.

Pour tester l'égalité de valeurs de nombres flottants, une borne supérieure de l'erreur relative à l'arrondi est utilisée. Cette valeur est connue comme étant l'epsilon de la machine, ou le unit roundoff, et est la différence la plus petite acceptable dans les calculs.

NaN

Quelques opérations numériques peuvent donner comme résultat une valeur représentée par la constante NAN. Ce résultat représente une valeur indéfinie ou non représentable lors de calculs avec des nombres à virgule flottante. Toute comparaison, même stricte de cette valeur avec une autre valeur, y compris cette constante elle-même, sauf si elle est égale à true, donnera une valeur de false.

En raison du fait que NAN représente tout nombre de valeur différente, NAN ne doit pas être comparé à d'autres valeurs, y compris cette constante elle-même, et à la place, elle doit être vérifiée en utilisant la fonction is_nan().

Syntaxe

Une chaîne de caractères littérale peut être spécifiée de 4 façons différentes :

• Guillemets simples
• Guillemets doubles
• Syntaxe Heredoc
• Syntaxe 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

Mon nom est "MyName". J'affiche quelques Foo.
Maintenant, j'affiche quelques Bar2.
Et ceci devrait afficher un 'A' majuscule : A

Exemple de chaîne sur plusieurs lignes en utilisant la syntaxe Nowdoc.
Les barre oblique inversée sont toujours traité de façon littérale,
par exemple \\ and \'.

Mom nom est "$name". J'affiche quelques $foo->foo.
Maintenant, j'affiche quelques {$foo->bar[1]}.
Ceci ne devrait pas afficher un 'A' : \x41

Il a bu du jus de pomme.
Il a bu du jus constitué de .
Il a bu du jus constitué de pommes.

Il a bu du jus de pomme.
Il a bu du jus de poire.
Il a bu du jus de raisin.
John Smith a bu du jus de pomme.
John Smith a dit bonjour à Jane Smith.
John Smith's wife greeted Robert Paulsen.
Robert Paulsen a dit bonjour aux .

Le personnage à l'index -2 est n.
Change le caractère à l'index -3 par o donne 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)

Fonctions et opérateurs utiles

Les chaîne de caractères peuvent être concaténées en utilisant l'opérateur '.' (point). Il est à noter que l'opérateur '+' (addition) ne fonctionnera pas. Voir opérateurs de chaînes pour plus d'informations.

Il existe de nombreuses fonctions utiles pour la manipulation de chaîne de caractères.

Voir la section sur les fonctions de chaînes de caractères pour des fonctions génériques, et à la section sur les expressions régulières compatibles Perl pour des fonctionnalités de recherches et remplacements avancés.

Il existe également des fonctions pour les URL, et des fonctions pour chiffrer/déchiffrer des chaînes de caractères (Sodium et Hash).

Finalement, voir aussi les fonctions "type de caractères".

Conversion en chaîne de caractères

Une valeur peut être convertie en une chaîne de caractères en utilisant le mot-clé (string) ou la fonction strval(). La conversion en chaîne de caractères est automatiquement effectuée dans le contexte d'une expression où une chaîne de caractères est nécessaire. Ceci survient notamment lors de l'utilisation des fonctions echo ou print, ou lorsqu'une variable est comparée à une chaîne de caractères. Les sections sur les types et sur le transtypage expliquent ce qui suit de manière plus détaillée. Voir aussi la fonction settype().

Une valeur booléen true est convertie en la chaîne de caractères "1". Une valeur booléen false est convertie en "" (une chaîne vide). Ceci permet les conversions vers et depuis les valeurs booléen et chaîne de caractères.

Un entier ou un nombre décimal est converti en une chaîne de caractères représentant le nombre de façon textuelle (y compris l'exposant pour les nombre décimal). Les nombres à virgule flottante peuvent être convertis en utilisant la notation exponentielle (4.1E+6).

Note:

À partir de PHP 8.0.0, le point décimal est toujours un point .. Antérieur à PHP 8.0.0, le point décimal est défini dans la locale du script (catégorie LC_NUMERIC). Voir la fonction setlocale().

Les tableau sont toujours convertis en la chaîne de caractères "Array" ; à cause de cela, echo et print ne peuvent pas afficher par eux-même le contenu d'un tableau. Pour afficher un seul élément, il faut utiliser une syntaxe tel que echo $arr['foo']. Voir ci-dessous pour des astuces permettant d'afficher le contenu complet.

Pour pouvoir convertir un objet en chaîne de caractères la méthode magique __toString doit être utilisée.

Les ressources sont toujours converties en chaîne de caractères sous la forme "Resource id #1", où 1 est l'identifiant assigné à la ressource par PHP lors de l'exécution. Alors qu'il ne faut pas se fier à cette structure, car susceptible d'évoluer, elle sera néanmoins unique pour une ressource donnée durant toute la durée d'exécution du script courant (ie une requête web ou un processus CLI). Pour récupérer le type d'une ressource, utilisez la fonction get_resource_type().

null est toujours converti en une chaîne vide.

Au vu de tout cela, la conversion d'un tableau, d'un objet, ou d'une ressource, en une chaîne de caractères ne fournit aucune information utile sur sa valeur, mis à part son type. Voir les fonctions print_r() et var_dump() pour inspecter plus efficacement les contenus de ces types.

La plupart des valeurs en PHP peuvent également être converties en chaîne de caractères afin de les stocker. Cette méthode est appelée "sérialisation", et est effectuée par serialize().

Détails sur le type "chaîne de caractères"

Le type chaîne de caractères en PHP est implémenté sous la forme d'un tableau d'octets accompagné d'un entier indiquant la longueur de la mémoire tampon. Il n'a aucune information sur la traduction octet/caractère, laissant cette tâche au programmeur. Il n'y a aucune limitation sur les valeurs pouvant être présentes dans une chaîne ; en particulier, les octets dont la valeur est 0 (“octets NUL”) sont autorisés à n'importe quel endroit de la chaîne (cependant, quelques fonctions, indiquées dans ce manuel comme n'étant pas “sécurisées au niveau binaire”, peuvent ignorer tous les octets après un octet nul.)

La nature même du type "chaîne de caractères" explique qu'il n'existe pas de type “byte” en PHP - les chaînes de caractères jouent ce rôle. Les fonctions qui ne retournent pas de données textuelles - par exemple, des données arbitraires lues depuis un socket réseau - continueront de retourner des chaînes de caractères.

PHP ne dictant aucun encodage spécifique pour les chaînes de caractères, on pourrait se demander comment les chaînes littérales sont codés. Par exemple, est-ce que la chaîne "á" équivaut à la chaîne "\xE1" (ISO-8859-1), "\xC3\xA1" (UTF-8, C form), "\x61\xCC\x81" (UTF-8, D form) ou à une autre des représentations possibles ? La réponse est que la chaîne sera encodée suivant l'encodage courant du script. Aussi, si le script est écrit en ISO-8859-1, alors, la chaîne sera encodée en ISO-8859-1 ; et ainsi de suite. Toutefois, ceci n'est pas vrai si Zend Multibyte est activé ; dans ce cas, le script peut être écrit dans n'importe quel encodage (qui sera explicitement déclaré, ou bien détecté), puis sera converti en un encodage interne, qui sera utilisé pour les chaînes littérales. Notez qu'il existe des contraintes sur l'encodage du script (ou sur l'encodage interne, si Zend Multibyte est activé) - cela signifie quasiment toujours que l'encodage utilisé doit être un sur-ensemble compatible d'ASCII, comme UTF-8 ou ISO-8859-1. Notez cependant que les encodages dépendant de l'état, où les mêmes valeurs de l'octet peuvent être utilisées dans des états de décalage initial et non-initial, peuvent être problématiques.

Bien évidemment, pour être utiles, les fonctions qui opèrent sur du texte peuvent devoir faire des hypothèses sur la façon dont est encodé la chaîne de caractères. Malheureusement, ces hypothèses ne sont pas les mêmes suivant les fonctions de PHP :

• Certaines fonctions supposent que la chaîne est encodée en utilisant un (quelconque) encodage à un seul octet, mais n'ont pas besoin d'interpréter ces octets sous la forme de caractères. C'est actuellement le cas, par exemple, pour les fonctions substr(), strpos(), strlen() et strcmp(). Une autre façon de voir ces fonctions est qu'elles opèrent sur les mémoires tampons ; autrement dit, qu'elles fonctionnent avec les octets et leurs positions.
• D'autres fonctions reçoivent l'encodage de la chaîne en paramètre, éventuellement en assumant un encodage par défaut si ce n'est pas le cas. C'est le cas de la fonction htmlentities() ainsi que de la majorité des fonctions de l'extension mbstring.
• D'autres utilisent la locale courante (voir setlocale()), mais opèrent octet par octet.
• Enfin, elles peuvent juste supposer que la chaîne utilise un encodage spécifique, généralement UTF-8. C'est le cas de la plupart des fonctions de l'extension intl ainsi que de celles de l'extension PCRE (dans ce dernier cas, uniquement lorsque le modificateur u est utilisé).

Pour conclure, le fait d'écrire un programme correct en utilisant Unicode dépend de l'utilisation ou non de fonctions qui ne fonctionnent pas en Unicode, et qui corrompront très certainement les données ; il conviendra donc d'utiliser des fonctions qui fonctionnent correctement, générallement depuis les extensions intl et mbstring. Cependant, l'utilisation de fonctions qui peuvent gérer des encodages Unicode n'est que le commencement. Quelques soient les fonctions fournies par le langage, il est essentiel de connaître les spécifications de l'Unicode. Par exemple, un programme qui assume qu'il n'y a que des caractères en majuscule et en minuscule fait une mauvaise hypothèse.

Chaînes de caractères utilisées dans des contextes numériques

Lorsqu'une string doit être évaluée comme un nombre (par exemple, opérations arithmétiques, déclaration de type int, etc.), les étapes suivantes sont suivies pour déterminer le résultat :

1. Si la string est numérique, elle est résolue en int si la string est une chaîne numérique entière et entre dans les limites du type int (telles que définies par PHP_INT_MAX), sinon elle est résolue en un float.
2. Si le contexte autorise les chaînes débutant numériquement et que la string en est une, elle est résolue en int si la partie initiale de la chaîne string est une chaîne numérique entière et entre dans les limites du type int (telles que définies par PHP_INT_MAX), sinon elle est résolue en un float. De plus, une erreur de niveau E_WARNING est soulevée.
3. Si la string n'est pas numérique, une TypeError est lancée.

Comportement antérieur à PHP 8.0.0

Antérieur à PHP 8.0.0, une string était considérée comme numérique seulement si elle avait des espaces blancs en début de chaîne, si elle avait des espaces blancs en fin de chaîne, la chaîne était considérée comme une chaîne débutant numériquement.

Antérieur à PHP 8.0.0, lorsqu'une chaîne de caractères était utilisée dans un contexte numérique, elle effectuait les mêmes étapes que ci-dessus, avec les différences suivantes :

• L'utilisation d'une chaîne de caractères débutant numériquement générait une erreur de type E_NOTICE au lieu de E_WARNING.
• Si la chaîne de caractères n'était pas numérique, une E_WARNING était levée et la valeur 0 était retournée.

Syntaxe

array(
    key  => value,
    key2 => value2,
    key3 => value3,
    ...
)

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[clé] = valeur;
$arr[] = valeur;
// clé peut être un entier ou une chaîne de caractères
// valeur peut être n'importe quel type

Fonctions utiles

Il y a beaucoup de fonctions utiles pour travailler avec les tableaux. Nous vous invitons à lire la section de ce manuel sur les fonctions en rapport avec les tableaux.

Note:

La fonction unset() permet d'effacer les clés d'un tableau. Soyez attentif sur le fait que le tableau ne sera pas ré-indexé. Si vous voulez réaliser un effacement complet et une ré-indexation de votre tableau, vous devez utiliser la fonction array_values().

<?php
$a = array(1 => 'one', 2 => 'two', 3 => 'three');
unset($a[2]);
/* produira un tableau comme ceci
$a = array(1 => 'one', 3 => 'three');
et NON un tableau comme ceci
$a = array(1 => 'one', 2 =>'three');
*/

$b = array_values($a);
// Maintenant, $b vaut array(0 => 'one', 1 =>'three')
?>

La structure de contrôle foreach existe tout spécialement pour les tableaux. Elle fournit une manière pratique de parcourir un tableau.

Ce qu'il est possible de faire ou non avec un tableau