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

Environnement CGI et modifications recommandées du php.ini

Il est important de garder en tête que iPlanet/SunONE/Netscape est un serveur Web multi-threadé. Comme toutes les requêtes se situent dans le même contexte (c'est le contexte sur serveur Web), et que ce contexte est unique, si vous voulez accéder à des variables comme PATH_INFO, HTTP_HOST etc., il n'est pas recommandé d'y accéder à l'ancienne manière de PHP, avec la fonction getenv() ou une autre méthode (register globals, $_ENV). De cette manière, vous n'aurez que des valeurs d'environnement du serveur, et non pas des valeurs correctes pour le CGI.

Note:

Pourquoi est-ce que les variables CGI sont invalides ?

C'est lié au fait que le processus du serveur Web est lancé par l'administrateur du serveur, qui utilise le script de lancement au démarrage. En fait, il aurait fallu que vous lanciez vous-même le processus. C'est pour cela que l'environnement du serveur Web contient des variables d'environnement CGI. Vous pouvez vérifier cela en lançant le serveur Web depuis un autre endroit que l'administrateur du serveur : utilisez la ligne de commande Unix en tant que root : vous verrez alors qu'il n'y a pas de variables d'environnement.

Changez simplement vos scripts pour lire les variables CGI, en utilisant le tableau superglobal $_SERVER. Si vous avez d'autres scripts qui utilisent encore $HTTP_HOST et compagnie, il est recommandé d'activer l'option register_globals dans le php.ini et de changer l'ordre des variables. IMPORTANT : supprimez le "E" dans cette option, car vous n'en avez pas besoin pour cet environnement.

variables_order = "GPCS"
register_globals = On

Utilisation particulière pour les pages d'erreurs ou les listages spécifiques de dossier (PHP >= 4.3.3)

Vous pouvez utiliser PHP pour générer des pages d'erreurs de type "404 Not Found" ou apparentée. Ajoutez la ligne suivante dans le fichier obj.conf pour chaque page d'erreur que vous souhaitez remplacer :

Error fn="php4_execute" code=XXX script="/chemin/vers/script.php" [inikey=value inikey=value...]

Une autre possibilité est de générer une liste de dossiers personnalisée. Créez simplement un script PHP qui affiche le contenu du dossier, et remplacez la ligne Service par défaut par type="magnus-internal/directory" dans obj.conf avec ceci :

Service fn="php4_execute" type="magnus-internal/directory" script="/chemin/vers/script.php" [inikey=value inikey=value...]

Note au sujet de nsapi_virtual() et des requêtes (PHP >= 4.3.3)

Le module NSAPI supporte désormais la fonction nsapi_virtual() (alias : virtual()), pour réaliser des sous requêtes au serveur Web, et inclure le résultat dans une page. Le problème est que cette fonction utilise une fonctionnalité non documentée de la bibliothèque NSAPI. Sous Unix, ce n'est pas un problème, car le module va automatiquement rechercher les fonctions nécessaires, et les utiliser si elles sont disponibles. Sinon, nsapi_virtual() sera désactivée.

Note:

Soyez prévenu : le support de nsapi_virtual() est EXPERIMENTAL !

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 php4-core-4.3.8.tgz, qui contient le moteur de base, plus gettext et iconv). Puis, jetez un oeil aux paquets de module, comme php4-mysql-4.3.8.tgz ou php4-imap-4.3.8.tgz. Vous devez utiliser la commande phpxs pour activer et désactiver ces modules dans votre 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
  (add in mysql)
# pkg_add php4-mysql-4.3.8.tgz
# /usr/local/sbin/phpxs -a mysql
  (add in imap)
# pkg_add php4-imap-4.3.8.tgz
# /usr/local/sbin/phpxs -a imap
  (remove mysql as a test)
# pkg_delete php4-mysql-4.3.8
# /usr/local/sbin/phpxs -r mysql
  (install the PEAR libraries)
# pkg_add php4-pear-4.3.8.tgz

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 PHP4 est scindé en deux sous-dossiers : 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

• 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, ce qui fait que rien n'est nécessaire. Plus d'informations sur OpenBSD Apache sont disponibles sur » OpenBSD FAQ.
• Le paquet OpenBSD 3.6 pour l'extension » gd requiert XFree86. Si vous n'avez pas besoin des fonctionnalités de polices qui demandent X11, installez le paquet php4-gd-4.3.8-no_x11.tgz.

Versions plus anciennes

Les anciennes versions de OpenBSD utilisaient le système des FLAVORS pour compiler statiquement PHP. Comme il est trop difficile de générer des packages binaires avec cette méthode, elle est considérée comme obsolète. Vous pouvez toujours utiliser les anciennes versions stables, mais sachez qu'elles ne sont plus supportées par l'équipe d'OpenBSD. Si vous avez des commentaires sur le sujet, le responsable actuel est Anil Madhavapeddy (avsm_arobase_openbsd_point_org).

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

• flex (à partir de PHP 5.2)
• 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 libapache2-mod-php5 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-get update.

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

APT installera et activera automatiquement le module PHP 5 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-get.

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

Ces exemples montreront de nombreux paquets, donc beaucoup spécifiques à PHP, comme php5-cgi, php5-cli et php5-dev. Déterminez ceux qui sont nécessaires et installez les comme n'importe quel autre en utilisant apt-get 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-get install php5-mysql php5-curl

APT ajoutera automatiquement les bonnes lignes aux fichiers connexes à php.ini, comme /etc/php5/apache2/php.ini, /etc/php5/conf.d/pdo.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-get et aptitude. Expliquer les différences subtiles entre les deux sort du cadre de ce manuel.

Installation normale

Exécutez l'installeur MSI et suivez les instructions fournies par l'assistant d'installation. Il vous sera demandé de sélectionner le serveur Web que vous voulez configurer en premier, ainsi que tous les détails de configuration nécessaires.

Ensuite, il vous sera demandé de sélectionner quelles fonctionnalités et extensions vous voulez installer et activer. En sélectionnant "Will be installed on local hard drive" dans le menu pour chaque élément, vous pouvez contrôler l'installation ou non de la fonctionnalité. En sélectionnant "Entire feature will be installed on local hard drive", vous pourrez installer toutes les sous-fonctionnalités de la fonctionnalité principale (par exemple, en sélectionnant la fonctionnalité "PDO", vous installerez également tous les drivers PDO).

L'installeur configurera donc PHP pour l'utiliser sous Windows, le fichier php.ini ainsi que certains serveurs Web. L'installeur configure actuellement IIS, Apache, Xitami et Sambar ; si vous utilisez un serveur web différent de ceux-ci, vous devrez le configurer manuellement.

Installation silencieuse

L'installeur supporte également un mode silencieux, qui est utile pour les administrateurs systèmes pour déployer PHP facilement. Pour utiliser le mode silencieux, entrez la commande suivante :

msiexec.exe /i php-VERSION-win32-install.msi /q

Vous pouvez contrôler le dossier d'installation en le passant comme paramètre à l'installeur. Par exemple, pour installer PHP dans le dossier e:\php :

msiexec.exe /i php-VERSION-win32-install.msi /q INSTALLDIR=e:\php

Vous pouvez également spécifier quelles fonctionnalités devront être installées. Par exemple, pour installer l'extension mysqli et l'exécutable CGI :

msiexec.exe /i php-VERSION-win32-install.msi /q ADDLOCAL=cgi,ext_php_mysqli

Voici la liste courante des fonctionnalités à installer :

MainExecutable - exécutable php.exe
ScriptExecutable - exécutable php-win.exe ( N'est plus disponible depuis PHP 5.2.10/5.3.0; il est maintenant inclut par défaut )
ext_php_* - les diverses extensions ( par exemple : ext_php_mysql for MySQL )
apache13 - module Apache 1.3
apache20 - module Apache 2.0
apache22 - module Apache 2.2
apacheCGI - exécutable Apache CGI
iis4ISAPI - module IIS ISAPI
iis4CGI - exécutable IIS CGI
iis4FastCGI - exécutable IIS CGI
NSAPI - module serveur Sun/iPlanet/Netscape
netserve - exécutable NetServe Web Server CGI
Xitami - exécutable Xitami CGI
Sambar - module Sambar Server ISAPI
CGI - exécutable php-cgi.exe
PEAR - installeur PEAR
Manual - manuel PHP au format CHM

Pour plus d'informations sur l'installation via les installeurs MSI depuis la ligne de commande, visitez » http://msdn.microsoft.com/en-us/library/aa367988.aspx

Mise à jour de PHP avec l'installeur

Pour effectuer une mise à jour, exécutez l'installeur soit en mode graphique, soit en ligne de commande. L'installeur lira vos options d'installation, effacera votre ancienne installation et réinstallera PHP avec les mêmes options que précédemment. Il est recommandé d'utiliser cette méthode pour mettre à jour votre installation de PHP plutôt que d'aller remplacer manuellement les fichiers dans le dossier d'installation.

Sélection et téléchargement de PHP

Téléchargez l'archive PHP depuis » PHP pour Windows: Binaires et sources. Il y a plusieurs versions de l'archive zip - choisissez la version correspondante au serveur web que vous utilisez :

• Si PHP est utilisé avec IIS, alors choisissez PHP 5.3 VC9 Non Thread Safe ou PHP 5.2 VC6 Non Thread Safe;

• Si PHP est utilisé avec IIS7 ou supérieure et PHP 5.3+, alors les binaires VC9 de PHP doivent être utilisés.

• Si PHP est utilisé avec Apache 1 ou Apache 2, alors choisissez PHP 5.3 VC6 ou PHP 5.2 VC6.

Note:

Les versions VC9 sont compilées avec le compilateur Visual Studio 2008 et sont optimisées en terme de performance et de stabilité. Les versions VC9 nécessitent d'avoir » Microsoft 2008 C++ Runtime (x86) ou » Microsoft 2008 C++ Runtime (x64) d'installé.

La structure et le contenu du paquet PHP

Décompressez le contenu de l'archive zip dans le dossier de votre choix, par exemple C:\PHP\. La structure des dossiers et des fichiers extraits depuis l'archive zip ressemble à ceci :

c:\php
   |
   +--dev
   |  |
   |  |-php5ts.lib                 -- php5.lib en version non thread safe
   |
   +--ext                          -- bibliothèques DLLs pour PHP
   |  |
   |  |-php_bz2.dll
   |  |
   |  |-php_cpdf.dll
   |  |
   |  |-...
   |
   +--extras                       -- vide 
   |
   +--pear                         -- copie initiale de PEAR
   |
   |
   |-go-pear.bat                   -- script d'installation de PEAR
   |
   |-...
   |
   |-php-cgi.exe                   -- exécutable CGI
   |
   |-php-win.exe                   -- exécution de scripts sans avoir un prompt de commande ouvert
   |
   |-php.exe                       -- exécutable de ligne de commande (CLI)
   |
   |-...
   |
   |-php.ini-development           -- configuration par défaut du php.ini
   |
   |-php.ini-production            -- configuration recommandée du php.ini
   |
   |-php5apache2_2.dll             -- n'existe pas dans la version non thread safe
   |
   |-php5apache2_2_filter.dll      -- n'existe pas dans la version non thread safe
   |
   |-...
   |
   |-php5ts.dll                    -- bibliothèque DLL coeur de PHP ( php5.dll en version non thread safe)
   | 
   |-...

Voici la liste des modules et des exécutables inclus dans l'archive zip de PHP :

• go-pear.bat - le script de configuration de PEAR. Référez-vous à l'» installation de PEAR pour plus de détails.

• php-cgi.exe - exécutable CGI qui peut être utilisé lors de l'exécution de PHP sous IIS via CGI ou FastCGI.

• php-win.exe - l'exécutable PHP pour l'exécution de scripts PHP sans fenêtre de ligne de commande (par exemple, des applications PHP qui utilisent un GUI Windows).

• php.exe - l'exécutable PHP pour l'exécution de scripts PHP dans une interface de ligne de commande (CLI).

• php5apache2_2.dll - module Apache 2.2.X.

• php5apache2_2_filter.dll - filtre Apache 2.2.X.

Modification du fichier php.ini

Après l'extraction du contenu du paquet PHP, copiez le fichier php.ini-production dans le fichier php.ini du même dossier. Si nécessaire, il est également possible de placer le fichier php.ini dans le dossier de votre choix mais cela nécessite d'autres étapes de configuration décrites dans la configuration de PHP.

Le fichier php.ini indique à PHP la façon doit il doit se configurer, mais aussi la façon dont il doit travailler avec l'environnement sur lequel il s'exécute. Voici quelques concfigurations du fichier php.ini qui aide PHP à fonctionner d'une meilleure façon sous Windows. Quelques-unes sont optionnelles. Il y a bien d'autres directives utiles pour votre environnement - référez-vous à la liste des directives du php.ini pour plus d'informations.

Directives nécessaires :

• extension_dir = <chemin vers le dossier des extensions> - extension_dir doit pointer vers le dossier contenant les fichiers des extensions PHP. Le chemin peut être absolu (e.g. "C:\PHP\ext") ou relatif (e.g. ".\ext"). Les extensions listées ci-dessous dans le fichier php.ini doivent se trouver dans le dossier extension_dir.

• extension = xxxxx.dll - Pour chaque extension que vous voulez activer, vous avez besoin d'une directive "extension=" qui indique à PHP quelles extensions du dossier extension_dir doivent être chargées au démarrage.

• log_errors = On - PHP a une fonctionnalité permettant d'historiser les erreurs, pouvant être utilisée pour envoyer les erreurs dans un fichier, ou vers un service (i.e. syslog) et fonctionne en conjonction de la directive error_log ci-dessous. Lors de l'exécution sous IIS, log_errors devrait être activée, avec une valeur valide de error_log.

• error_log = <chemin vers le fichier d'historisation des erreurs> - error_log doit spécifier le chemin absolu ou relatif vers un fichier où les erreurs PHP doivent être écrites. Le fichier doit être accessible en écriture par le serveur web. L'endroit commun de ce fichier est le dossier TEMP, par exemple, "C:\inetpub\temp\php-errors.log".

• cgi.force_redirect = 0 - Cette directive est nécessaire pour le fonctionnement sous IIS. Elle est relative à la sécurité et est nécessaire par bons nombres de serveurs web. Cependant, son activation sous IIS fera échouer le moteur PHP sous Windows.

• cgi.fix_pathinfo = 1 - Cette directive permet à PHP d'accéder aux informations concernant le chemin réel suivi par la spécification CGI. Cette directive est nécessaire lors de l'implémentation de FastCGI sous IIS.

• fastcgi.impersonate = 1 - FastCGI sous IIS supporte la possibilité de rendre impersonnels les éléments relatifs à la sécurité lors d'un appel client. Ceci permet à IIS de définir le contexte de sécurité sur lequel la demande est effectuée.

• fastcgi.logging = 0 - L'historisation FastCGI doit être désactivé sous IIS. S'il est activé, alors tous les messages de toutes les classes seront traités par FastCGI comme des conditions d'erreur, ce qui fera qu'IIS générera des exceptions HTTP 500.

Directives optionnelles

• max_execution_time = ## - Cette directive demande à PHP un maximum de temps afin d'exécuter un script donné. Par défaut, c'est 30 secondes. Augmentez la valeur de cette direction si l'application PHP prend plus de temps à s'exécuter.

• memory_limit = ###M - La mémoire maximale disponible pour le processus PHP, en méga-octets. Par défaut, c'est 128, ce qui est parfait pour la plupart des applications PHP. Pour des applications plus complexes, il peut être nécessaire d'augmenter cette valeur.

• display_errors = Off - Cette directive indique à PHP si les messages d'erreur doivent être inclus dans le flux retourné au serveur web. Si défini à "On", alors PHP les enverra, suivants les classes d'erreur que vous avez définies avec la directive error_reporting, au serveur web comme partie du flux d'erreur. Pour des raisons de sécurité, il est recommandé de définir à "Off" cette directive sur les serveurs de production afin de ne pas révéler les informations concernant la sécurité, qui sont inclues dans les messages d'erreur.

• open_basedir = <chemins vers les dossiers, séparés par un point virgule>, e.g. openbasedir="C:\inetpub\wwwroot;C:\inetpub\temp". Cette directive spécifie le chemin vers le dossier où PHP est autorisé à effectuer des opérations sur le système de fichiers. Toute opération en dehors de ces chemins retournera une erreur. Cette directive est spécialement utile pour cantonner l'installation de PHP dans des environnements partagés afin d'éviter que les scripts PHP accèdent à tout fichier se trouvant en dehors du dossier racine du site web.

• upload_max_filesize = ###M et post_max_size = ###M - La taille maximale autorisée, respectivement, d'un fichier téléchargé et des données de type POST. Les valeurs de ces directives devraient être augmentées si les applications PHP doivent effectuer de gros téléchargements, comme des images ou des fichiers vidéos.

PHP est maintenant configuré pour votre système. La prochaine étape est de choisir un serveur web et de la configurer pour y faire fonctionner PHP. Choisissez un serveur web depuis la table de contenus.

En plus de faire fonctionner PHP via un serveur web, PHP peut être exécuté depuis la ligne de commande, à la façon des scripts .BAT. Reportez-vous au chapitre sur la ligne de commande PHP sous Microsoft Windows pour plus d'informations.

Configuration sous IIS pour traiter les requêtes PHP

Téléchargez et installez PHP suivant les instructions décrites dans les étapes d'installation manuelle.

Note:

La version PHP non thread-safe est recommandé lors de l'utilisation d'IIS. Ces versions sont disponibles sur la page » PHP pour Windows : Binaires et sources.

Configurez les options CGI- et FastCGI du fichier php.ini comme ceci :

fastcgi.impersonate = 1
fastcgi.logging = 0
cgi.fix_pathinfo=1
cgi.force_redirect = 0

Téléchargez et installez l'extension » Microsoft FastCGI pour IIS 5.1 et 6.0. L'extension est disponible pour les plate-formes 32-bit et 64-bit - sélectionnez le bon paquet pour votre plate-forme..

Configurez l'extension FastCGI pour gérer les requêtes spécifiques PHP en exécutant la commande ci-dessous. Remplacez la valeur du paramètre "-path" avec le chemin absolu vers le fichier php-cgi.exe.

cscript %windir%\system32\inetsrv\fcgiconfig.js -add -section:"PHP" ^
-extension:php -path:"C:\PHP\php-cgi.exe"

Cette commande va créer un mapping des scripts IIS pour les extensions de fichiers *.php, ce qui aura pour effet la gestion de toutes les URLs se terminant par .php par l'extension FastCGI. De plus, la commande configurera l'extension FastCGI lui demandant d'utiliser l'exécutable php-cgi.exe pour traiter les requêtes PHP.

Note:

A ce point, les étapes d'installation et de configuration nécessaires sont terminées. Les instructions qui suivent dans cette section sont optionnelles mais vivement recommandées afin d'atteindre des fonctionnalités et des performances optimales de PHP sous IIS.

Usurpation d'identité et accès au système de fichiers

Il est recommandé d'activer l'usurpation d'identité pour FastCGI en PHP lors de l'utilisation avec IIS. Ce mode est contrôlé par la directive fastcgi.impersonate du fichier php.ini. Lorsque ce mode est activé, PHP effectuera toutes les opérations du système de fichiers avec le compte utilisateur qui a été choisi pour l'authentification IIS. Ceci assure que, même si le même processus PHP est partagé avec différents sites web IIS, les scripts PHP de ces sites web ne pourront pas accéder aux autres fichiers tant que différents comptes utilisateurs sont utilisées pour l'authentification IIS de chaque site web.

Par exemple, IIS 5.1 et IIS 6.0, dans leurs configurations par défaut, ont d'activé l'authentification anonyme avec le compte interne IUSR_<MACHINE_NAME> utilisé comme identité par défaut. Ceci signifie que, afin de permettre à IIS d'exécuter des scripts PHP, il est nécessaire de donner les droits de lecture au compte IUSR_<MACHINE_NAME> pour ces scripts. Si les applications PHP doivent effectuer des opérations en écriture sur certains fichiers ou écrire des fichiers dans des dossiers, le compte IUSR_<MACHINE_NAME> doit avoir les permissions en écriture sur ces différents éléments.

Pour déterminer quel est le compte utilisateur utilisé par l'authentification anonyme IIS, suivez ces étapes :

Pour modifier la configuration des permissions sur des fichiers ou des dossiers, utilisez l'explorateur Windows ou la commande icacls.

icacls C:\inetpub\wwwroot\upload /grant IUSR:(OI)(CI)(M)

Définition du fichier index.php comme document par défaut sous IIS

Les documents par défaut IIS sont utilisés pour les requêtes HTTP qui ne spécifie pas de nom de document. Avec les applications PHP, index.php agit généralement comme document par défaut. Pour ajouter index.php à la liste des documents par défaut IIS, suivez ces étapes :

Configuration du recyclage FastCGI et PHP

Configurez l'extension IIS FastCGI pour le recyclage des processus PHP en utilisant la commande ci-dessous. La directive instanceMaxRequests de FastCGI contrôle le nombre de requêtes a traité par un seul processus php-cgi.exe avant l'extinction de l'extension FastCGI. La variable d'environnement PHP PHP_FCGI_MAX_REQUESTS contrôle le nombre de requêtes qu'un seul processus php-cgi.exe peut gérer avant de ce recycler lui-même. Assurez-vous que la valeur spécifiée pour la directive InstanceMaxRequests FastCGI est inférieure ou égale à la valeur spécifiée pour la directive PHP_FCGI_MAX_REQUESTS.

cscript %windir%\system32\inetsrv\fcgiconfig.js -set -section:"PHP" ^
-InstanceMaxRequests:10000

cscript %windir%\system32\inetsrv\fcgiconfig.js -set -section:"PHP" ^
-EnvironmentVars:PHP_FCGI_MAX_REQUESTS:10000

Configuration du délai d'expiration FastCGI

Augmentez le délai d'expiration pour l'extension FastCGI s'il y a des applications dont les scripts PHP mettent beaucoup de temps à s'exécuter. Les 2 configurations qui contrôlent les délais d'expiration sont ActivityTimeout et RequestTimeout. Referez-vous à la » configuration de l'extension FastCGI pour IIS 6.0 pour plus d'informations sur ces configurations.

cscript %windir%\system32\inetsrv\fcgiconfig.js -set -section:"PHP" ^
-ActivityTimeout:90

cscript %windir%\system32\inetsrv\fcgiconfig.js -set -section:"PHP" ^
-RequestTimeout:90

Modification du dossier contenant le fichier php.ini

PHP recherche le fichier php.ini dans différents endroits et il est possible de modifier ces endroits de recherche du fichier php.ini en utilisant la variable d'environnement PHPRC. Pour demander à PHP de charger le fichier de configuration depuis un dossier personnalisé, exécutez la commande ci-dessous. Le chemin absolu du dossier contenant le fichier php.ini doit être spécifié sous la variable d'environnement PHPRC.

cscript %windir%\system32\inetsrv\fcgiconfig.js -set -section:"PHP" ^
-EnvironmentVars:PHPRC:"C:\Some\Directory\"

Activation du support FastCGI sous IIS

Le module FastCGI est désactivé par défaut sous IIS. Les étapes pour l'activer diffèrent suivant la version de Windows utilisée.

Pour activer le support FastCGI sous Windows Vista SP1 et Windows 7 :

Pour activer le support FastCGI sous Windows Server 2008 et Windows Server 2008 R2 :

Configuration d'IIS pour traiter les requêtes PHP

Téléchargez et installez PHP suivant les instructions décrites dans les étapes d'installation manuelle.

Note:

La version PHP non thread-safe est recommandée lors de l'utilisation d'IIS. Les versions non thread-safe sont disponibles sur la page » PHP pour Windows : Binaires et sources.

Configurez les options CGI et FastCGI dans le fichier php.ini comme ceci :

fastcgi.impersonate = 1
fastcgi.logging = 0
cgi.fix_pathinfo=1
cgi.force_redirect = 0

Configurez le gestionnaire de mapping IIS pour PHP en utilisant soit l'interface de gestion utilisateurs IIS ou l'outil en ligne de commande.

Utilisation de l'interface de gestion utilisateurs IIS pour créer un gestionnaire de mapping pour PHP

Suivez ces étapes pour créer un gestionnaire de mapping IIS pour PHP dans l'interface de gestion utilisateurs IIS :

1. Dans le menu démarrer de Windows, choisissez "Run:", tapez "inetmgr" et cliquez sur "Ok";

2. Dans l'interface de gestion utilisateurs IIS, sélectionnez le nœud correspondant au serveur dans l'arbre "Connections";

3. Dans la page "Features View", ouvrez la fonctionnalité "Handler Mappings";

   

4. Dans le panneau "Actions", cliquez sur "Add Module Mapping...";

5. Dans la fenêtre "Add Module Mapping", entrez ceci :

   • Request path: *.php
   • Module: FastCgiModule
   • Executable: C:\[Path to PHP installation]\php-cgi.exe
   • Name: PHP_via_FastCGI

6. Cliquez sur le bouton "Request Restrictions", puis, configurez le mappin pour appeler le gestionnaire uniquement si la requête est mappée à un fichier ou un dossier;

7. Cliquez sur OK sur tous les dialogues pour sauvegarder la configuration.

%windir%\system32\inetsrv\appcmd set config /section:system.webServer/fastCGI ^
/+[fullPath='c:\PHP\php-cgi.exe']

%windir%\system32\inetsrv\appcmd set config /section:system.webServer/handlers ^
/+[name='PHP_via_FastCGI', path='*.php',verb='*',modules='FastCgiModule',^
scriptProcessor='c:\PHP\php-cgi.exe',resourceType='Either']

Usurpation d'identité et l'accès au système de fichiers

Il est recommandé d'activer l'usurpation d'identité FastCGI en PHP lors de l'utilisation avec IIS. Ce mode est contrôlé par la directive fastcgi.impersonate du fichier php.ini. Lorsque l'usurpation d'identité est active, PHP effectuera toutes les opérations sur le systèmes de fichiers en se faisant passer pour le compte utilisateur qui a été déterminé par l'authentification IIS. Ceci assure que même si le même processus PHP est partagé sur plusieurs sites Web IIS, les scripts PHP de ces sites Web ne pourront pas accéder aux autres fichiers sachant qu'un compte utilisateur différent est utilisé pour l'authentification IIS de chacun de ces sites.

Par exemple, IIS 7, dans sa configuration par défaut, a d'activer l'authentification anonyme avec le compte utilisateur interne IUSR, utilisé comme identité par défaut. Ceci signifie que, pour qu'IIS puisse exécuter des scripts PHP, il est nécessaire d'avoir une permission en lecture pour le compte utilisateur IUSR sur ces scripts. Si les applications PHP doivent effectuer des opérations en écriture sur certains fichiers ou écrire des fichiers dans des dossiers, alors le compte IUSR doit avoir les bonnes permissions en écriture.

Pour déterminer le compte utilisateur utilisé comme identité anonyme sous IIS 7, utilisez la commande suivante. Remplacez "Default Web Site" avec le nom du site web IIS que vous utilisez. Dans l'élément de configuration XML, regardez l'attribut userName.

%windir%\system32\inetsrv\appcmd.exe list config "Default Web Site" ^
/section:anonymousAuthentication

<system.webServer>
  <security>
    <authentication>
      <anonymousAuthentication enabled="true" userName="IUSR" />
    </authentication>
   </security>
</system.webServer>

Note:

Si l'attribut userName n'est pas présent dans l'élément anonymousAuthentication, ou s'il est vide, alors cela signifie que l'identité de l'application est bien l'identité anonyme pour ce site web.

Pour modifier la configuration sur les permissions de ces fichiers ou ces dossiers, utilisez l'interface de l'explorateur Windows ou la ligne commande icacls.

icacls C:\inetpub\wwwroot\upload /grant IUSR:(OI)(CI)(M)

Définir index.php comme document par défaut sous IIS

Les documents par défaut IIS sont utilisés pour les requêtes HTTP qui ne spécifient pas un nom de document. Avec les applications PHP, index.php agit généralement comme document par défaut. Pour ajouter index.php à la liste des documents par défaut d'IIS, utilisez la commande suivante :

%windir%\system32\inetsrv\appcmd.exe set config ^
-section:system.webServer/defaultDocument /+"files.[value='index.php']" ^
/commit:apphost

Configuration du recyclage FastCGI et PHP

Configurez l'extension IIS FastCGI pour le recyclage des processus PHP en utilisant la commande ci-dessous. La directive instanceMaxRequests de FastCGI contrôle le nombre de requêtes a traité par un seul processus php-cgi.exe avant l'extinction d'IIS. La variable d'environnement PHP PHP_FCGI_MAX_REQUESTS contrôle le nombre de requêtes qu'un seul processus php-cgi.exe peut gérer avant de ce recycler lui-même. Assurez-vous que la valeur spécifiée pour la directive InstanceMaxRequests FastCGI est inférieure ou égale à la valeur spécifiée pour la directive PHP_FCGI_MAX_REQUESTS.

%windir%\system32\inetsrv\appcmd.exe set config -section:system.webServer/fastCgi ^
/[fullPath='c:\php\php-cgi.exe'].instanceMaxRequests:10000

%windir%\system32\inetsrv\appcmd.exe set config -section:system.webServer/fastCgi ^
/+"[fullPath='C:\{php_folder}\php-cgi.exe'].environmentVariables.^
[name='PHP_FCGI_MAX_REQUESTS',value='10000']"

Configuration du délai d'expiration FastCGI

Augmentez le délai d'expiration pour l'extension FastCGI s'il y a des applications dont les scripts PHP mettent beaucoup de temps à s'exécuter. Les 2 configurations qui contrôlent les délais d'expiration sont activityTimeout et requestTimeout. Utilisez les commandes ci-dessous pour modifier la configuration du délai d'expiration. Assurez-vous de remplacer la valeur du paramètre fullPath par le chemin absolu vers le fichier php-cgi.exe.

%windir%\system32\inetsrv\appcmd.exe set config -section:system.webServer/fastCgi ^
/[fullPath='C:\php\php-cgi.exe',arguments=''].activityTimeout:"90"  /commit:apphost

%windir%\system32\inetsrv\appcmd.exe set config -section:system.webServer/fastCgi ^
/[fullPath='C:\php\php-cgi.exe',arguments=''].requestTimeout:"90"  /commit:apphost

Modification du dossier contenant le fichier php.ini

PHP recherche le fichier php.ini dans différents endroits et il est possible de modifier ces endroits de recherche du fichier php.ini par défaut en utilisant la variable d'environnement PHPRC. Pour demander à PHP de charger le fichier de configuration depuis un dossier personnalisé, exécutez la commande ci-dessous. Le chemin absolu du dossier contenant le fichier php.ini doit être spécifié sous la variable d'environnement PHPRC.

appcmd.exe set config  -section:system.webServer/fastCgi ^
/+"[fullPath='C:\php\php.exe',arguments=''].environmentVariables.^
[name='PHPRC',value='C:\Some\Directory\']" /commit:apphost

Installation de PHP en tant que module Apache

Vous devez ajouter les lignes suivantes à votre fichier de configuration Apache httpd.conf :

# À ajouter à la fin de la section LoadModule
# N'oubliez pas de copier ce fichier depuis le dossier sapi !
LoadModule php4_module "C:/php/php4apache.dll"

# À ajouter à la fin de la section AddModule
AddModule mod_php4.c

# À ajouter à la fin de la section LoadModule
LoadModule php5_module "C:/php/php5apache.dll"

# À ajouter à la fin de la section AddModule
AddModule mod_php5.c

# Ajoutez cette ligne dans les parenthèses conditionnelles <IfModule mod_mime.c>
AddType application/x-httpd-php .php

# Pour les fichiers de syntaxe colorisée .phps, ajoutez également
AddType application/x-httpd-php-source .phps

Installation comme binaire CGI

Si vous avez dézippé le paquet PHP dans le répertoire c:\php\ comme décrit dans la section sur les étapes d'installation du manuel, vous devez insérer ces lignes à votre fichier de configuration Apache pour activer le binaire CGI :

ScriptAlias /php/ "c:/php/"
AddType application/x-httpd-php .php

# Pour PHP 4
Action application/x-httpd-php "/php/php.exe"

# Pour PHP 5
Action application/x-httpd-php "/php/php-cgi.exe"

# spécifez le répertoire où se trouve php.ini
SetEnv PHPRC C:/php

Si vous voulez présenter la source de vos fichiers PHP avec la coloration syntaxique, il n'existe pas d'option équivalente de celle de la version module de PHP. Si vous choisissez de configurer Apache pour utiliser PHP en mode CGI, vous aurez besoin d'utiliser la fonction highlight_file(). Pour réaliser cela simplement, créez un script PHP dans un fichier et ajoutez ce code : <?php highlight_file('original_php_script.php'); ?>.

Installation d'Apache comme gestionnaire

Vous devez insérer les lignes suivantes dans le fichier de configuration httpd.conf d'Apache pour charger le module PHP pour Apache 2.x :

# 
LoadModule php5_module "c:/php/php5apache2.dll"
AddHandler application/x-httpd-php .php

# configure the path to php.ini
PHPIniDir "C:/php"

Note: Rappelez-vous de placer votre chemin actuel de PHP dans le chemin C:/php/ des exemples ci-dessous. Assurez-vous d'utiliser soit php5apache2.dll, soit php5apache2_2.dll dans la directive LoadModule et de vérifiez que le fichier correspondant est en réalité situé dans le chemin utilisé dans cette directive.

La configuration suivante activera le gestionnaire PHP pour tous les fichiers qui ont l'extension .php, même si d'autres extensions sont utilisées pour ces fichiers. Par exemple, un fichier nommé example.php.txt sera exécuté par le gestionnaire PHP. Pour vous assurez que seuls les fichiers se terminant par .php sont exécutés, utilisez plutôt la configuration suivante :

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

Exécution de PHP en tant que CGI

Vous devriez consulter la » documentation Apache CGI où vous trouverez toutes les informations nécessaires à l'exécution d'Apache CGI.

Pour exécuter PHP en tant que CGI, vous devez placer tous vos fichiers php-cgi dans un dossier désigné comme dossier CGI en utilisant la directive ScriptAlias.

Vous devez ensuite insérer une ligne #! dans vos fichiers PHP, pointant vers le binaire PHP :

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

Exécuter PHP en tant que FastCGI

L'exécution de PHP en tant que FastCGI a un beaucoup d'avantages contrairement à son exécution en tant que CGI. Sa mise en place de cette manière est assez simple :

Récupérez mod_fcgid depuis » http://httpd.apache.org/mod_fcgid/. Les bibliothèques Win32 sont disponibles au téléchargement depuis ce site. Installez le module suivant les instructions fournies.

Configurez votre serveur web comme ci-dessous, en vous assurant d'ajuster tous les chemins pour refléter votre configuration système particulière :

LoadModule fcgid_module modules/mod_fcgid.so  

# Où se trouve le fichier php.ini ?
FcgidInitialEnv PHPRC        "c:/php" 

AddHandler fcgid-script .php  
FcgidWrapper "c:/php/php-cgi.exe" .php  

Configuration en CGI sur les serveurs Sun, iPlanet et Netscape

Pour installer PHP en CGI, suivez ce qui suit :

• Copiez le fichier php4ts.dll dans votre dossier principal (le dossier où vous avez installé Windows)

• Faites un fichier d'association depuis la ligne de commande. Tapez les lignes suivantes :

  assoc .php=PHPScript
  ftype PHPScript=c:\php\php.exe %1 %*

• Dans le serveur Netscape Enterprise Administration Server, créez un dossier shellcgi et supprimez-le aussitôt (cette opération crée 5 lignes importantes dans le fichier obj.conf et permet au serveur de gérer les scripts CGI).
• Dans le serveur Netscape Enterprise Administration Server, créez un nouveau type MIME : Category: type, Content-Type: magnus-internal/shellcgi, File Suffix:php.
• Recommencez pour chaque instance de serveur web qui devra exécuter PHP.

Plus de détails sur la configuration de PHP comme CGI sont disponibles à » http://benoit.noss.free.fr/php/install-php.html

Configuration NSAPI sur les serveurs Sun, iPlanet et Netscape

Pour installer PHP avec l'interface NSAPI, faites ceci :

• Copiez le fichier php4ts.dll dans votre dossier systemroot (le dossier où vous avez installé windows)

• Faites un fichier d'association depuis la ligne de commande. Tapez les lignes suivantes :

  assoc .php=PHPScript
  ftype PHPScript=c:\php\php.exe %1 %*

• Dans le serveur Netscape Enterprise Administration Server, créez un nouveau type MIME : Category: type, Content-Type: magnus-internal/shellcgi, File Suffix:php.

• Éditez le fichier magnus.conf (pour les serveurs >= 6) ou obj.conf (pour les serveurs < 6) et ajoutez ce qui suit : Vous devez placer ces lignes après mime types init.

  Init fn="load-modules" funcs="php4_init,php4_execute,php4_auth_trans" shlib="c:/php/sapi/php4nsapi.dll"
  Init fn="php4_init" LateInit="yes" errorString="Failed to initialise PHP!" [php_ini="c:/path/to/php.ini"]
  

  (PHP >= 4.3.3) Le paramètre php_ini est optionnel, mais si vous le définissez, vous pourrez placer votre fichier php.ini dans le dossier de configuration de votre serveur web.

• Configurez l'objet par défaut dans le fichier obj.conf (pour les classes de serveur virtuel [Sun Web Server 6.0+], dans le fichier vserver.obj.conf) : dans la section <Object name="default">, placez cette ligne nécessairement avant toutes les lignes 'ObjectType' et après toutes les lignes 'ObjectType' :

  Service fn="php4_execute" type="magnus-internal/x-httpd-php" [inikey=value inikey=value ...]
  

  (PHP >= 4.3.3) Comme paramètres supplémentaires, vous pouvez ajouter quelques valeurs spéciales du php.ini, par exemple, vous pouvez définir un docroot="/path/to/docroot" spécifique au contexte où php4_execute est appelé, non pas "On","Off",... (cela ne fonctionnerait pas correctement), e.g. zlib.output_compression=1 à la place de zlib.output_compression="On"

• Cela n'est nécessaire que si vous voulez configurer un dossier qui ne contiendra que vos scripts PHP (tout comme un dossier cgi-bin) :

  <Object name="x-httpd-php">
  ObjectType fn="force-type" type="magnus-internal/x-httpd-php"
  Service fn=php4_execute [inikey=value inikey=value ...]
  </Object>
  

  Après cela, vous pouvez configurer un dossier dans l'administration du serveur et lui assigner le style x-httpd-php. Tous les fichiers s'y trouvant seront exécutés comme étant des scripts PHP. Cela peut être pratique pour cacher l'usage de PHP en renommant les fichiers en .html.

• Redémarrez votre serveur web pour que les modifications prennent effet.
• Faites cela pour chaque instance du serveur web où vous voulez exécuter PHP.

Note:

Plus de détails sur la configuration de PHP comme filtre NSAPI peuvent être trouvés ici : » http://benoit.noss.free.fr/php/install-php4.html

Note:

La taille de la pile que PHP utilise dépend de la configuration du serveur web. Si vous rencontrez des crashs avec les grands scripts PHP, il est recommandé d'augmenter la taille de la pile avec la console d'administration : dans la section "MAGNUS EDITOR".

Environnement CGI et modifications recommandées du php.ini

Il est important de garder en tête que iPlanet/SunONE/Netscape est un serveur web multi-threadé. Comme toutes les requêtes se situent dans le même contexte (c'est le contexte sur serveur web), et que ce contexte est unique. SI vous voulez accéder a des variables comme PATH_INFO, HTTP_HOST etc. il n'est pas recommandé d'y accéder à l'ancienne manière de PHP, avec la fonction getenv() ou une autre méthode (register globals, $_ENV). De cette manière, vous n'aurez que des valeurs d'environnement du serveur, et non pas des valeurs correctes pour le CGI.

Note:

Pourquoi est-ce que les variables CGI sont invalides ?

C'est lié au fait que le processus du serveur web est lancé par l'administrateur du serveur, qui utilise le script de lancement au démarrage. En fait, il aurait fallu que vous lanciez vous-même le processus. C'est pour cela que l'environnement du serveur web contient des variables d'environnement CGI. Vous pouvez vérifier cela en lançant le serveur web depuis un autre endroit que l'administrateur du serveur : utilisez la ligne de commande Unix en tant que root : vous verrez alors qu'il n'y a pas de variables d'environnement.

Changez simplement vos scripts pour lire les variables CGI, en utilisant le tableau superglobal $_SERVER. Si vous avez d'autres scripts qui utilisent encore $HTTP_HOST et compagnie, il est recommandé d'activer l'option register_globals dans le php.ini et de changer l'ordre des variables. IMPORTANT : supprimez le "E" dans cette option, car vous n'en avez pas besoin pour cet environnement.

variables_order = "GPCS"
register_globals = On

Utilisation particulière pour les pages d'erreurs ou les listages spécifiques de dossiers (PHP >= 4.3.3)

Vous pouvez utiliser PHP pour générer des pages d'erreurs de type "404 Not Found" ou apparentée. Ajoutez la ligne suivante dans le fichier obj.conf pour chaque page d'erreur que vous souhaitez remplacer :

Error fn="php4_execute" code=XXX script="/path/to/script.php" [inikey=value inikey=value...]

Une autre possibilité est de générer une liste de dossiers personnalisée. Créez simplement un script PHP qui affiche le contenu du dossier, et remplacez la ligne Service par défaut par type="magnus-internal/directory" dans obj.conf avec ceci :

Service fn="php4_execute" type="magnus-internal/directory" script="/path/to/script.php" [inikey=value inikey=value...]

Note au sujet de nsapi_virtual() et des requêtes (PHP >= 4.3.3)

Le module NSAPI supporte désormais la fonction nsapi_virtual() (alias : virtual()), pour réaliser des sous requêtes au serveur web, et inclure le résultat dans une page. Le problème est que cette fonction utilise une fonctionnalité non documentée de la bibliothèque NSAPI.

Sous Unix, ce n'est pas un problème, car le module va automatiquement rechercher les fonctions nécessaires, et les utiliser si elles sont disponibles. Sinon, nsapi_virtual() sera désactivée.

Sous Windows, des limitations dans la gestion des DLL impose l'utilisation de la plus récente bibliothèque ns-httpdXX.dll. Cela a été testé pour les serveurs jusqu'à la version 6.0. Si une nouvelle version de SunONE server est utilisée, la détection échoue, et nsapi_virtual() est désactivée.

Dans ce cas, essayez ceci : ajoutez le paramètre suivant à php4_init dans magnus.conf/obj.conf :

Init fn=php4_init ... server_lib="ns-httpdXX.dll"

Vous pouvez vérifier le statut en utilisant la fonction phpinfo().

Note:

Soyez prévenu : le support de nsapi_virtual() est expérimental.

Compiler depuis les sources

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

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

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

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

Liste des directives globales de php-fpm.conf

pid string

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

error_log string

Chemin vers le fichier de journal. Par défaut: #INSTALL_PREFIX#/log/php-fpm.log.

log_level string

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

emergency_restart_threshold int

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

Interval 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 acccelé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 signals 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.

daemonize boolean

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

Liste des directives de pool

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

listen string

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 int

Affecte listen(2) backlog. Une valeur de '-1' signifie illimité. Valeur par défaut: -1.

listen.allowed_clients string

Liste d'adresses ipv4 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 accceptées depuis toute adresse ip. Valeur par défaut: any.

listen.owner string

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 0666.

listen.group string

Voyez listen.owner.

listen.mode string

Voyez listen.owner.

user string

Utilisateur Unix des processus FPM. Cette option est obligatoire.

group string

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

pm string

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 le directives suivantes: pm.max_children, pm.start_servers, pm.min_spare_servers, pm.max_spare_servers.

pm.max_children int

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. Options 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 in

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 int

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 int

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

pm.max_requests int

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_path string

L'URI vers la page de statut de FPM. Si cette valeur n'est pas précisée, aucune page de statut ne sera utilisée, ce qui est le cas par défaut.

ping.path string

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 string

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.

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' ne stoppe 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.

slowlog string

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

rlimit_files int

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

rlimit_core int

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

chroot string

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 string

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 boolean

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.

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 à php-fpm.conf

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

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\extensions" en PHP 4).

PHP est livré avec les extensions qui sont les plus utiles à la majorité des utilisateurs. Elles sont appelées des extensions coeur, ou "core".

Cependant, si vous avez besoins de fonctionnalités qui ne sont pas fournies par une extension coeur, vous pourriez quand même les trouver dans PECL. Le PHP Extension Community Library (PECL, aussi dit Bibliothèque d'Extensions Communautaires de PHP) est un dépôt de code pour les extensions PHP, qui fournit un annuaire de toutes les extensions connues, et un service d'hébergement pour télécharger et développer ces extensions.

Si vous avez développé une extension pour votre propre usage, vous pourriez avoir envie de l'héberger sur PECL, pour que tous ceux qui ont eu le même problème que vous, puissent avoir accès à la même solution. Cela vous donne de bonnes chances d'avoir des retours de la communauté, et, peut-être, des remerciements, des rapports de bugs, et même des correctifs. Avant que vous n'envoyez votre extension sur les serveurs PECL, il est recommandé de lire http://pecl.php.net/package-new.php.

Quelles extensions télécharger ?

Souvent, vous trouverez 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 vous utilisez PHP. Le script suivant va vous afficher toutes vos 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 votre fichier de configuration php.ini. Notez que de nombreuses extensions sont déjà présentes dans le fichier php.ini et que vous avez simplement à supprimer le point-virgule pour les activer.

;extension=php_extname.dll

extension=php_extname.dll

Cependant, certains serveurs Web sont déroutants, car ils n'utilisent pas le fichier php.ini rangé avec votre exécutable PHP. Pour en savoir plus sur votre véritable php.ini, recherchez son dossier dans le fichier phpinfo():

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

Loaded Configuration File   C:\Program Files\PHP\5.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 le fichier phpinfo(), vous devriez jeter un oeil dans les logs pour savoir d'où vient le problème.

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

Si vous utilisez PHP sur un serveur Web, la position et le format des logs varient grandement d'un serveur à l'autre. Lisez la documentation de votre serveur Web pour savoir où ils sont : PHP ne peut pas vous aider pour cela.

Les problèmes les plus courants sont la localisation du fichier DLL, 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, vous avez probablement téléchargé une mauvaise DLL. Essayez d'en charger une nouvelle, avec les bonnes configurations pour votre serveur. phpinfo() vous sera alors très utile.

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 PHP_INI_ALL, PHP_INI_PERDIR ou PHP_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 PHP_INI_ALL et PHP_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 PHP_INI_ALL et PHP_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 PHP_INI_USER peuvent être fixées de cette manière, celles dans PHP_INI_PERDIR ne peuvent l'être.

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

Syntaxe

Pour spécifier un booléen littéral, utilisez le mot-clé 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éen, utilisez (bool) ou (boolean). Cependant, dans la plupart des cas, le transtypage n'est pas nécessaire, sachant qu'une valeur sera automatiquement convertie si un opérateur, une fonction ou une structure de contrôle demandent un argument de type booléen.

Voir aussi le transtypage.

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)
• le nombre à virgule flottante 0.0 (zéro)
• la chaîne vide, et la chaîne "0"
• un tableau avec aucun élément
• un objet avec aucun membre, ni variable (uniquement en PHP 4)
• le type spécial NULL (incluant les variables non définies)
• les objets SimpleXML créés depuis des balises vides

Toutes les autres valeurs sont considérées comme TRUE (y compris toutes les ressources).

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) optionnellement précédée d'un signe (- ou +).

Les entiers littéraux binaires sont disponibles depuis PHP 5.4.0.

Pour utiliser la notation octale, précédez le nombre d'un 0 (zéro). Pour utiliser la notation hexadécimale, précédez le nombre d'un 0x. Pour utiliser la notation binaire, précédez le nombre d'un 0b.

Formellement, la structure d'un entier littéral est :

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

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

octal       : 0[0-7]+

integer     : [+-]?decimal
            | [+-]?hexadecimal
            | [+-]?octal
            | [+-]?binary

La taille d'un entier est dépendant 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, et la valeur maximale, en utilisant la constante PHP_INT_MAX depuis PHP 4.4.0 et PHP 5.0.5.

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 supérieur au nombre maximal d'un entier, retournera un nombre décimal.

Il n'y a pas d'opérateur de division entière en PHP. 1/2 contient en fait, float(0.5). La valeur peut être convertie en un entier en l'arrondissant, en utilisant la fonction round().

Conversion en entier

Pour convertir explicitement une valeur en un entier, utilisez 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().

Voir aussi : le transtypage.

Conversion en un nombre décimal

Pour plus d'informations sur la conversion de chaînes en nombres décimaux, voir la section sur la conversion de chaînes en nombres décimaux. Pour les valeurs d'autres types, la conversion est effectuée en convertissant tout d'abord la valeur en un entier, puis, en nombre décimal. Voir la section sur la conversion en entier pour plus d'informations. Une notice est émise si un objet est converti en nombre décimal.

Comparing floats

Comme dit dans la note ci-dessus, le test d'égalité des valeurs de nombres décimaux 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 décimaux, 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, 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 :

• Entourée de guillemets simples
• Entourée de guillemets doubles
• syntaxe Heredoc
• syntaxe Nowdoc (depuis PHP 5.3.0)

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

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 de.

Il a bu du jus de pomme.
Il a bu du jus de poire.
Il a bu du jus à base de s.
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 .

I am bar.
I am bar.

Fonctions et opérateurs utiles

Une chaîne de caractères peut être concaténée en utilisant l'opérateur '.' (point). Notez que l'opérateur '+' (addition) ne fonctionnera pas. Reportez-vous aux opérateurs de chaîne pour plus d'informations.

Il y a beaucoup de fonctions utiles pour la manipulation de chaîne de caractères.

Reportez-vous à la section sur les fonctions des chaînes de caractères pour plus de précisions et à la section sur les expressions rationnelles ou sur les expressions rationnelles compatibles Perl pour des recherches et des remplacements avancés.

Il y a également des fonctions pour les URL, et des fonctions pour chiffrer/déchiffrer les chaînes de caractères (mcrypt et mhash).

Et pour finir, reportez-vous aux 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 d'une 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 lors de l'utilisation des fonctions echo ou print ou lorsqu'une variable est comparée à une chaîne. Les sections sur les types et sur le transtypage expliquent ce qui suit de manière plus détaillée. Reportez-vous également à la fonction settype().

La valeur booléenne TRUE est convertie en la chaîne "1". La valeur booléenne FALSE est convertie en "" (une chaîne vide). Ceci permet les conversions vers et depuis une chaîne et un booléen.

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

Note:

Le point décimal est défini dans la locale du script (catégorie LC_NUMERIC). Reportez-vous à la fonction setlocale().

Les tableaux sont toujours convertis en la chaîne "Array" ; ainsi, echoet print ne peuvent être utilisés pour afficher le contenu d'un tableau. Pour afficher un seul élément, utilisez une syntaxe comme echo $arr['foo']. Voir ci-dessous pour des astuces permettant d'afficher le contenu complet.

Les objets en PHP <5.2 sont convertis en la chaîne "Object id#1" où 1 un est un chiffre pouvant varier. Pour afficher les valeurs des propriétés de l'objet (à des fins de déboguage, par exemple), lisez le paragraphe ci-dessous. Pour récupérer le nom de la classe de l'objet, utilisez la fonction get_class(). Notez qu'à partir de PHP 5, la méthode __toString est utilisée lorsqu'elle peut s'appliquer.

Les ressources sont toujours converties en la chaîne "Resource id #1", où 1 est le nombre unique assigné à la ressource par PHP au moment de l'exécution. Ne vous fiez pas à cette structure, il est possible qu'elle change. Pour récupérer le type de la 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 la valeur contenue dans ce type. Reportez-vous aux fonctions print_r() et var_dump() pour plus d'informations sur le contenu 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 "linéarisation", et est effectuée par la fonction serialize(). Si le moteur PHP a été compilé avec le support WDDX, les valeurs PHP peuvent également être linéarisées en XML.

Conversion de chaînes en nombres

Lorsqu'une chaîne de caractères est évaluée dans un contexte numérique, la valeur et le type résultants sont déterminés comme suit.

Si la chaîne de caractères ne contient aucun '.', 'e', ou 'E' et que la valeur numérique est dans l'intervalle de représentation des entiers (et notamment plus petite que PHP_INT_MAX), alors la chaîne de caractères sera transformée en entier. Dans les autres cas, elle sera interprétée comme un nombre décimal.

La valeur est fournie par la portion initiale de la chaîne de caractères. Si la chaîne de caractères commence par un caractère numérique valide, ce sera la valeur utilisée. Sinon, la valeur sera de 0 (zéro). Une valeur numérique valide est un signe optionnel, suivi par un ou plusieurs nombres (contenant, optionnellement, un point décimal), suivi par, éventuellement, un exponentiel. L'exponentiel est un 'e' ou 'E' suivi par un ou plusieurs nombres.

Pour plus d'informations sur ces conversions, reportez-vous au manuel Unix de la fonction strtod(3).

Pour tester un exemple de cette section, copiez/collez l'exemple et insérez la ligne suivante pour voir ce qu'il se passe :

Ne vous attendez pas à récupérer le code d'un caractère en le convertissant en entier, comme cela est possible en C. Utilisez la fonction ord() et la fonction chr() pour convertir les caractères en codes ASCII.

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

Le type string en PHP est implémenté sous la forme d'un tableau d'octets ainsi que d'un entier indiquant la longueur du buffer. 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 (“NUL bytes”) sont autorisés à n'importe quel endroit de la chaîne (cependant, quelques fonctions de ce manuel indiquées comme n'étant pas “sécurisée au niveau binaire”, peuvent ignorer tous les octets après un octet nul.)

De part la nature même du type "chaîne de caractères", cela explique le fait qu'il n'existe pas de type “byte” en PHP - la chaîne de caractères prend 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.

Ceci étant dit, PHP ne dicte aucun encodage spécifique pour les chaînes de caractères ; aussi, 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 toutes autres représentations ? 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, la chaîne sera encodée en ISO-8859-1 et ainsi de suite. Cependant, ceci n'est pas vrai si Zend Multibyte est actif ; dans ce cas, le script peut être écrit dans n'importe quel encodage (explicitement déclaré ou bien détecté) puis, sera convertis 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 que l'encodage utilisé doit être un sous-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 le statut du décalage initial et non-initial, peuvent devenir problématiques.

Bien évidemment, 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 suivants les fonctions PHP :

• Quelques fonctions supposent que la chaîne est encodée en utilisant un encodage multi-octets, mais n'ont pas besoin d'interpréter ces octets sous la forme de caractères. C'est actuellement le cas pour les fonctions substr(), strpos(), strlen() et strcmp(). Une autre façon de voir ces fonctions est qu'elles opèrent sur les buffers mémoires, i.e. elles fonctionnent avec les octets et leurs positions.
• D'autres fonctions demandent à ce que soit passé l'encodage de la chaîne, assumant un encodage par défaut si ce n'est pas le cas. C'est le cas des fonctions htmlentities() ainsi que la majorité des fonctions de l'extension mbstring.
• D'autres utilisent la locale courante (voir la fonction setlocale()), mais opèrent octets par octets. C'est le cas des fonctions strcasecmp(), strtoupper() ucfirst(). Cela signifie qu'elles ne peuvent être utilisées qu'avec les encodages sur un seul octet, et si l'encodage correspond à la locale. Actuellement, strtoupper("á") peut retourner "Á" si la locale est correctement positionnée, et á si l'encodage est sur un seul octet. Si la chaîne est encodée en UTF-8, le résultat correct ne sera pas retourné, et la chaîne résultante peut (ou pas) être corrompue, suivant la locale courante.
• Et enfin, elles peuvent juste émettre l'hypothèse que la chaîne utilise un encodage spécifique, comme UTF-8. C'est le cas des fonctions de l'extension intl ainsi que celles de l'extension PCRE (dans le dernier cas, uniquement lorsque le modificateur u est utilisé). Bien que ceci soit du en raison d'un but spécifique, la fonction utf8_decode() assume un encodage UTF-8 et la fonction utf8_encode(), un encodage ISO-8859-1.

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 les données ; il conviendra donc d'utiliser des fonctions qui fonctionnent correctement, comme celles des 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.

Syntaxe

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

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)

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) "hallo"
  [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[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