PHP
Les variables

Syntaxe

• $ variable = 'value'; // Assigner une variable générale
• $ object-> property = 'value'; // Attribuer une propriété d'objet
• ClassName :: $ property = 'value'; // Assigne une propriété de classe statique
• $ array [0] = 'value'; // Assigne une valeur à un index d'un tableau
• $ array [] = 'value'; // Pousse un élément à la fin d'un tableau
• $ array ['key'] = 'value'; // Attribuer une valeur de tableau
• echo $ variable; // Echo (print) une valeur de variable
• some_function ($ variable); // Utilise la variable comme paramètre de fonction
• unset ($ variable); // Supprime une variable
• $$ variable = 'value'; // Attribuer à une variable variable
• isset ($ variable); // Vérifie si une variable est définie ou non
• vide (variable $); // Vérifie si une variable est vide ou non

Remarques

<?php

/**
 * Juggle numbers and return true if juggling was
 * a great success.
 */
function numberJuggling(int $a, int $b) : bool
{
    $sum = $a + $b;

    return $sum % 2 === 0;
}

<?php
declare('strict_types=1');

Accès dynamique à une variable par nom (variables variables)

Les variables sont accessibles via des noms de variables dynamiques. Le nom d'une variable peut être stocké dans une autre variable, ce qui permet son accès dynamique. Ces variables sont appelées variables variables.

Pour transformer une variable en variable variable, vous mettez un $ supplémentaire devant votre variable.

$variableName = 'foo';
$foo = 'bar';

// The following are all equivalent, and all output "bar":
echo $foo;
echo ${$variableName};
echo $$variableName;

//similarly,
$variableName  = 'foo';
$$variableName = 'bar';

// The following statements will also output 'bar'
echo $foo; 
echo $$variableName; 
echo ${$variableName};

Les variables variables sont utiles pour mapper des appels de fonction / méthode:

function add($a, $b) {
    return $a + $b;
}

$funcName = 'add';

echo $funcName(1, 2); // outputs 3

Cela devient particulièrement utile dans les classes PHP:

class myClass {
    public function __construct() {
        $functionName = 'doSomething';
        $this->$functionName('Hello World');
    }

    private function doSomething($string) {
        echo $string; // Outputs "Hello World"
    }
}

Il est possible, mais pas obligatoire, de mettre $variableName entre {} :

${$variableName} = $value;

Les exemples suivants sont à la fois équivalents et en sortie "baz":

$fooBar = 'baz';
$varPrefix = 'foo';

echo $fooBar;               // Outputs "baz"
echo ${$varPrefix . 'Bar'}; // Also outputs "baz"

Utiliser {} n'est obligatoire que lorsque le nom de la variable est lui-même une expression, comme ceci:

${$variableNamePart1 . $variableNamePart2} = $value;

Il est néanmoins recommandé de toujours utiliser {} , car il est plus lisible.

Bien qu'il ne soit pas recommandé de le faire, il est possible de chaîner ce comportement:

$$$$$$$$DoNotTryThisAtHomeKids = $value;

Il est important de noter que l'utilisation excessive de variables variables est considérée comme une mauvaise pratique par de nombreux développeurs. Comme ils ne sont pas bien adaptés à l'analyse statique par les IDE modernes, les bases de code volumineuses comportant de nombreuses variables variables (ou invocations de méthodes dynamiques) peuvent rapidement devenir difficiles à gérer.

Différences entre PHP5 et PHP7

Une autre raison de toujours utiliser {} ou () est que PHP5 et PHP7 ont une manière légèrement différente de traiter les variables dynamiques, ce qui entraîne des résultats différents dans certains cas.

En PHP7, les variables dynamiques, les propriétés et les méthodes seront désormais évaluées strictement dans l’ordre de gauche à droite, par opposition au mélange de cas spéciaux en PHP5. Les exemples ci-dessous montrent comment l'ordre d'évaluation a changé.

Cas 1: $$foo['bar']['baz']

• Interprétation PHP5: ${$foo['bar']['baz']}
• Interprétation de PHP7: ($$foo)['bar']['baz']

Cas 2: $foo->$bar['baz']

• Interprétation PHP5: $foo->{$bar['baz']}
• Interprétation de PHP7: ($foo->$bar)['baz']

Cas 3: $foo->$bar['baz']()

• Interprétation PHP5: $foo->{$bar['baz']}()
• Interprétation PHP7: ($foo->$bar)['baz']()

Cas 4: Foo::$bar['baz']()

• Interprétation PHP5: Foo::{$bar['baz']}()
• Interprétation PHP7: (Foo::$bar)['baz']()

Types de données

Il existe différents types de données à des fins différentes. PHP n'a pas de définitions de type explicites, mais le type d'une variable est déterminé par le type de la valeur affectée ou par le type auquel elle est convertie. Voici un bref aperçu des types, pour une documentation détaillée et des exemples, voir la rubrique sur les types PHP .

Il existe les types de données suivants en PHP: null, booléen, entier, float, chaîne, objet, ressource et tableau.

Nul

Null peut être assigné à n'importe quelle variable. Il représente une variable sans valeur.

$foo = null;

Cela invalide la variable et sa valeur serait indéfinie ou nulle si elle est appelée. La variable est effacée de la mémoire et supprimée par le ramasse-miettes.

Booléen

C'est le type le plus simple avec seulement deux valeurs possibles.

$foo = true;
$bar = false;

Les booléens peuvent être utilisés pour contrôler le flux de code.

$foo = true;

if ($foo) {
    echo "true";
} else {
    echo "false";
}

Entier

Un entier est un nombre entier positif ou négatif. Il peut être utilisé avec n'importe quelle base de chiffres. La taille d'un entier dépend de la plate-forme. PHP ne supporte pas les entiers non signés.

$foo = -3;  // negative
$foo = 0;   // zero (can also be null or false (as boolean)
$foo = 123; // positive decimal
$bar = 0123; // octal = 83 decimal
$bar = 0xAB; // hexadecimal = 171 decimal
$bar = 0b1010; // binary = 10 decimal
var_dump(0123, 0xAB, 0b1010); // output: int(83) int(171) int(10)

Flotte

Les nombres à virgule flottante, "doubles" ou simplement appelés "flottants" sont des nombres décimaux.

$foo = 1.23;
$foo = 10.0;
$bar = -INF;
$bar = NAN;

Tableau

Un tableau est comme une liste de valeurs. La forme la plus simple d'un tableau est indexée par un entier et ordonnée par l'index, le premier élément se trouvant à l'index 0.

$foo = array(1, 2, 3); // An array of integers
$bar = ["A", true, 123 => 5]; // Short array syntax, PHP 5.4+

echo $bar[0];    // Returns "A"
echo $bar[1];    // Returns true
echo $bar[123];  // Returns 5
echo $bar[1234]; // Returns null

Les tableaux peuvent également associer une clé autre qu'un index entier à une valeur. En PHP, tous les tableaux sont des tableaux associatifs en arrière-plan, mais lorsque nous faisons référence à un «tableau associatif» distinctement, nous en appelons généralement un qui contient une ou plusieurs clés qui ne sont pas des entiers.

$array = array();
$array["foo"] = "bar";
$array["baz"] = "quux";
$array[42] = "hello";
echo $array["foo"]; // Outputs "bar"
echo $array["bar"]; // Outputs "quux"
echo $array[42]; // Outputs "hello"

Chaîne

Une chaîne est comme un tableau de caractères.

$foo = "bar";

Comme un tableau, une chaîne peut être indexée pour renvoyer ses caractères individuels:

$foo = "bar";
echo $foo[0]; // Prints 'b', the first character of the string in $foo.

Objet

Un objet est une instance d'une classe. Ses variables et méthodes sont accessibles avec l'opérateur -> .

$foo = new stdClass(); // create new object of class stdClass, which a predefined, empty class
$foo->bar = "baz";
echo $foo->bar; // Outputs "baz"
// Or we can cast an array to an object:
$quux = (object) ["foo" => "bar"];
echo $quux->foo; // This outputs "bar".

Ressource

Les variables de ressource contiennent des poignées spéciales pour les fichiers ouverts, les connexions à la base de données, les flux, les zones de canevas d'image et autres éléments (comme indiqué dans le manuel ).

$fp = fopen('file.ext', 'r'); // fopen() is the function to open a file on disk as a resource.
var_dump($fp); // output: resource(2) of type (stream)

Pour obtenir le type d'une variable sous forme de chaîne, utilisez la fonction gettype() :

echo gettype(1); // outputs "integer"
echo gettype(true); // "boolean"

Pratiques globales de variables

Nous pouvons illustrer ce problème avec le pseudo-code suivant

function foo() {
    global $bob;
    $bob->doSomething();
}

Votre première question ici est évidente

D'où vient $bob ?

Êtes-vous confus? Bien. Vous venez d'apprendre pourquoi les globals sont déroutants et considérés comme une mauvaise pratique .

S'il s'agissait d'un vrai programme, votre prochain plaisir sera de retrouver toutes les instances de $bob et vous espérez trouver celle qui convient (cela devient pire si $bob est utilisé partout). Pire encore, si quelqu'un d'autre définit $bob (ou si vous avez oublié et réutilisé cette variable), votre code peut se casser (dans l'exemple de code ci-dessus, avoir le mauvais objet ou aucun objet provoquerait une erreur fatale).

Puisque pratiquement tous les programmes PHP utilisent du code comme include('file.php'); votre travail maintenant le code comme celui-ci devient exponentiellement plus difficile, plus vous ajoutez de fichiers.

De plus, cela rend la tâche de tester vos applications très difficile. Supposons que vous utilisiez une variable globale pour conserver votre connexion à la base de données:

$dbConnector = new DBConnector(...);

function doSomething() {
    global $dbConnector;
    $dbConnector->execute("...");
}

Pour pouvoir tester cette fonction, vous devez remplacer la variable globale $dbConnector , exécuter les tests et la réinitialiser à sa valeur d'origine, qui est très sujette aux bogues:

/**
 * @test
 */
function testSomething() {
     global $dbConnector;

     $bkp = $dbConnector; // Make backup
     $dbConnector = Mock::create('DBConnector'); // Override

     assertTrue(foo());

     $dbConnector = $bkp; // Restore
}

Comment évitons-nous les Globals?

La meilleure façon d'éviter les globales est une philosophie appelée injection de dépendances . C'est là que nous transmettons les outils dont nous avons besoin dans la fonction ou la classe.

function foo(\Bar $bob) {
    $bob->doSomething();
}

C'est beaucoup plus facile à comprendre et à maintenir. Il n'y a pas de devinettes où $bob été mis en place, car l'appelant est responsable de le savoir (il nous transmet ce que nous devons savoir). Mieux encore, nous pouvons utiliser des déclarations de type pour limiter ce qui est passé.

Nous savons donc que $bob est soit une instance de la classe Bar , soit une instance d'un enfant de Bar , ce qui signifie que nous pouvons utiliser les méthodes de cette classe. Combiné à un autochargeur standard (disponible depuis PHP 5.3), nous pouvons désormais localiser où Bar est défini. PHP 7.0 ou version ultérieure inclut des déclarations de type étendues, dans lesquelles vous pouvez également utiliser des types scalaires (comme int ou string ).

Obtenir toutes les variables définies

get_defined_vars() renvoie un tableau contenant tous les noms et les valeurs des variables définies dans la portée dans laquelle la fonction est appelée. Si vous souhaitez imprimer des données, vous pouvez utiliser des fonctions standard pour la sortie de données lisibles par l'homme, telles que print_r ou var_dump .

var_dump(get_defined_vars());

Note : Cette fonction ne retourne généralement que 4 superglobales : $_GET , $_POST , $_COOKIE , $_FILES . Les autres superglobales ne sont retournées que si elles ont été utilisées quelque part dans le code. Cela est dû à la directive auto_globals_jit qui est activée par défaut. Lorsqu'elle est activée, les $_SERVER et $_ENV sont créées lors de leur première utilisation (Just In Time) et non lors du démarrage du script. Si ces variables ne sont pas utilisées dans un script, l'activation de cette directive entraînera un gain de performances.

Valeurs par défaut des variables non initialisées

Bien que cela ne soit pas nécessaire en PHP, il est toutefois conseillé d’initialiser les variables. Les variables non initialisées ont une valeur par défaut de leur type en fonction du contexte dans lequel elles sont utilisées:

Non défini ET non référencé

var_dump($unset_var); // outputs NULL

Booléen

echo($unset_bool ? "true\n" : "false\n"); // outputs 'false' 

Chaîne

$unset_str .= 'abc';
var_dump($unset_str); // outputs 'string(3) "abc"'

Entier

$unset_int += 25; // 0 + 25 => 25
var_dump($unset_int); // outputs 'int(25)'

Flotteur / double

$unset_float += 1.25;
var_dump($unset_float); // outputs 'float(1.25)'

Tableau

$unset_arr[3] = "def";
var_dump($unset_arr); //  outputs array(1) {  [3]=>  string(3) "def" }

Objet

$unset_obj->foo = 'bar';
var_dump($unset_obj); // Outputs: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }

S'appuyer sur la valeur par défaut d'une variable non initialisée est problématique dans le cas de l'inclusion d'un fichier dans un autre qui utilise le même nom de variable.

Véritable valeur et vérité opérateur identique

En PHP, les valeurs de variables ont une "vérité" associée, donc même les valeurs non-booléennes sont true ou false . Cela permet d'utiliser n'importe quelle variable dans un bloc conditionnel, par exemple

if ($var == true) { /* explicit version */ }
if ($var) { /* $var == true is implicit */ }

Voici quelques règles fondamentales pour différents types de valeurs de variables:

• Les chaînes dont la longueur est différente de zéro correspondent à true y compris les chaînes contenant uniquement des espaces tels que ' ' .
• Les chaînes vides '' assimilent à false .

$var = '';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = '   ';
$var_is_true = ($var == true); // true
$var_is_false = ($var == false); // false

• Les entiers équivalent à true s'ils ne sont pas nuls, tandis que zéro équivaut à false .

$var = -1;
$var_is_true = ($var == true); // true
$var = 99;
$var_is_true = ($var == true); // true
$var = 0;
$var_is_true = ($var == true); // false

• null équivaut à false

$var = null;
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

• Les chaînes vides '' et la chaîne zéro '0' équivalent à false .

$var = '';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = '0';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

• Les valeurs à virgule flottante équivalent à true si elles ne sont pas nulles, tandis que les valeurs nulles correspondent à false .
  • NAN (Not-a-Number de PHP) équivaut à true , c'est-à-dire que NAN == true est true . Cela est dû au fait que NAN est une valeur à virgule flottante non nulle .
  • Les valeurs nulles incluent à la fois +0 et -0 telles que définies par IEEE 754. PHP ne fait pas la distinction entre +0 et -0 dans son virgule flottante double précision, c.-à-d. floatval('0') == floatval('-0') est true .
    • En fait, floatval('0') === floatval('-0') .
    • De plus, floatval('0') == false et floatval('-0') == false .

$var = NAN;
$var_is_true = ($var == true); // true
$var_is_false = ($var == false); // false

$var = floatval('-0');
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = floatval('0') == floatval('-0');
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

OPÉRATEUR IDENTIQUE

Dans la documentation PHP pour les opérateurs de comparaison , il existe un opérateur identique === . Cet opérateur peut être utilisé pour vérifier si une variable est identique à une valeur de référence:

$var = null;
$var_is_null = $var === null; // true
$var_is_true = $var === true; // false
$var_is_false = $var === false; // false

Il a un opérateur correspondant non identique !== :

$var = null;
$var_is_null = $var !== null; // false
$var_is_true = $var !== true; // true
$var_is_false = $var !== false; // true

L'opérateur identique peut être utilisé comme alternative aux fonctions de langage comme is_null() .

CAS D'UTILISATION AVEC strpos()

La fonction de strpos($haystack, $needle) est utilisée pour localiser l'index auquel $needle apparaît dans $haystack , ou si elle se produit du tout. La fonction strpos() est sensible à la casse; si la recherche insensible à la casse est ce dont vous avez besoin, vous pouvez aller avec des stripos($haystack, $needle)

La fonction strpos & stripos contient également le troisième paramètre offset (int) qui, si spécifié, lance ce nombre de caractères depuis le début de la chaîne. Contrairement aux strrpos et strripos, le décalage ne peut pas être négatif

La fonction peut retourner:

• 0 si $needle est trouvé au début de $haystack ;
• un entier non nul spécifiant l'index si $needle est trouvé quelque part autre que le début dans $haystack ;
• et la valeur false si l' $needle ne trouve nulle part dans $haystack .

Comme 0 et false ont tous deux une vérité false en PHP mais représentent des situations distinctes pour strpos() , il est important de les distinguer et d'utiliser l'opérateur identique === pour rechercher exactement les false et pas seulement les valeurs false .

$idx = substr($haystack, $needle);
if ($idx === false) 
{
    // logic for when $needle not found in $haystack
} 
else
{
    // logic for when $needle found in $haystack
}

Alternativement, en utilisant l'opérateur non identique :

$idx = substr($haystack, $needle);
if ($idx !== false) 
{
    // logic for when $needle found in $haystack
} 
else
{
    // logic for when $needle not found in $haystack
}