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 :
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().
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.
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.
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.
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.
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.
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.
Les fonctions internes
contraigne automatiquement null aux types scalaires,
ce comportement est OBSOLÈTE à partir de PHP 8.1.0.
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 :
À 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
nulletfalsene 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
?>Le casting de type converti la valeur à un type donnée en écrivant le type entre parenthèse avant la valeur à convertir.
<?php
$foo = 10; // $foo is an integer
$bar = (bool) $foo; // $bar is a boolean
?>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 NULLNote:
(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.
L'alias de cast (real) est obsolète à partir de PHP 8.0.0.
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.
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";
?>Note: Au lieu de transtyper une variable en une string, il est également possible d'entourer la variable de guillemets doubles.
<?php
$foo = 10; // $foo is an integer
$str = "$foo"; // $str is a string
$fst = (string) $foo; // $fst is also a string
// This prints out that "they are the same"
if ($fst === $str) {
echo "they are the same";
}
?>
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 :
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 :
Voir la section sur l'accès aux chaînes par caractère pour plus d'informations.<?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
?>
Uneven division of an integer variable by another integer variable will result in a float by automatic conversion -- you do not have to cast the variables to floats in order to avoid integer truncation (as you would in C, for example):
$dividend = 2;
$divisor = 3;
$quotient = $dividend/$divisor;
print $quotient; // 0.66666666666667Cast operators have a very high precedence, for example (int)$a/$b is evaluated as ((int)$a)/$b, not as (int)($a/$b) [which would be like intdiv($a,$b) if both $a and $b are integers].
The only exceptions (as of PHP 8.0) are the exponentiation operator ** [i.e. (int)$a**$b is evaluated as (int)($a**$b) rather than ((int)$a)**$b] and the special access/invocation operators ->, ::, [] and () [i.e. in each of (int)$a->$b, (int)$a::$b, (int)$a[$b] and (int)$a($b), the cast is performed last on the result of the variable expression].Casting objects to arrays is a pain. Example:
<?php
class MyClass {
private $priv = 'priv_value';
protected $prot = 'prot_value';
public $pub = 'pub_value';
public $MyClasspriv = 'second_pub_value';
}
$test = new MyClass();
echo '<pre>';
print_r((array) $test);
/*
Array
(
[MyClasspriv] => priv_value
[*prot] => prot_value
[pub] => pub_value
[MyClasspriv] => second_pub_value
)
*/
?>
Yes, that looks like an array with two keys with the same name and it looks like the protected field was prepended with an asterisk. But that's not true:
<?php
foreach ((array) $test as $key => $value) {
$len = strlen($key);
echo "{$key} ({$len}) => {$value}<br />";
for ($i = 0; $i < $len; ++$i) {
echo ord($key[$i]) . ' ';
}
echo '<hr />';
}
/*
MyClasspriv (13) => priv_value
0 77 121 67 108 97 115 115 0 112 114 105 118
*prot (7) => prot_value
0 42 0 112 114 111 116
pub (3) => pub_value
112 117 98
MyClasspriv (11) => second_pub_value
77 121 67 108 97 115 115 112 114 105 118
*/
?>
The char codes show that the protected keys are prepended with '\0*\0' and private keys are prepended with '\0'.__CLASS__.'\0' so be careful when playing around with this.If you want to convert a string automatically to float or integer (e.g. "0.234" to float and "123" to int), simply add 0 to the string - PHP will do the rest.
e.g.
$val = 0 + "1.234";
(type of $val is float now)
$val = 0 + "123";
(type of $val is integer now)The object casting methods presented here do not take into account the class hierarchy of the class you're trying to cast your object into.
/**
* Convert an object to a specific class.
* @param object $object
* @param string $class_name The class to cast the object to
* @return object
*/
public static function cast($object, $class_name) {
if($object === false) return false;
if(class_exists($class_name)) {
$ser_object = serialize($object);
$obj_name_len = strlen(get_class($object));
$start = $obj_name_len + strlen($obj_name_len) + 6;
$new_object = 'O:' . strlen($class_name) . ':"' . $class_name . '":';
$new_object .= substr($ser_object, $start);
$new_object = unserialize($new_object);
/**
* The new object is of the correct type but
* is not fully initialized throughout its graph.
* To get the full object graph (including parent
* class data, we need to create a new instance of
* the specified class and then assign the new
* properties to it.
*/
$graph = new $class_name;
foreach($new_object as $prop => $val) {
$graph->$prop = $val;
}
return $graph;
} else {
throw new CoreException(false, "could not find class $class_name for casting in DB::cast");
return false;
}
}There are some shorter and faster (at least on my machine) ways to perform a type cast.
<?php
$string='12345.678';
$float=+$string;
$integer=0|$string;
$boolean=!!$string;
?>Printing or echoing a FALSE boolean value or a NULL value results in an empty string:
(string)TRUE //returns "1"
(string)FALSE //returns ""
echo TRUE; //prints "1"
echo FALSE; //prints nothing!Type casting in expressions is executed first.
The casting is assigned to the value, not to the expression result.
Examples:
<?php
$string = "777";
var_dump( $string === 777 ); // FALSE
var_dump( (int) $string === 777 ); // TRUE
var_dump( ( (int) $string ) === 777 ); // TRUE
var_dump( (int) ( $string === 777 ) ); // 0
?>