Question :

Que signifie "&" ici en PHP?

Opérateur PHP "&"

Facilite la vie une fois que nous nous y sommes habitués .. (vérifiez l'exemple ci-dessous avec soin)

& vérifie généralement les bits définis dans $ a et $ b sont définis.

Avez-vous même remarqué comment ces appels fonctionnent?

   error_reporting(E_ERROR | E_WARNING | E_PARSE);
    error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
    error_reporting(E_ALL & ~E_NOTICE);
    error_reporting(E_ALL);

Donc, derrière tout ce qui précède se cache un jeu d’opérateurs et de bits.

Un cas utile parmi ceux-ci est la configuration simple comme celle donnée ci-dessous, de sorte qu'un seul champ entier peut stocker des milliers de combinaisons pour vous.

La plupart des gens ont déjà lu la documentation, mais n'ont pas précisé le cas d'utilisation réel de ces opérateurs au niveau des bits.

Exemple que vous allez aimer

<?php

class Config {

    // our constants must be 1,2,4,8,16,32,64 ....so on
    const TYPE_CAT=1;
    const TYPE_DOG=2;
    const TYPE_LION=4;
    const TYPE_RAT=8;
    const TYPE_BIRD=16;
    const TYPE_ALL=31;

    private $config;

    public function __construct($config){
        $this->config=$config;

        if($this->is(Config::TYPE_CAT)){
            echo 'cat ';
        }
        if($this->is(Config::TYPE_DOG)){
            echo 'dog ';
        }
        if($this->is(Config::TYPE_RAT)){
            echo 'rat ';
        }
        if($this->is(Config::TYPE_LION)){
            echo 'lion ';
        }
        if($this->is(Config::TYPE_BIRD)){
            echo 'bird ';
        }
        echo "\n";
    }

    private function is($value){
        return $this->config & $value;
    }
}

new Config(Config::TYPE_ALL);
// cat dog rat lion bird
new Config(Config::TYPE_BIRD);
//bird
new Config(Config::TYPE_BIRD | Config::TYPE_DOG);
//dog bird
new Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);
//rat lion bird

QUESTION:

Que signifie => ?

RÉPONSE:

=> Est-ce le symbole que les humains ont décidé d'utiliser pour séparer les paires "Key" => "Value" dans des tableaux associatifs.

ELABORANT:

Pour comprendre cela, nous devons savoir ce que sont les tableaux associatifs. La première chose qui se présente lorsqu'un programmeur conventionnel pense à un tableau ( en PHP ) serait quelque chose de similaire à:

$myArray1 = array(2016, "hello", 33);//option 1

$myArray2 = [2016, "hello", 33];//option 2

$myArray3 = [];//option 3
$myArray3[] = 2016; 
$myArray3[] = "hello"; 
$myArray3[] = 33;

Où, si nous voulions appeler le tableau dans une partie ultérieure du code, nous pourrions faire:

echo $myArray1[1];// output: hello
echo $myArray2[1];// output: hello
echo $myArray3[1];// output: hello

Jusqu'ici tout va bien. Cependant, en tant qu'êtres humains, nous pourrions avoir du mal à nous rappeler que l'index [0] du tableau est la valeur de l' année 2016, l'index [1] du tableau est un message d'accueil et l'index [2] du tableau est un simple valeur entière . L'alternative serait alors d'utiliser ce qu'on appelle un tableau associatif . Un tableau associatif présente quelques différences par rapport à un tableau séquentiel ( ce qui correspond aux cas précédents car ils incrémentent l'index utilisé dans une séquence prédéterminée, en incrémentant de 1 pour chaque valeur suivante ).

Différences ( entre un tableau séquentiel et associatif ):

• Au cours de la déclaration d’un tableau associatif, vous n’incluez pas seulement valuece que vous voulez mettre dans le tableau, mais vous indiquez également la valeur d’index (appelée le key) que vous souhaitez utiliser lorsque vous appelez le tableau dans code. La syntaxe suivante est utilisée au cours de ce déclaration: "key" => "value".

• Lors de l'utilisation du tableau associatif, la keyvaleur serait alors placée dans l'index du tableau pour récupérer le résultat souhaité value.

Par exemple:

    $myArray1 = array( 
        "Year" => 2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33);//option 1

    $myArray2 = [ 
        "Year" =>  2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33];//option 2

    $myArray3 = [];//option 3
    $myArray3["Year"] = 2016; 
    $myArray3["Greetings"] = "hello"; 
    $myArray3["Integer_value"] = 33;

Et maintenant, pour recevoir le même résultat qu'auparavant, la keyvaleur serait utilisée dans l'index des tableaux:

echo $myArray1["Greetings"];// output: hello
echo $myArray2["Greetings"];// output: hello
echo $myArray3["Greetings"];// output: hello

POINT FINAL:

Ainsi, à partir de l'exemple ci-dessus, il est assez facile de voir que le =>symbole est utilisé pour exprimer la relation d'un tableau associatif entre chacune des paires keyet valuedans un tableau PENDANT le lancement des valeurs dans le tableau.

Opérateur de coalescence nul (??)

Cet opérateur a été ajouté dans PHP 7.0 pour le cas habituel d'utilisation d'un opérateur ternaire avec isset() . Il retourne son premier opérande s'il existe et n'est pas NULL ; sinon, il retourne son deuxième opérande.

<?php
// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>

{} Accolades

• Blocs - accolades / pas d'accolades?
• Accolades dans une chaîne en PHP
• Accolades PHP en notation de tableau

Et quelques mots sur le dernier post

$x[4] = 'd'; // it works
$x{4} = 'd'; // it works

$echo $x[4]; // it works
$echo $x{4}; // it works

$x[] = 'e'; // it works
$x{} = 'e'; // does not work

$x = [1, 2]; // it works
$x = {1, 2}; // does not work

echo "${x[4]}"; // it works
echo "${x{4}}"; // does not work

echo "{$x[4]}"; // it works
echo "{$x{4}}"; // it works

Opérateur Null Coalesce "??" (Ajouté en PHP 7)

Ce n'est pas le nom le plus accrocheur pour un opérateur, mais PHP 7 apporte la fusion null, plutôt pratique, alors j'ai pensé partager un exemple.

En PHP 5, nous avons déjà un opérateur ternaire, qui teste une valeur, puis renvoie le deuxième élément si cela renvoie true et le troisième s'il ne le fait pas:

echo $count ? $count : 10; // outputs 10

Il existe également un raccourci pour celui qui vous permet de sauter le deuxième élément s'il est identique au premier: echo $ count?: 10; // affiche également 10

En PHP 7, nous obtenons également le ?? L’opérateur qui, plutôt que d’indiquer une confusion extrême, c’est ainsi que j’utilise habituellement deux points d’interrogation, nous permet plutôt de chaîner une chaîne de valeurs. En lisant de gauche à droite, la première valeur qui existe et qui n’est pas nulle est la valeur qui sera renvoyée.

// $a is not set
$b = 16;

echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

Cette construction est utile pour donner la priorité à une ou plusieurs valeurs provenant peut-être d'une entrée utilisateur ou d'une configuration existante, et pour revenir en toute sécurité à une valeur par défaut donnée si cette configuration manque. C’est un peu une petite fonctionnalité, mais je sais que je vais l’utiliser dès que mes applications passeront à PHP 7.

_ Alias ​​pour gettext ()

Le caractère de soulignement '_' comme dans _() est un alias de la fonction gettext() .

Incrémentation / décrémentation des opérateurs

++ opérateur incrément

-- opérateur de décrémentation

Example    Name              Effect
---------------------------------------------------------------------
++$a       Pre-increment     Increments $a by one, then returns $a.
$a++       Post-increment    Returns $a, then increments $a by one.
--$a       Pre-decrement     Decrements $a by one, then returns $a.
$a--       Post-decrement    Returns $a, then decrements $a by one.

Ceux-ci peuvent aller avant ou après la variable.

Si elle est placée avant la variable, l'opération d'incrémentation / décrémentation est effectuée sur la variable puis le résultat est renvoyé. Si elle est placée après la variable, la variable est d' abord renvoyée, puis l'opération d'incrémentation / décrémentation est effectuée.

Par exemple:

$apples = 10;
for ($i = 0; $i < 10; ++$i) {
    echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}

Exemple en direct

Dans le cas ci-dessus, ++$i est utilisé car il est plus rapide. $i++ aurait les mêmes résultats.

La pré-incrémentation est un peu plus rapide car elle incrémente réellement la variable et après elle "retourne" le résultat. La post-incrémentation crée une variable spéciale, y copie la valeur de la première variable et remplace celle-ci uniquement après l'utilisation de la première.

Cependant, vous devez utiliser $apples-- , puisque vous voulez d’abord afficher le nombre actuel de pommes, puis vous voulez en soustraire une.

Vous pouvez également incrémenter des lettres en PHP:

$i = "a";
while ($i < "c") {
    echo $i++;
}

Une fois que z est atteint, aa est le suivant, et ainsi de suite.

Notez que les variables de caractère peuvent être incrémentées mais pas décrémentées. Néanmoins, seuls les caractères ASCII ordinaires (az et AZ) sont pris en charge.

Messages de débordement de pile:

• Comprendre l'incrémentation

Opérateurs de type

instanceof est utilisé pour déterminer si une variable PHP est un objet instancié d'une certaine classe.

<?php
class mclass { }
class sclass { }
$a = new mclass;
var_dump($a instanceof mclass);
var_dump($a instanceof sclass);

L'exemple ci-dessus affichera:

bool(true)
bool(false)

Raison: Exemple ci-dessus $a est un objet de la mclass . mclass données mclass , pas une instance de la sclass

Exemple avec héritage

<?php 
class pclass { } 
class childclass extends pclass { } 
$a = new childclass; 
var_dump($a instanceof childclass); 
var_dump($a instanceof pclass);

L'exemple ci-dessus affichera:

bool(true)
bool(true)

Exemple avec Clone

<?php 
class cloneable { } 
$a = new cloneable;
$b = clone $a; 
var_dump($a instanceof cloneable); 
var_dump($b instanceof cloneable);

L'exemple ci-dessus affichera:

bool(true)
bool(true)

==est utilisé pour vérifier l'égalité sans prendre en compte le type de données variable

===est utilisé pour l' égalité de contrôle pour les deux la variable valeur * et ** type de données

Exemple

$a = 5

1. if ($a == 5) - évaluera à vrai

2. if ($a == '5') - sera évalué à true, car en comparant cette valeur, php convertit en interne cette valeur de chaîne en entier, puis compare les deux valeurs

3. if ($a === 5) - évaluera à vrai

4. if ($a === '5') - sera évalué à false, car la valeur est 5, mais cette valeur 5 n'est pas un entier.

<=> Opérateur de vaisseau spatial

Ajouté en PHP 7

L' opérateur de vaisseau spatial <=> est le dernier opérateur de comparaison ajouté en PHP 7. Il s'agit d'un opérateur binaire non associatif ayant la même priorité que les opérateurs d'égalité ( == != , === !== ). Cet opérateur permet une comparaison tridirectionnelle plus simple entre les opérandes gauche et droit.

L'opérateur résulte en une expression entière de:

• 0 lorsque les deux opérandes sont égaux
• Inférieur à 0 lorsque l'opérande gauche est inférieur à l'opérande droit
• Supérieur à 0 lorsque l'opérande gauche est supérieur à l'opérande droit

par exemple

1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1

Une bonne application pratique de l'utilisation de cet opérateur serait dans les rappels de type comparaison censés renvoyer un entier zéro, négatif ou positif basé sur une comparaison à trois voies entre deux valeurs. La fonction de comparaison transmise à usort est un exemple.

Avant PHP 7, vous écririez ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    if ($a < $b) {
        return -1;
    } elseif ($a > $b) {
        return 1;
    } else {
        return 0;
    }
});

Depuis PHP 7, vous pouvez écrire ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    return $a <=> $b;
});

Null Coalesce Operator php

L'opérateur de coalescence nul (??) a été ajouté à PHP7 pour le cas habituel d'utilisation d'un ternaire avec isset (). Il retourne son premier opérande s'il existe et n'est pas NULL, sinon, il retourne son deuxième opérande, comme dans l'exemple suivant:

$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody'; 

Chaînes PHP: Les chaînes PHP peuvent être spécifiées de quatre manières différentes:

1) Chaînes de devis simples:

$string = 'This is my string'; // print This is my string

2) Cordes à double citation:

$str = 'string';

$string = "This is my $str"; // print This is my string

3) Heredoc:

$string = <<<EOD
This is my string
EOD; // print This is my string

4) Nowdoc (depuis PHP 5.3.0):

$string = <<<'END_OF_STRING'
    This is my string 
END_OF_STRING; // print This is my string

Syntax    Name             Description

x == y    Equality         True if x and y have the same key/value pairs
x != y    Inequality       True if x is not equal to y
x === y   Identity         True if x and y have the same key/value pairs
                            in the same order and of the same types
x !== y   Non-identity     True if x is not identical to y
++ x      Pre-increment    Increments x by one, then returns x
x ++      Post-increment   Returns x, then increments x by one
-- x      Pre-decrement    Decrements x by one, then returns x
x --      Post-decrement   Returns x, then decrements x by one
x and y   And              True if both x and y are true x=6 y=3
                           (x < 10 and y > 1) returns true 
x && y    And              True if both x and y are true x=6 y=3
                           (x < 10 && y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"