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


Qu'est-ce que c'est?

Ceci est une collection de questions qui se posent de temps en temps sur la syntaxe en PHP. Ceci est également un wiki communautaire, donc tout le monde est invité à participer à la maintenance de cette liste.

Pourquoi est-ce?

Il était difficile de trouver des questions sur les opérateurs et autres jetons de syntaxe.
L'idée principale est d'avoir des liens vers des questions existantes sur Stack Overflow, donc il est plus facile pour nous de les référencer, pas de copier du contenu du manuel PHP.

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

Que devrais-je faire ici?

Si vous avez été désigné par quelqu'un parce que vous avez posé une telle question, veuillez trouver la syntaxe particulière ci-dessous. Les pages liées à la Manuel PHP avec les questions liées répondra probablement à votre question alors. Si c'est le cas, vous êtes encouragé à modifier la réponse. Cette liste n'est pas destinée à remplacer l'aide fournie par les autres.

La liste

Si votre jeton n'est pas répertorié ci-dessous, vous pouvez le trouver dans le Liste des jetons d'analyseur.


&  Opérateurs bit à bit ou Les références


=&  Les références


&=  Opérateurs bit à bit


&&  Opérateurs logiques


%  Opérateurs arithmétiques


!!  Opérateurs logiques


@  Opérateurs de contrôle d'erreur


?:  Opérateur ternaire


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


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


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


\  Espaces de noms


->  Classes et objets


=>  Tableaux


^  Opérateurs bit à bit


>>  Opérateurs bit à bit


<<  Opérateurs bit à bit


<<<  Heredoc ou Nowdoc


=  Opérateurs d'affectation


==  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érateurs bit à bit


||  Opérateurs logiques


~  Opérateurs bit à bit


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


+= et -=  Opérateurs d'affectation


++ et --  Incrémenter / décrémenter les opérateurs


.=  Opérateurs d'affectation


.  Opérateurs de chaîne


,  Arguments de fonction

,  Déclarations variables


$$  Variables variables


`  Opérateur d'exécution


<?=  Balises ouvertes courtes


[]  Tableaux (syntaxe courte depuis PHP 5.4)


<?  Ouverture et fermeture des tags


...  Argument déballage (depuis PHP 5.6)


**  Exponentiation (depuis PHP 5.6)


#  Commentaire shell d'une ligne



3785


origine


Réponses:


Incrémenter / décrémenter les opérateurs

++ incrément opérateur

-- 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 incrément / décrément est effectuée sur la variable premier alors le résultat est retourné. Si mis après la variable, la variable est premier renvoyé, l'opération d'incrémentation / décrémentation est terminé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.

Le pré-incrément est un peu plus rapide, car il incrémente vraiment la variable et après cela "renvoie" le résultat. Post-incrément crée une variable spéciale, y copie la valeur de la première variable et seulement après que la première variable est utilisée, remplace sa valeur par une seconde.

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

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

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

Une fois que z est atteint aa est la prochaine, et ainsi de suite.

Notez que les variables de caractères peuvent être incrémentées mais pas décrémentées et même que seuls les caractères ASCII (a-z et A-Z) sont pris en charge.


Poteaux de dépassement de pile:


947



Opérateur bit à bit

Quel est un peu? Un bit est une représentation de 1 ou 0. Fondamentalement OFF (0) et ON (1)

Qu'est-ce qu'un octet? Un octet est composé de 8 bits et la valeur la plus élevée d'un octet est 255, ce qui signifie que chaque bit est défini. Nous allons voir pourquoi la valeur maximale d'un octet est 255.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------

Cette représentation de 1 Byte

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255 (1 octet)

Quelques exemples pour mieux comprendre

L'opérateur "ET": &

$a =  9;
$b = 10;
echo $a & $b;

Cela produirait le numéro 8. Pourquoi? Eh bien, voyons en utilisant notre exemple de table.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      &     |   0|  0|  0|  0| 1| 0| 0| 0|
------------------------------------------- 

Donc, vous pouvez voir à partir de la table le seul bit qu'ils partagent ensemble est le bit 8.

Deuxième exemple

$a =  36;
$b = 103;
echo $a & $b; // This would output the number 36.
$a = 00100100
$b = 01100111

Les deux bits partagés sont 32 et 4, qui, lorsqu'ils sont ajoutés ensemble, renvoient 36.

L'opérateur "Ou": |

$a =  9;
$b = 10;
echo $a | $b;

Cela produirait le numéro 11. Pourquoi?

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      |     |   0|  0|  0|  0| 1| 0| 1| 1|
-------------------------------------------

Vous remarquerez que nous avons 3 bits, dans les colonnes 8, 2 et 1. Ajoutez-les: 8 + 2 + 1 = 11.


359



_  Alias ​​pour gettext () 

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


224



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"

209



Constantes magiques: Bien que ce ne sont pas seulement des symboles mais une partie importante de cette famille symbolique. Il y a huit constantes magiques qui changent selon l'endroit où elles sont utilisées.

__LINE__: Le numéro de ligne actuel du fichier.

__FILE__: Le chemin d'accès complet et le nom de fichier du fichier. S'il est utilisé dans un include, le nom du fichier inclus est renvoyé. Depuis PHP 4.0.2, __FILE__ contient toujours un chemin absolu avec des liens symboliques résolus alors que dans les versions plus anciennes, il contenait un chemin relatif dans certaines circonstances.

__DIR__: Le répertoire du fichier. S'il est utilisé dans un include, le répertoire du fichier inclus est renvoyé. Ceci est équivalent à dirname(__FILE__). Ce nom de répertoire n'a pas de barre oblique à moins qu'il ne s'agisse du répertoire racine. (Ajouté en PHP 5.3.0.)

__FUNCTION__: Le nom de la fonction. (Ajouté en PHP 4.3.0) Depuis PHP 5 cette constante retourne le nom de la fonction telle qu'elle a été déclarée (sensible à la casse). En PHP 4, sa valeur est toujours en minuscules.

__CLASS__: Le nom de la classe. (Ajouté en PHP 4.3.0) Depuis PHP 5 cette constante retourne le nom de la classe telle qu'elle a été déclarée (sensible à la casse). En PHP 4, sa valeur est toujours en minuscules. Le nom de classe inclut l'espace de noms dans lequel il a été déclaré (par ex. Foo\Bar). Notez que depuis PHP 5.4 __CLASS__ travaille également dans les traits. Lorsqu'il est utilisé dans une méthode de trait, __CLASS__ est le nom de la classe dans laquelle le trait est utilisé.

__TRAIT__: Le nom du trait. (Ajouté en PHP 5.4.0) Depuis PHP 5.4 cette constante retourne le trait tel qu'il a été déclaré (sensible à la casse). Le nom du trait comprend l'espace de noms dans lequel il a été déclaré (par ex. Foo\Bar).

__METHOD__: Le nom de la méthode de classe. (Ajouté en PHP 5.0.0) Le nom de la méthode est retourné tel qu'il a été déclaré (sensible à la casse).

__NAMESPACE__: Le nom de l'espace de noms actuel (sensible à la casse). Cette constante est définie dans la compilation (Ajout en PHP 5.3.0).

La source


194



<=> Opérateur de vaisseau spatial

Ajouté en PHP 7

le opérateur de vaisseau spatial  <=> est le dernier opérateur de comparaison ajouté en PHP 7. C'est un non associatif opérateur binaire avec la même priorité que les opérateurs d'égalité (==, !=, ===, !==). Cet opérateur permet une comparaison à trois voies plus simple entre les opérandes de gauche et de droite.

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

  • 0 lorsque les deux opérandes sont égaux
  • Moins que 0 lorsque l'opérande de gauche est inférieur à l'opérande de droite
  • Plus grand que 0 lorsque l'opérande de gauche est plus grand que l'opérande de droite

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 qui devraient renvoyer un entier nul, 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 écrivez ...

$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;
});

188



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 va afficher:

bool(true)
bool(false)

Raison: Exemple ci-dessus $a est un objet de mclass alors utilisez seulement un mclass données non instance de avec le 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 va afficher:

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 va afficher:

bool(true)
bool(true)

120



Un aperçu de opérateurs en PHP:


Opérateurs logiques:

  • $ a && $ b: VRAI si à la fois $ a et $ b sont VRAIES.
  • $ a || $ b: VRAI si $ a ou $ b est VRAI.
  • $ a x ou $ b: VRAI si $ a ou $ b est VRAI, mais pas les deux.
  • ! $ a: VRAI si $ a n'est pas VRAI.
  • $ a et $ b: VRAI si à la fois $ a et $ b sont VRAIES.
  • $ 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: VRAI si $ a est égal à $ b, et 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 : TRUE si $ a est strictement inférieur à $ b.
  • $ a> $ b : TRUE si $ a est strictement supérieur à $ b.
  • $ a <= $ b : TRUE si $ a est inférieur ou égal à $ b.
  • $ a> = $ b : TRUE si $ a est supérieur ou égal à $ b.
  • $ a <=> $ b : Entier inférieur à, égal à ou supérieur à zéro lorsque $ a est respectivement inférieur, égal ou supérieur à $ b. Disponible depuis PHP 7.
  • $ a? $ b: $ c : si $ a return $ b sinon retourne $ c (opérateur ternaire)
  • $ a ?? $ c : Idem que $ a? $ a: $ c (opérateur de coalescence null - nécessite PHP> = 7)

Opérateurs arithmétiques:

  • - $ a : En face de $ a.
  • $ a + $ b : Somme de $ a et $ b.
  • $ a - $ b : Différence de $ 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 l'augmentation de $ a à la puissance $ b'th (introduit en PHP 5.6)

Incrémenter / décrémenter les opérateurs:

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

Opérateurs bit à bit:

  • $ a et $ 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 pas les deux sont définis.
  • ~ $ a : Les bits définis dans $ a ne sont pas définis et vice versa.
  • $ a << $ b : Décale les bits de $ a $ b vers la gauche (chaque étape signifie "multiplier par deux")
  • $ a >> $ b : Décale les bits de $ a $ b vers la droite (chaque étape 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 : TRUE si $ a et $ b ont les mêmes paires clé / valeur dans le même ordre et les mêmes types.
  • $ a! = $ b : TRUE si $ a n'est pas égal à $ b.
  • $ a <> $ b : TRUE si $ a n'est pas égal à $ b.
  • $ a! == $ b : TRUE si $ a n'est pas identique à $ b.

Opérateurs d'affectation:

  • $ a = $ b : La valeur de $ b est affectée à $ a
  • $ a + = $ b : Idem que $ a = $ a + $ b
  • $ a - = $ b : Idem que $ a = $ a - $ b
  • $ a * = $ b : Idem que $ a = $ a * $ b
  • $ a / = $ b : Idem que $ a = $ a / $ b
  • $ a% = $ b : Idem que $ a = $ a% $ b
  • $ a ** = $ b : Idem que $ a = $ a ** $ b
  • $ a. = $ b : Idem que $ a = $ a. $ b
  • $ a & = $ b : Idem que $ a = $ a & $ b
  • $ a | = $ b : Idem que $ a = $ a | $ b
  • $ a ^ = $ b : Idem que $ a = $ a ^ $ b
  • $ a << = $ b : Idem que $ a = $ a << $ b
  • $ a >> = $ b : Idem que $ a = $ a >> $ b

Remarque

and opérateur et or l'opérateur a une priorité inférieure à celle de l'opérateur d'affectation =.

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 de langages comme C, Java ou JavaScript.


96