variable Référence-Que signifie ce symbole en PHP?




reference function php (14)

Un aperçu des opérateurs en PHP :

Opérateurs logiques:

  • $ a && $ b: VRAI si $ a et $ b sont VRAI.
  • $ a || $ b: TRUE si $ a ou $ b est TRUE.
  • $ a xor $ b: TRUE si $ a ou $ b est TRUE, mais pas les deux.
  • ! $ a: TRUE si $ a n'est pas TRUE.
  • $ a et $ b: VRAI si $ a et $ b sont VRAI.
  • $ a ou $ b: VRAI si $ a ou $ b est VRAI.

Opérateurs de comparaison:

  • $ a == $ b: VRAI si $ a est égal à $ b après le jonglage de type.
  • $ a === $ b: TRUE si $ a est égal à $ b et qu’ils sont du même type.
  • $ a! = $ b: VRAI si $ a n'est pas égal à $ b après le jonglage de type.
  • $ a <> $ b: VRAI si $ a n'est pas égal à $ b après le jonglage de type.
  • $ a! == $ b: VRAI si $ a n'est pas égal à $ b, ou s'ils ne sont pas du même type.
  • $ a <$ b : VRAI si $ a est strictement inférieur à $ b.
  • $ a> $ b : TRUE si $ a est strictement supérieur à $ b.
  • $ a <= $ b : VRAI si $ a est inférieur ou égal à $ b.
  • $ a> = $ b : VRAI si $ a est supérieur ou égal à $ b.
  • $ a <=> $ b : Un entier inférieur, égal ou supérieur à zéro lorsque $ a est respectivement inférieur, égal ou supérieur à $ b. Disponible à partir de PHP 7.
  • $ a? $ b: $ c : si $ a return $ b sinon return $ c ( opérateur ternaire )
  • $ a ?? $ c : Identique à $ a? $ a: $ c ( opérateur coalescent nul - requiert PHP> = 7)

Opérateurs arithmétiques:

  • - $ a : Inverse de $ a.
  • $ a + $ b : somme de $ a et $ b.
  • $ a - $ b : Différence entre $ a et $ b.
  • $ a * $ b : produit de $ a et $ b.
  • $ a / $ b : quotient de $ a et $ b.
  • $ a% $ b : Reste de $ a divisé par $ b.
  • $ a ** $ b : Résultat de la levée de $ a au pouvoir en $ bth (introduit en PHP 5.6)

Opérateurs d'incrémentation / décrémentation:

  • ++ $ a : Incrémente $ a de un, puis retourne $ a.
  • $ a ++ : retourne $ a, puis incrémente $ a de un.
  • - $ a : Décrémente $ a par un, puis retourne $ a.
  • $ a-- : retourne $ a, puis décrémente $ a par un.

Opérateurs binaires:

  • $ a & $ b : les bits définis dans $ a et $ b sont définis.
  • $ a | $ b : les bits définis dans $ a ou $ b sont définis.
  • $ a ^ $ b : les bits définis dans $ a ou $ b mais les deux ne sont pas définis.
  • ~ $ a : Les bits définis dans $ a ne le sont pas et vice versa.
  • $ a << $ b : décale les bits de $ a $ b pas à gauche (chaque pas signifie "multiplier par deux")
  • $ a >> $ b : décale les bits de $ a $ b pas à droite (chaque pas signifie "diviser par deux")

Opérateurs de chaîne:

  • $ a. $ b : Concaténation de $ a et $ b.

Opérateurs de tableau:

  • $ a + $ b : Union de $ a et $ b.
  • $ a == $ b : TRUE si $ a et $ b ont les mêmes paires clé / valeur.
  • $ a === $ b : VRAI si $ a et $ b ont les mêmes paires clé / valeur dans le même ordre et du même type.
  • $ a! = $ b : VRAI si $ a n'est pas égal à $ b.
  • $ a <> $ b : TRUE si $ a n'est pas égal à $ b.
  • $ a! == $ b : VRAI si $ a n'est pas identique à $ b.

Opérateurs d'assignation:

  • $ a = $ b : la valeur de $ b est assignée à $ a
  • $ a + = $ b : Identique à $ a = $ a + $ b
  • $ a - = $ b : Identique à $ a = $ a - $ b
  • $ a * = $ b : identique à $ a = $ a * $ b
  • $ a / = $ b : Identique à $ a = $ a / $ b
  • $ a% = $ b : Identique à $ a = $ a% $ b
  • $ a ** = $ b : Identique à $ a = $ a ** $ b
  • $ a. = $ b : Identique à $ a = $ a. $ b
  • $ a & = $ b : Identique à $ a = $ a & $ b
  • $ a | = $ b : Identique à $ a = $ a | $ b
  • $ a ^ = $ b : Identique à $ a = $ a ^ $ b
  • $ a << = $ b : Identique à $ a = $ a << $ b
  • $ a >> = $ b : Identique à $ a = $ a >> $ b

Remarque

and operator et or operator ont une priorité inférieure à celle de l'opérateur d'assignation = .

Cela signifie que $a = true and false; est équivalent à ($a = true) and false .

Dans la plupart des cas, vous voudrez probablement utiliser && et || , qui se comportent d’une manière connue des langages tels que C, Java ou JavaScript.

Qu'est-ce que c'est?

Ceci est une collection de questions qui reviennent de temps en temps sur la syntaxe en PHP. C’est aussi un wiki de la communauté, donc tout le monde est invité à participer au maintien de cette liste.

Pourquoi est-ce?

Auparavant, il était difficile de trouver des questions sur les opérateurs et les autres jetons de syntaxe.¹
L'idée principale est d'avoir des liens vers des questions existantes sur Stack Overflow, afin de nous permettre de les référencer plus facilement, sans copier le contenu du manuel PHP.

¹ Remarque: depuis janvier 2013, Stack Overflow prend en charge les caractères spéciaux . Entourez simplement les termes de recherche entre guillemets, par exemple [php] "==" vs "==="

Que dois-je faire ici?

Si quelqu'un vous a indiqué ici parce que vous avez posé une telle question, veuillez trouver la syntaxe particulière ci-dessous. Les pages liées au manuel PHP ainsi que les questions liées répondront probablement à votre question à ce moment-là. Si tel est le cas, vous êtes invité à relire la réponse. Cette liste ne vise pas à remplacer l'aide fournie par les autres.

La liste

Si votre jeton ne figure pas dans la liste ci-dessous, vous pouvez le trouver dans la liste des jetons d’analyseur .

Opérateurs ou References niveau du bit

=& References

&= Opérateurs sur les bits

&& Opérateurs logiques

% opérateurs arithmétiques

!! Opérateurs logiques

@ Opérateurs de contrôle d'erreur

?: Opérateur ternaire

?? Opérateur NULL Coalesce (depuis PHP 7)

: Syntaxe alternative pour les structures de contrôle , opérateur ternaire

:: Opérateur de résolution de portée

\ Namespaces

-> Classes Et Objets

=> Arrays

^ Opérateurs bit à bit

>> Opérateurs bit à bit

<< Opérateurs de bits

<<< Heredoc ou Nowdoc

= Opérateurs d'assignation

== Opérateurs de comparaison

=== Opérateurs de comparaison

!== Opérateurs de comparaison

!= Opérateurs de comparaison

<> Opérateurs de comparaison

<=> Opérateurs de comparaison (depuis PHP 7.0)

  • Opérateur de vaisseau spatial (comparaison à trois voies)

| Opérateurs de bits

|| Opérateurs logiques

~ Opérateurs de bits

+ Opérateurs arithmétiques , Opérateurs de tableaux

+= et -= opérateurs d'assignation

++ et -- Opérateurs d'incrémentation / décrémentation

.= Opérateurs d'assignation

. Opérateurs de cordes

, Arguments de fonction

, Déclarations variables

$$ variables variables

` exécution

<?= Tags ouverts courts

[] Arrays (syntaxe courte depuis PHP 5.4)

<? Balises d'ouverture et de fermeture

... Déballage des arguments (depuis PHP 5.6)

** Exponentiation (depuis PHP 5.6)

# Commentaire en ligne de commande


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';
?>


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.



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:


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"




php-5.3