PHP
Les types

Entiers

Les entiers en PHP peuvent être spécifiés nativement en base 2 (binaire), base 8 (octal), base 10 (décimal) ou base 16 (hexadécimal).

$my_decimal = 42;
$my_binary = 0b101010;
$my_octal = 052;
$my_hexadecimal = 0x2a;

echo ($my_binary + $my_octal) / 2;
// Output is always in decimal: 42

Les entiers ont une longueur de 32 ou 64 bits, selon la plate-forme. La constante PHP_INT_SIZE contient la taille entière en octets. PHP_INT_MAX et (depuis PHP 7.0) PHP_INT_MIN sont également disponibles.

printf("Integers are %d bits long" . PHP_EOL, PHP_INT_SIZE * 8);
printf("They go up to %d" . PHP_EOL, PHP_INT_MAX);

Les valeurs entières sont automatiquement créées en fonction des besoins à partir de valeurs flottantes, booléennes et chaînes. Si un transtypage explicite est nécessaire, cela peut être fait avec la distribution (int) ou (integer) :

$my_numeric_string = "123";
var_dump($my_numeric_string);
// Output: string(3) "123"
$my_integer = (int)$my_numeric_string;
var_dump($my_integer);
// Output: int(123)

Le dépassement d'entier sera géré par la conversion en flottant:

$too_big_integer = PHP_INT_MAX + 7;
var_dump($too_big_integer);
// Output: float(9.2233720368548E+18)

Il n'y a pas d'opérateur de division en nombres entiers en PHP, mais il peut être simulé en utilisant un transtypage implicite, qui «arrondit» toujours en supprimant simplement la partie flottante. Depuis PHP version 7, une fonction de division en nombre entier a été ajoutée.

$not_an_integer = 25 / 4;
var_dump($not_an_integer);
// Output: float(6.25)
var_dump((int) (25 / 4)); // (see note below)
// Output: int(6)
var_dump(intdiv(25 / 4)); // as of PHP7
// Output: int(6)

(Notez que les parenthèses supplémentaires autour de (25 / 4) sont nécessaires car la distribution (int) a une priorité plus élevée que la division)

Cordes

Une chaîne en PHP est une série de caractères à un octet (c’est-à-dire qu’il n’existe pas de support Unicode natif) pouvant être spécifiée de quatre manières:

Simple coté

Affiche les choses presque complètement "telles quelles". Les variables et la plupart des séquences d'échappement ne seront pas interprétées. L'exception est que pour afficher un guillemet simple littéral, on peut y échapper avec une barre oblique inverse, et pour afficher une barre oblique inverse, on peut y échapper avec une autre barre oblique inverse \

$my_string = 'Nothing is parsed, except an escap\'d apostrophe or backslash. $foo\n';
var_dump($my_string);

/*
string(68) "Nothing is parsed, except an escap'd apostrophe or backslash. $foo\n"
*/

Double coté

Contrairement à une chaîne de guillemets simples, les noms de variables simples et les séquences d'échappement dans les chaînes seront évaluées. Les accolades (comme dans le dernier exemple) peuvent être utilisées pour isoler des noms de variables complexes.

$variable1 = "Testing!";
$variable2 = [ "Testing?", [ "Failure", "Success" ] ];
$my_string = "Variables and escape characters are parsed:\n\n";
$my_string .= "$variable1\n\n$variable2[0]\n\n";
$my_string .= "There are limits: $variable2[1][0]";
$my_string .= "But we can get around them by wrapping the whole variable in braces: {$variable2[1][1]}";
var_dump($my_string);

/*
string(98) "Variables and escape characters are parsed:

Testing!

Testing?

There are limits: Array[0]"

But we can get around them by wrapping the whole variable in braces: Success

*/

Heredoc

Dans une chaîne Heredoc, les noms de variables et les séquences d'échappement sont analysés de la même manière que les chaînes entre guillemets, bien que les accolades ne soient pas disponibles pour les noms de variables complexes. Le début de la chaîne est délimité par <<< identifier et la fin par identifier , où identifier est un nom PHP valide. L'identifiant de fin doit apparaître sur une ligne par lui-même. Aucun espace n’est autorisé avant ou après l’identifiant, même si, comme toute ligne de PHP, il doit également être terminé par un point-virgule.

$variable1 = "Including text blocks is easier";
$my_string = <<< EOF
Everything is parsed in the same fashion as a double-quoted string,
but there are advantages. $variable1; database queries and HTML output
can benefit from this formatting.
Once we hit a line containing nothing but the identifier, the string ends.
EOF;
var_dump($my_string);

/*
string(268) "Everything is parsed in the same fashion as a double-quoted string,
but there are advantages. Including text blocks is easier; database queries and HTML output
can benefit from this formatting.
Once we hit a line containing nothing but the identifier, the string ends."
*/

Nowdoc

Une chaîne nowdoc est comme la version citée de heredoc, même si les séquences d'échappement les plus élémentaires ne sont pas évaluées. L'identifiant au début de la chaîne est entouré de guillemets simples.

$my_string = <<< 'EOF'
A similar syntax to heredoc but, similar to single quoted strings,
nothing is parsed (not even escaped apostrophes \' and backslashes \\.)
EOF;
var_dump($my_string);

/*
string(116) "A similar syntax to heredoc but, similar to single quoted strings,
nothing is parsed (not even escaped apostrophes \' and backslashes \\.)"
*/

Booléen

Boolean est un type ayant deux valeurs, noté true ou false .

Ce code définit la valeur de $foo comme true et $bar comme false :

$foo = true;
$bar = false;

true et false ne sont pas sensibles à la casse, donc TRUE et FALSE peuvent également être utilisés, même FaLsE est possible. L'utilisation des minuscules est la plus courante et recommandée dans la plupart des guides de style de code, par exemple PSR-2 .

Les booléens peuvent être utilisés dans les instructions if comme ceci:

if ($foo) { //same as evaluating if($foo == true)
    echo "true";
}

Étant donné que PHP est faiblement typé, si $foo ci-dessus est différent de true ou false , il est automatiquement forcé à une valeur booléenne.
Les valeurs suivantes entraînent false :

• une valeur nulle: 0 (entier), 0.0 (flottant) ou '0' (chaîne)
• une chaîne vide '' ou une matrice []
• null (le contenu d'une variable non définie ou assigné à une variable)

Toute autre valeur est true .

Pour éviter cette faible comparaison, vous pouvez appliquer une comparaison forte en utilisant === , qui compare la valeur et le type . Voir Comparaison de type pour plus de détails.

Pour convertir un type en booléen, vous pouvez utiliser le cast (bool) ou (boolean) avant le type.

var_dump((bool) "1"); //evaluates to true

ou appelez la fonction boolval :

var_dump( boolval("1") ); //evaluates to true

Conversion booléenne en chaîne (notez que false génère une chaîne vide):

var_dump( (string) true ); // string(1) "1"
var_dump( (string) false ); // string(0) ""

Conversion booléenne en entier:

var_dump( (int) true ); // int(1)
var_dump( (int) false ); // int(0)

Notez que le contraire est également possible:

var_dump((bool) "");        // bool(false)
var_dump((bool) 1);         // bool(true)

De même, tous les non-zéro renverront true:

var_dump((bool) -2);        // bool(true)
var_dump((bool) "foo");     // bool(true)
var_dump((bool) 2.3e5);     // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array());   // bool(false)
var_dump((bool) "false");   // bool(true)

Flotte

$float = 0.123;

Pour des raisons historiques, "double" est renvoyé par gettype() dans le cas d'un flottant, et pas simplement "float"

Les flottants sont des nombres à virgule flottante, qui permettent une plus grande précision de sortie que les entiers simples.

Les flotteurs et les entiers peuvent être utilisés ensemble en raison de la coulée libre de PHP des types de variables:

$sum = 3 + 0.14;

echo $sum; // 3.14

php ne montre pas float comme nombre flottant comme les autres langages, par exemple:

$var = 1;
echo ((float) $var); //returns 1 not 1.0

Attention

Précision à virgule flottante

(À partir de la page de manuel PHP )

Les nombres à virgule flottante ont une précision limitée. Bien que cela dépende du système, PHP donne généralement une erreur relative maximale due à l’arrondi de l’ordre de 1.11e-16. Les opérations arithmétiques non élémentaires peuvent donner des erreurs plus importantes et la propagation des erreurs doit être envisagée lorsque plusieurs opérations sont combinées.

De plus, les nombres rationnels qui sont exactement représentables sous forme de nombres à virgule flottante dans la base 10, comme 0.1 ou 0.7, n'ont pas de représentation exacte sous forme de nombres à virgule flottante en base 2 (binaire), quelle que soit la taille de la mantisse . Par conséquent, ils ne peuvent pas être convertis en leurs homologues binaires internes sans une petite perte de précision. Cela peut conduire à des résultats confus: par exemple, floor ((0.1 + 0.7) * 10) renverra généralement 7 au lieu de 8, car la représentation interne sera quelque chose comme 7.9999999999999991118 ....

Donc, ne faites jamais confiance aux résultats des nombres flottants au dernier chiffre et ne comparez pas directement les nombres à virgule flottante pour l'égalité. Si une plus grande précision est nécessaire, les fonctions mathématiques de précision arbitraire et les fonctions gmp sont disponibles.

Appelable

Les callables sont tout ce qui peut être appelé comme rappel. Les choses que l'on peut appeler un "rappel" sont les suivantes:

• Fonctions anonymes

• Fonctions PHP standard (note: pas de constructions de langage )

• Classes statiques

• Classes non statiques ( utilisant une syntaxe alternative )

• Méthodes spécifiques d'objet / classe

• Objets eux-mêmes, tant que l'objet est trouvé dans la clé 0 d'un tableau

  Exemple de référence à un objet en tant qu'élément de tableau:

 $obj = new MyClass();
 call_user_func([$obj, 'myCallbackMethod']);

Les rappels peuvent être désignés par un indicateur de type callable partir de PHP 5.4.

$callable = function () {
    return 'value';
};

function call_something(callable $fn) {
    call_user_func($fn);
}

call_something($callable);

Nul

PHP représente "no value" avec le mot clé null . Il est quelque peu similaire au pointeur null en langage C et à la valeur NULL en SQL.

Définir la variable sur null:

$nullvar = null; // directly

function doSomething() {} // this function does not return anything
$nullvar = doSomething(); // so the null is assigned to $nullvar

Vérifier si la variable a été définie sur null:

if (is_null($nullvar)) { /* variable is null */ }

if ($nullvar === null) {  /* variable is null */ }

Variable nulle ou non définie

Si la variable n'a pas été définie ou n'a pas été définie, tous les tests par rapport à la valeur NULL seront réussis, mais ils généreront également un Notice: Undefined variable: nullvar : Notice: Undefined variable: nullvar :

$nullvar = null;
unset($nullvar);
if ($nullvar === null) {  /* true but also a Notice is printed */ }
if (is_null($nullvar)) {  /* true but also a Notice is printed */ }

Par conséquent, les valeurs non définies doivent être vérifiées avec isset :

if (!isset($nullvar)) {  /* variable is null or is not even defined */  }

Comparaison de type

Il existe deux types de comparaison : la comparaison libre avec == et la comparaison stricte avec === . Une comparaison stricte garantit que le type et la valeur des deux côtés de l'opérateur sont identiques.

// Loose comparisons
var_dump(1 == 1); // true
var_dump(1 == "1"); // true
var_dump(1 == true); // true
var_dump(0 == false); // true

// Strict comparisons
var_dump(1 === 1); // true
var_dump(1 === "1"); // false
var_dump(1 === true); // false
var_dump(0 === false); // false

// Notable exception: NAN — it never is equal to anything
var_dump(NAN == NAN); // false
var_dump(NAN === NAN); // false

Vous pouvez également utiliser une comparaison forte pour vérifier si le type et la valeur ne correspondent pas à l'aide de !== .

Un exemple typique où l'opérateur == ne suffit pas, sont des fonctions qui peuvent renvoyer différents types, comme strpos , qui renvoie false si le searchword est introuvable, et la position de correspondance ( int ) sinon:

if(strpos('text', 'searchword') == false)
  // strpos returns false, so == comparison works as expected here, BUT:
if(strpos('text bla', 'text') == false)
  // strpos returns 0 (found match at position 0) and 0==false is true.
  // This is probably not what you expect!
if(strpos('text','text') === false)
  // strpos returns 0, and 0===false is false, so this works as expected.

Casting de type

PHP devine généralement correctement le type de données que vous avez l'intention d'utiliser dans le contexte dans lequel il est utilisé, mais il est parfois utile de forcer manuellement un type. Cela peut être accompli en préfixant la déclaration avec le nom du type requis entre parenthèses:

$bool = true;
var_dump($bool); // bool(true)

$int = (int) true;
var_dump($int); // int(1)

$string = (string) true;
var_dump($string); // string(1) "1"
$string = (string) false;
var_dump($string); // string(0) ""

$float = (float) true;
var_dump($float); // float(1)

$array = ['x' => 'y'];
var_dump((object) $array); // object(stdClass)#1 (1) { ["x"]=> string(1) "y" } 

$object = new stdClass();
$object->x = 'y';
var_dump((array) $object); // array(1) { ["x"]=> string(1) "y" }

$string = "asdf";
var_dump((unset)$string); // NULL

Mais attention: tous les types ne fonctionnent pas comme on peut s’y attendre:

// below 3 statements hold for 32-bits systems (PHP_INT_MAX=2147483647)
// an integer value bigger than PHP_INT_MAX is automatically converted to float:
var_dump(       999888777666 ); // float(999888777666)
// forcing to (int) gives overflow:
var_dump((int)  999888777666 ); // int(-838602302)
// but in a string it just returns PHP_INT_MAX
var_dump((int) "999888777666"); // int(2147483647)

var_dump((bool) []);      // bool(false) (empty array)
var_dump((bool) [false]); // bool(true)  (non-empty array)

Ressources

Une ressource est un type spécial de variable qui référence une ressource externe, telle qu'un fichier, un socket, un flux, un document ou une connexion.

$file = fopen('/etc/passwd', 'r');

echo gettype($file);
# Out: resource

echo $file;
# Out: Resource id #2

Il existe différents types de sous-ressources. Vous pouvez vérifier le type de ressource en utilisant get_resource_type() :

$file = fopen('/etc/passwd', 'r');
echo get_resource_type($file);
#Out: stream

$sock = fsockopen('www.google.com', 80);
echo get_resource_type($sock);
#Out: stream

Vous pouvez trouver une liste complète des types de ressources intégrés ici .

Type Jongler

PHP est un langage faiblement typé. Il ne nécessite pas de déclaration explicite des types de données. Le contexte dans lequel la variable est utilisée détermine son type de données. la conversion se fait automatiquement:

$a = "2";             // string 
$a = $a + 2;          // integer (4) 
$a = $a + 0.5;        // float (4.5)
$a = 1 + "2 oranges"; // integer (3)