Développement web avancé

1. 1994 - 1995 : PHP/FI Créé par Rasmus Lerdorf pour des scripts CGI personnels.
2. 1997 : PHP 3 Réécriture complète et adoption du nom PHP (PHP Hypertext Preprocessor).
3. 2000 : PHP 4 Moteur Zend 1.
4. 2004 : PHP 5 Moteur Zend 2. Modèle objet moderne (visibilité, interfaces, exceptions). PDO.
5. 2015 : PHP 7 Moteur Zend 3 (2x plus performant). Typage explicite. Nouveux opérateurs.
6. 2020 : PHP 8 JIT compiler. Amélioration de la gestion des erreurs et de la gestion des types.

php.ini

La configuration principale de PHP est gérée dans le fichier php.ini

Ce fichier contient un ensemble de directives, ce sont des paramètres de configuration selon le principe de clé=valeur. Elles sont organisées par catégories (langage, gestion des erreurs, performances, sécurité, etc.) et par modules. Ces modules de PHP sont des extensions qui étendent le cœur de PHP pour lui ajouter des fonctionnalités (gestion de MySQL, réseau, cryptographie, etc.)

Il est parfois possible de surcharger certaines directives autorisées :

• Soit dans Apache (virtualhost et .htaccess) si PHP est un module Apache (mod_php).
• Soit dans le script, avec PHP lui-même.

Directives

Exemples

• memory_limit : Taille maximale de mémoire que PHP peut utiliser.
• max_execution_time : Durée maximale (en secondes) pendant laquelle un script PHP peut s'exécuter.
• post_max_size : Taille maximale des données POST que le serveur peut accepter.
• display_errors : Affiche les erreurs PHP directement dans la sortie HTML.
• open_basedir : Restriction d'accès aux répertoires et fichiers.
• date.timezone : Fuseau horaire par défaut.
• default_charset : Encodage de caractères interne par défaut.

phpinfo( )

Affiche de nombreuses informations sur PHP, concernant sa configuration courante : options de compilation, extensions, version, informations sur le serveur, et l'environnement (lorsqu'il est compilé comme module), environnement PHP, informations sur le système, chemins, valeurs générales et locales de configuration, en-têtes HTTP et la licence PHP.

phpinfo(); // simplement

Valeurs

Typage

PHP détermine le type d'une variable au moment de l'exécution, en fonction de la valeur qui lui est affectée, et non en fonction d"une déclaration préalable. Cela offre une grande flexibilité mais cela augmente le risque d'erreurs silencieuses.

Jonglage de type

PHP ne requiert pas une définition de type explicite dans les déclarations de variables. Dans ce cas, le type d'une variable est déterminé en fonction de la valeur qu'elle a stocké.

$a = 10;      // typage dynamique (integer)
$b = "1";     // typage dynamique (string)
$c = "3" + 7; // conversion implicite en integer ($c vaut 10)

gettype( )

Retourne le type de la variable

$a = 10;     
$b = 1.5;    
$c = "Hello";

gettype( $a ); // Retourne "integer"
gettype( $b ); // Retourne "double" (et non "float" pour des raisons historiques)
gettype( $c ); // Retourne "string"

Déclaration de type

Typage explicite

Les déclarations de types peuvent être ajoutées aux arguments des fonctions, valeurs de retour, à partir de PHP 7.4.0, les propriétés de classe, et à partir de PHP 8.3.0, les constantes de classe :

// $a et $b doivent être des entiers.
function sum( int $a, int $b ){
  return $a + $b;
}

Casting de type

ou conversion explicite de type

Le casting de type converti la valeur à un type donnée en écrivant le type entre parenthèse avant la valeur à convertir :

$a = 10;          // integer
$b = (string) $a; // string

Voici la liste des casts permis :

•  (int)  : cast en int
•  (bool)  : cast en bool
•  (float)  : cast en float
•  (string)  : cast en string
•  (array)  : cast en array
•  (object)  : cast en object
•  (unset)  : cast en NULL

Il existe aussi des fonctions permettant de retourner une valeur dans un type donné :

•  intval( $value )  : retourne $value en nomber entier.
• floatval( $value )  : retourne $value en nomber décimal.
• strval( $value )  : retourne $value sous forme de chaîne de caractère.
• boolval( $value )  : retourne $value sous forme de boolean.

Type scalaire

Une valeur est considérée comme scalaire si elle est de type int, float, string ou bool. La fonction is_scalar( ) indique si une variable est un scalaire en retournant un boolean :

Détection de type

Il existe plusieurs fonctions permettant d'indiquer le type de la valeur passée en argument :

• is_bool( $value ) : Détermine si $value est un booléen.
• is_float( $value ) : Détermine si $value est un nombre décimal.
• is_int( $value ) : Détermine si $value est un nombre entier.
• is_numeric( $value ) : Détermine si $value est un nombre ou une chaîne numérique.
• is_string( $value ) : Détermine si $value est une chaîne de caractères.
• is_array( $value ) : Détermine si $value est un tableau.
• is_object( $value ) : Détermine si $value est un objet.
• is_null( $value ) : Détermine si $value vaut null.
• is_resource( $value ) : Détermine si $value est une ressource.

Manipulation des nombres

ou nombre approché

round( )

Arrondit un nombre à virgule flottante :

echo round( 1 );    // 1
echo round( 1.5 );  // 2
echo round( 1.49 ); // 1
echo round( 1.7 );  // 2
echo round( -1.2 ); // -1
echo round( -1.8 ); // -2

floor( )

Arrondit à l'entier inférieur :

echo floor( 1 );    // 1
echo floor( 1.5 );  // 1
echo floor( 1.49 ); // 1
echo floor( 1.7 );  // 1
echo floor( -1.2 ); // -2
echo floor( -1.8 ); // -2

ceil( )

Arrondit à l'entier supérieur:

echo ceil( 1 );    // 1
echo ceil( 1.5 );  // 2
echo ceil( 1.49 ); // 2
echo ceil( 1.7 );  // 2
echo ceil( -1.2 ); // -1
echo ceil( -1.8 ); // -1

(int) & intval( )

Cast un nombre décimal avec (int) ou intval() ne retournera que sa valeur entière, peut importe sa valeur décimal.

echo (int) 1.5;            // 1
echo (int) 12.1248548;     // 12
echo (int) -3.49;          // -3

echo intval( 1.5 );        // 1
echo intval( 12.1248548 ); // 12
echo intval( -3.49 );      // -3

Conversion de nombre

Numeric to string

Il existe plusieurs façons de transformer un nombre en chaîne de caractères :

$number = 1000.5;

// concatenation
echo $number . "";             // "1000.5"

// casting
echo (string) $number;         // "1000.5"

// number_format
echo number_format( $number ); // "1,001" ??

number_format( )

Formate un nombre en millier (séparé par une virgule par défaut) et l'arrondi avec round.

echo number_format( 1000 );                // "1,000";
echo number_format( 1000.5 );              // "1,001";
echo number_format( 1000000 );             // "1,000,000";
echo number_format( 1000.5, 2, ",", " " ); // "1 000.50";

String to numeric

$string = "10.5";

// conversion implicite
echo $string * 1;         // 10.5
echo "1,000.2" * 1;       // 1 (Warning: A non-numeric value encountered)

// casting
echo (float) $string;     // 10.5
echo floatval( $string);  // 10.5
echo (float) "1,000.2";   // 1

echo (int) $string;       // 10
echo intval( $string);    // 10

Falsy values

Les valeurs fausses (falsy) sont des valeurs évaluées comme fausses quand elles sont évaluées dans un contexte booléen :

var_dump( (bool) '' );       // false
var_dump( (bool) 0 );        // false
var_dump( (bool) 0.0 );      // false
var_dump( (bool) '0' );      // false
var_dump( (bool) NULL );     // false
var_dump( (bool) array() );  // false
var_dump( (bool) [] );       // false

Cela peut avoir un impact sur vos conditions :

// égal
if( "0" == false) {
  echo "✅ Cet echo est affiché";
}

// strictement égal
if( "0" === false ){
  echo "❌ Cet echo ne sera pas affiché";
}

Séquences d'échappement

L'antislash  \  permet d'échapper certains caractères spéciaux dans une chaîne de caractères :

echo 'L\'échappement ce fait sur l\'apostrophe';

Interpolation de chaînes

$pokemon = "Pikachu";
echo 'Un $pokemon sauvage apparaît';  // $pokemon pas interprété
echo 'Un ' . $pokemon . ' sauvage apparaît';   
echo "Un $pokemon sauvage apparaît";  
echo "Un \$pokemon sauvage apparaît"; // $pokemon pas interprété
echo "Un {$pokemon} sauvage apparaît";