## 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é. C'est-à-dire, si une string est assignée à la variable $var, alors $var est de type string. Si après une valeur int est assignée à $var, elle sera de type int.

PHP peut tenter de convertir le type d'une valeur en une autre automatiquement dans certains contextes. Les différents contextes qui existent sont :

- Numérique
- String
- Logique
- Intégral et string
- Comparatif
- Fonction

> Note: Quand une valeur a besoin d'être interprétée comme un type différent, la valeur elle-même ne change pas de type.

Pour forcer une variable à être évaluée comme un type particulier, voir la section sur le casting de type. Pour changer le type d'une variable, voir la fonction settype().

### Contextes numériques

Ceci est le contexte lors de l'utilisation d' opérateur arithmétique.

Dans ce contexte si un des opérandes est un float (ou pas interprétable comme int), les deux opérandes sont interprétés comme des floats, et le résultat sera un float. Sinon, les opérandes sont interprétés comme des ints, et le résultat sera aussi un int. À partir de PHP 8.0.0, si un des opérandes ne peut être interprété une TypeError est lancée.

### Contextes string

Ceci est le contexte lors de l'utilisation de echo, print, l'interpolation de chaînes de caractères, ou l' opérateur de concaténation pour les chaînes de caractères.

Dans ce contexte la valeur sera interprétée comme une string. Si la valeur ne peut pas être interprétée, une TypeError est levée. Antérieur à PHP 7.4.0, une `E_RECOVERABLE_ERROR` était soulevée.

### Contextes logiques

Ceci est le contexte lors de l'utilisation de déclarations conditionnelles, l'opérateur ternaire, ou un opérateur logique.

Dans ce contexte la valeur sera interprétée comme un bool.

### Contextes intégraux et string

Ceci est le contexte lors de l'utilisation d'un opérateur bit à bit.

Dans ce contexte si tous les opérandes sont de type string alors le résultat sera aussi une string. Sinon, les opérandes seront interprétés comme des ints, et le résultat sera aussi un int. À partir de PHP 8.0.0, si un des opérandes ne peut être interprétés une TypeError est lancée.

### Contextes comparatifs

Ceci est le contexte lors de l'utilisation d'un opérateur de comparaison.

Les conversions de types qui se produisent dans ce contexte sont expliqués dans le tableau Comparaison avec plusieurs types.

### Contextes de fonctions

Ceci est le contexte quand une valeur est passée à un paramètre ou propriété typée ou retournée depuis une fonction qui déclare un type de retour.

Dans ce contexte, la valeur doit être une valeur du type. Il existe deux exceptions, la première est la suivante : si la valeur est de type int et que le type déclaré est float, alors l'entier est converti en nombre à virgule flottante. La seconde est : si le type déclaré est un type scalaire , la valeur est convertible en un type scalaire, et le mode de typage coercitif est actif (par défaut), la valeur peut être convertie en une valeur scalaire acceptée. Voir ci-dessous pour une description de ce comportement.

Avertissement

Les fonctions internes contraigne automatiquement `null` aux types scalaires, ce comportement est OBSOLÈTE à partir de PHP 8.1.0.

#### Typage coercitif avec déclarations de type simples

- Type de déclaration bool : valeur est interprétée comme bool.
- Type de déclaration int : valeur est interprétée comme int si la conversion est bien-définie. Par exemple le chaîne est numérique.
- Type de déclaration float : valeur est interprétée comme float si la conversion est bien-définie. Par exemple le chaîne est numérique.
- Type de déclaration string : valeur est interprétée comme string.

#### Typage coercitif avec unions de type

Lorsque `strict_types` n’est pas activé, les déclarations de type scalaire sont soumises à des contraintes de type implicites limitées. Si le type exact de la valeur ne fait pas partie de l’union, le type cible est choisi dans l’ordre de préférence suivant :

1. int
2. float
3. string
4. bool

Si le type existe dans l'union et que la valeur peut être forcée en ce type en utilisant la sémantique de vérification de type existante de PHP, alors le type est choisi.
Attention

À titre d’exception, si la valeur est une chaîne et que int et float font tous deux partie de l’union, le type préféré est déterminé par la sémantique de chaîne numérique. Par exemple, pour `"42"` int est choisi, tandis que pour `"42.0"` float est choisi.

> Note:

> Les types qui ne font pas partie de la liste de préférences ci-dessus ne sont pas des cibles admissibles à la coercition implicite. En particulier, aucune contrainte implicite aux types `null` et `false` ne se produit.

Exemple #1 Exemple de types contraints à une partie type de l'union

    <?php
    // int|string
    42    --> 42          // exact type
    "42"  --> "42"        // exact type
    new ObjectWithToString --> "Result of __toString()"
                          // object never compatible with int, fall back to string
    42.0  --> 42          // float compatible with int
    42.1  --> 42          // float compatible with int
    1e100 --> "1.0E+100"  // float too large for int type, fall back to string
    INF   --> "INF"       // float too large for int type, fall back to string
    true  --> 1           // bool compatible with int
    []    --> TypeError   // array not compatible with int or string

    // int|float|bool
    "45"    --> 45        // int numeric string
    "45.0"  --> 45.0      // float numeric string

    "45X"   --> true      // not numeric string, fall back to bool
    ""      --> false     // not numeric string, fall back to bool
    "X"     --> true      // not numeric string, fall back to bool
    []      --> TypeError // array not compatible with int, float or bool
    ?>

### Cast de type

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

Exemple #2 Conversion de type

`<?php
$foo = 10; // $foo est un entier
$bar = (bool) $foo; // $bar est un booléen
var_dump($bar);
?>`

Les casts permis sont :

- `(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

> Note:

> `(integer)` est un alias du cast `(int)`. `(boolean)` est un alias du cast `(bool)`. `(binary)` est un alias du cast `(string)`. `(double)` et `(real)` sont des alias du cast `(float)`. Ces casts n'utilisent pas le nom de type canonique et ne sont pas recommandés.

Avertissement

L'alias de cast `(real)` est obsolète à partir de PHP 8.0.0.

Avertissement

Le cast `(unset)` a été rendu obsolète à partir de PHP 7.2.0. À noter que le cast `(unset)` est identique à assigner la valeur NULL à une variable ou un appel. Le cast `(unset)` est supprimé à partir de PHP 8.0.0.

Attention

Le cast `(binary)` et le préfixe `b` existent uniquement pour la compatibilité ascendante. Actuellement `(binary)` et `(string)` sont identiques, mais ceci peut changer : vous ne devriez pas compter dessus.

> Note:

> Les espaces blancs sont ignoré à l'intérieur des parenthèses d'un cast. Ansi, les deux casts suivant sont équivalents :

> `<?php
> $foo = (int) $bar;
> $foo = ( int ) $bar;
> ?>`

Cast de strings littérales et variables en strings binaires :

`<?php
$binary = (binary) $string;
$binary = b"binary string";
?>`

Au lieu de transtyper une variable en une string, il est également possible d'entourer la variable de guillemets doubles.

Exemple #3 Différents mécanismes de conversion

`<?php
$foo = 10; // $foo est un entier
$str = "$foo"; // $str est une chaîne
$fst = (string) $foo; // $fst est également une chaîne
// Ceci afficher "Ils sont les mêmes"
if ($fst === $str) {
echo "Ils sont les mêmes", PHP_EOL;
}
?>`

Ce qui se produira exactement lors d'un transtypage entre certains types n'est pas forcément évident. Pour plus d'informations, voir ces sections :

- Convertir en boolean
- Convertir en integer
- Convertir en float
- Convertir en string
- Convertir en array
- Convertir en object
- Convertir en resource
- Convertir en NULL
- Les tables de comparaison de type

> Note: Comme PHP prend en charge l'indexation dans les strings via des positions en utilisant la même syntaxe que l'indexation des array, l'exemple suivant est valable pour toutes les versions de PHP :

> Exemple #4 Utilisation d'un index de tableau avec une chaîne

> `<?php
> $a = 'car'; // $a est une chaîne de caractères
> $a[0] = 'b'; // $a est toujours une chaîne de caractères
> echo $a; // bar
> ?>`
> Voir la section sur l'accès aux chaînes par caractère pour plus d'informations.