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


4481

Qu'est-ce que c'est?

Ceci est une collection de questions qui se posent de temps en temps sur la syntaxe en PHP. Il s'agit également d'un wiki communautaire, 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 autres jetons de syntaxe.¹
L'idée principale est d'avoir des liens vers des questions existantes sur Stack Overflow, il est donc plus facile pour nous de les référencer, de ne pas 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 de guillemets, par exemple[php] "==" vs "==="

Que dois-je faire ici?

Si vous avez été pointé ici par quelqu'un 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. Si c'est le cas, vous êtes encouragé à voter pour la réponse. Cette liste n'est pas destinée à remplacer l'aide fournie par d'autres.

La liste

Si votre jeton particulier n'est pas répertorié ci-dessous, vous le trouverez peut-être dans la liste des jetons de l'analyseur .


& Opérateurs ou références au niveau du bit


=& Références


&= Opérateurs au niveau du bit


&& 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)


?string ?int ?array ?bool ?float Déclaration de type de retour nul (depuis PHP 7.1)


: 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 au niveau du bit


>> Opérateurs au niveau du bit


<< Opérateurs au niveau du 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 au niveau du bit


|| Opérateurs logiques


~ Opérateurs au niveau du bit


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


+=et -= opérateurs d'affectation


++et -- incrémentation / décrémentation des 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 balises


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


** Exponentiation (depuis PHP 5.6)


# Commentaire de style shell sur une ligne


:? Types de retour nullables


?-> Appels d'opérateur NullSafe



36
Je sais que ce n'est pas strictement PHP, mais qu'en est-il de l'inclusion d'un lien vers phpdoc.org pour la syntaxe de commentaire de phpDocumentor, qui est couramment utilisé et qu'il est également impossible de rechercher /**?
Mike

8
Puis-je suggérer des crochets et des crochets?
ajreal

124
J'ai également rencontré ce problème (ne pouvant pas rechercher de caractères spéciaux), c'est pourquoi j'ai créé SymbolHound , un moteur de recherche qui n'ignore pas les caractères spéciaux. Je l'ai également posté sur StackApps .
dncrane

1
Eh bien, de la rubrique Pourquoi est-ce? , Je suppose que c'est parce que "L'idée principale est d'avoir des liens vers des questions existantes sur Stack Overflow, il est donc plus facile pour nous de les référencer".
Herbert

3
Une question a été posée aujourd'hui (Nov.20 / 15) stackoverflow.com/questions/33833259/what-is-rscat-in-php demandé « Qu'est - ce que $ rsCat en php » (si cette question encore être rendue visible et non supprimé) . Curieusement, il n'y a pas de référence sur les $variables, mais $$uniquement sur les variables variables. Je pense que cela devrait être modifié quelque part.
Funk Forty Niner

Réponses:


1172

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

++ opérateur d'incrémentation

-- 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 mis avant la variable, l'opération d' incrément / décrément est fait à la variable première alors le résultat est retourné. 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 ++$i- dessus 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 vraiment la variable et ensuite «retourne» le résultat. Le 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 la seconde.

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

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

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

Une fois zatteint, aac'est le suivant, 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 ainsi, seuls les caractères ASCII simples (az et AZ) sont pris en charge.


Poteaux de débordement de pile:


9
+1 pour la note que les décrémenteurs ne fonctionnent pas sur les caractères, uniquement sur les nombres
Mark Baker

163
Pour le bien de tous, veuillez supprimer les informations en gras indiquant que la pré-incrémentation est infiniment plus rapide. C'est le pire exemple absolu d'optimisation prématurée et ce type d'information ne devrait pas être dans la tête des gens s'ils commencent tout juste à apprendre PHP.
Lotus Notes

14
@Lotus - Je considère que c'est un fait amusant. Si vous êtes un débutant en PHP, ou C ++, etc., il semble assez farfelu que ++ i et i ++ soient suffisamment différents pour fonctionner à des vitesses différentes. Je l'ai trouvé fascinant.
Peter Ajtai

12
@Peter Ajtai Oui, c'est intéressant, mais de la façon dont vous avez structuré votre message, vous le faites apparaître comme l'un des principaux faits de PHP qui est absolument vital pour utiliser le langage.
Lotus Notes

4
Je ne sais pas si c'est juste moi ou non, mais l'exemple de la pomme semble un peu trompeur. «J'ai 10 pommes. Je viens d'en manger une 'me fait croire que vous aviez 11 pommes, mais maintenant vous en avez 10 parce que vous en avez juste mangé plutôt que vous en avez mangé après avoir dit que vous en avez 10, ce qui vous fait en avoir 9 - ce que le code implique.
さ り げ な い 告白

440

Opérateur au niveau du bit

Qu'est-ce qu'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 verrons 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 octet

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

Quelques exemples pour une meilleure compréhension

L'opérateur "ET": &

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

Cela donnerait le chiffre 8. Pourquoi? Voyons voir 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|
------------------------------------------- 

Ainsi, vous pouvez voir dans le tableau que le seul bit qu'ils partagent ensemble est le 8 bits.

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 additionnés, renvoient 36.

L'opérateur "Ou": |

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

Cela donnerait le nombre 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 défini 3 bits, dans les colonnes 8, 2 et 1. Additionnez-les: 8 + 2 + 1 = 11.


6
Et si $ a prend une valeur supérieure à 255?
Aycan Yaşıt

@ AycanYaşıt La plupart du système d'exploitation utilise un système 32 bits et 64 bits, ce qui signifie que la limite est bien supérieure à 255 (8 bits).
AlbertSamuel

@ AycanYaşıt En fait, la représentation ici avec une longueur d'un octet n'est même pas correcte, car même le plus petit entier est toujours 64 bits (8 octets) en mémoire sur une plate-forme 64 bits moderne.
Kaii

Pourquoi and &est 0 0 0 0 1 0 0 0 et or |est 0 0 0 0 1 0 1 1?
Vir

285

<=> 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 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 donne 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
  • Supérieur à 0lorsque l'opérande de gauche est supérieur à 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 zéro, un négatif ou un entier positif sur la base d'une comparaison à trois entre deux valeurs. La fonction de comparaison est passée àusort est un tel exemple.

Avant PHP 7, vous écriviez ...

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

21
Je ne sais pas en quoi $a <=> $best différent de$a - $b
rev

38
@AcidShout $a - $bfonctionne pour les nombres, mais pas pour les chaînes, les objets ou les tableaux.
mcrumley

44
@mcrumley Non, c'est pire que ça. En général, $a - $bne fonctionne même pas pour les chiffres; cela ne fonctionne que pour les entiers . Cela ne fonctionne pas pour les nombres non entiers, car usortconvertit les valeurs de retour de votre fonction de comparaison en int, ce qui signifie que 0,5 est converti en 0, ce qui signifie que deux nombres avec une différence inférieure à 1, tels que 4 et 4,6, peuvent (selon sur lequel on est passé comme premier argument à votre fonction de comparaison) comparer incorrectement comme égal.
Mark Amery

5
@MarkAmery le guide de migration n'est pas le comportement documenté de l'opérateur. Pour cela, vous voulez consulter la section des opérateurs de langue du manuel pour cette comparaison php.net/language.operators.com, le comportement réel derrière cela repose sur diverses fonctions de comparaison de l'API, comme lorsque vous faites strcmp pour les chaînes, où vous ne pouvez pas garantir la valeur de retour réelle dans chaque cas. Bien sûr, c'est presque toujours 1, 0 ou -1, mais pour les cas où vous ne pouvez pas le garantir comme dans l'encapsulation du strcmp de libc, vous offrez le même comportement défini que la spécification sous-jacente pour être sûr
Sherif

9
@MarkAmery Le but ici n'est pas de permettre aux gens de s'appuyer sur un comportement indéfini. Dans le cas où quelqu'un obtient une valeur qui n'est pas exactement 1, 0 ou -1, vous obtenez quelqu'un qui dépose un rapport de bogue en pensant qu'il y a quelque chose de mal dans la langue. C'est pourquoi nous documentons que tout ce que nous pouvons garantir est que la valeur sera inférieure , supérieure ou égale à 0, et pas nécessairement 1, 0 et -1.
Sherif


273
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
x or y     Or              True if any of x or y are true x=6 y=3
                           (x < 10 or y > 10) returns true 
x || y     Or              True if any of x or y are true x=6 y=3
                           (x < 3 || y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"

239

Constantes magiques : bien que ce ne soient pas seulement des symboles mais une partie importante de cette famille de jetons. 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 complet et le nom de fichier du fichier. S'il est utilisé dans une inclusion, 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 anciennes versions, il contenait un chemin relatif dans certaines circonstances.

__DIR__: Le répertoire du fichier. S'il est utilisé dans une inclusion, le répertoire du fichier inclus est renvoyé. C'est équivalent à dirname(__FILE__). Ce nom de répertoire n'a pas de barre oblique de fin sauf s'il s'agit 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 renvoie le nom de la fonction tel qu'il a été déclaré (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 renvoie le nom de classe tel qu'il a été déclaré (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 exemple Foo\Bar). Notez que depuis PHP 5.4 __CLASS__fonctionne é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 renvoie le trait tel qu'il a été déclaré (sensible à la casse). Le nom de trait inclut l'espace de noms dans lequel il a été déclaré (par exemple 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 au moment de la compilation (ajoutée en PHP 5.3.0).

La source


150

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)

Motif: exemple ci - dessus $aest un objet de l' mclassutiliser de manière seulementmclass données et non une instance desclass

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)

7
Ce qui précède fonctionne également avec les «interfaces». Ceci est utile pour vérifier qu'une interface particulière est disponible.
Ryan Vincent

133

Un aperçu des opérateurs en PHP :


Opérateurs logiques:

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

Opérateurs de comparaison:

  • $ a == $ b: TRUE si $ a est égal à $ b après avoir jonglé avec le type.
  • $ a === $ b: TRUE si $ a est égal à $ b et qu'ils sont du même type.
  • $ a! = $ b: TRUE si $ a n'est pas égal à $ b après avoir jonglé avec le type.
  • $ a <> $ b: TRUE si $ a n'est pas égal à $ b après avoir jonglé avec le type.
  • $ a! == $ b: TRUE 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 : VRAI 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 : 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 retour $ b sinon retour $ $ ( opérateur ternaire )
  • $ a ?? $ c : Identique à $ a? $ a: $ c ( opérateur de coalescence nul - nécessite PHP> = 7)

Opérateurs arithmétiques:

  • - $ a : opposé à $ 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 (introduite en PHP 5.6)

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

  • ++ $ a : incrémente $ a d'une unité, puis retourne $ a.
  • $ a ++ : renvoie $ a, puis incrémente $ a d'une unité.
  • - $ a : décrémente $ a d'une unité, puis retourne $ a.
  • $ a-- : renvoie $ a, puis décrémente $ a d'une unité.

Opérateurs au niveau du bit:

  • $ a & $ b : les bits définis à la fois 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 le sont pas et vice versa.
  • $ a << $ b : décale les bits des étapes $ a $ b vers la gauche (chaque étape signifie "multiplier par deux")
  • $ a >> $ b : décale les bits des étapes $ 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 baies:

  • $ 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 du même type.
  • $ 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 : 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

andl'opérateur et l' oropérateur ont une priorité plus faible que l'opérateur d'affectation =.

Cela signifie que cela $a = true and false;équivaut à ($a = true) and false.

Dans la plupart des cas, vous voudrez probablement utiliser &&et ||, qui se comportent d'une manière connue à partir de langages comme C, Java ou JavaScript.


1
Il y a une erreur dans $a ?? $c, il dit que c'est la même chose $a ? $a : $c, mais l'opérateur ternaire vérifie si la valeur est vraie, d'autre part, la coalescence nulle vérifie les valeurs nulles, donc, si $ a est 0, vous obtiendrez 0 (car 0 est non nul), par exemple si vous avez: $a=0; $c=5;puis $a?$a:$cretourne 5, et $a??$crenvoie 0.
stramin

104

Opérateur de vaisseau spatial<=> (ajouté en PHP 7)

Exemples d' <=>opérateur de vaisseau spatial (PHP 7, Source: PHP Manual):

Entiers, flottants, chaînes, tableaux et objets pour la comparaison à trois des variables.

// Integers
echo 10 <=> 10; // 0
echo 10 <=> 20; // -1
echo 20 <=> 10; // 1

// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
// Comparison is case-sensitive
echo "B" <=> "a"; // -1

echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1

// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1

// Objects
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 0

$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "c"]; 
echo $a <=> $b; // -1

$a = (object) ["a" => "c"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 1

// only values are compared
$a = (object) ["a" => "b"]; 
$b = (object) ["b" => "b"]; 
echo $a <=> $b; // 1


74

{} Accolades

Et quelques mots sur le dernier message

$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

4
Notation {''} pour les noms de propriété. echo $ films-> film -> {'grandes lignes'} -> ligne; peut être utilisé pour accéder aux données dans SimpleXMLElement. Peut-être qu'il peut également être utilisé dans d'autres cas. php.net/manual/en/simplexml.examples-basic.php
Andrei

68

Opérateur coalescent nul (??)

Cet opérateur a été ajouté en PHP 7.0 pour le cas courant de besoin d'utiliser un opérateur ternaire en conjonction avec isset(). Il retourne son premier opérande s'il existe et n'est pas NULL; sinon, elle renvoie 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';
?>

64

Chaînes PHP: les chaînes PHP peuvent être spécifiées de quatre manières et non seulement de deux façons:

1) Chaînes de guillemets simples:

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

2) Chaînes de guillemets doubles:

$str = 'string';

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

3) Hérédoc:

$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

@ Rizier123: Que signifie "Heredocs ne peut pas être utilisé pour initialiser les propriétés d'une classe. Depuis PHP 5.3, cette limitation n'est valable que pour les heredocs contenant des variables."?
PHPFan

48

QUESTION:

Que veut =>dire?


RÉPONSE:

=>Est le symbole que nous, les humains, avons décidé d'utiliser pour séparer les "Key" => "Value"paires dans les tableaux associatifs.

ELABORATION:

Pour comprendre cela, nous devons savoir ce que sont les tableaux associatifs. La première chose qui arrive quand 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;

Alors que, 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'indice [0]du tableau est la valeur de l' année 2016, l'indice [1]du tableau est une salutation et l'indice [2]du tableau est une simple valeur entière . L'alternative que nous aurions alors serait 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 était le cas dans la mesure où il incrémente 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 ):

  • En brouillant la déclaration d'un tableau associatif, vous incluez non seulement le valuede ce que vous voulez mettre dans le tableau, mais vous mettez également la valeur d'index (appelée le key) que vous souhaitez utiliser lors de l'appel du tableau dans les parties ultérieures du tableau. code. La syntaxe suivante est utilisée lors de la déclaration de ce: "key" => "value".

  • Lors de l'utilisation du tableau associatif, la keyvaleur serait alors placée à l'intérieur de l'index du tableau pour récupérer le 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 la même sortie 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 l'initiation des valeurs dans le tableau.


36

Question :

Que signifie "&" ici en PHP?

Opérateur PHP "&"

Rend la vie plus facile une fois que nous nous y sommes habitués .. (consultez attentivement l'exemple ci-dessous)

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

avez-vous même remarqué le fonctionnement de ces appels?

   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 trouve un jeu d'opérateurs et de bits au niveau du bit.

Un exemple utile de ces configurations simples est comme donner ci-dessous, donc un seul champ entier peut stocker des milliers de combos pour vous.

La plupart des gens ont déjà lu les documents mais n'ont pas reliacé le cas d'utilisation réel de ces opérateurs au niveau du bit.

Exemple que vous allez adorer

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

30

== est utilisé pour vérifier l'égalité sans tenir compte du type de données variable

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

Exemple

$a = 5

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

  2. if ($a == '5') - sera évalué à vrai, car en comparant ces deux valeurs, 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é à faux, car la valeur est 5, mais cette valeur 5 n'est pas un entier.


27

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

Ce n'est pas le nom le plus accrocheur pour un opérateur, mais PHP 7 apporte la fusion nulle 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 retourne le deuxième élément si cela retourne vrai et le troisième si ce n'est pas le cas:

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

Il y a aussi un raccourci pour cela qui vous permet de sauter le deuxième élément s'il est le même que le premier: echo $ count?: 10; // affiche également 10

En PHP 7, nous obtenons en outre le ?? opérateur qui, plutôt que d'indiquer une confusion extrême, c'est ainsi que j'utiliserais habituellement deux points d'interrogation ensemble, nous permet 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 retourné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 retomber en toute sécurité sur une valeur par défaut donnée si cette configuration est manquante. C'est une sorte de petite fonctionnalité mais c'est une que je sais que j'utiliserai dès que mes applications passeront à PHP 7.


12

Déclaration de type de retour nul

PHP 7 ajoute la prise en charge des déclarations de type de retour. De la même manière que les déclarations de type d'argument, les déclarations de type de retour spécifient le type de valeur qui sera renvoyé par une fonction. Les mêmes types sont disponibles pour les déclarations de type de retour que ceux disponibles pour les déclarations de type d'argument.

Une frappe stricte a également un effet sur les déclarations de type de retour. Dans le mode faible par défaut, les valeurs renvoyées seront contraintes au type correct si elles ne sont pas déjà de ce type. En mode fort, la valeur retournée doit être du type correct, sinon, une TypeError sera levée.

Depuis PHP 7.1.0, les valeurs de retour peuvent être marquées comme nullables en préfixant le nom du type avec un point d'interrogation (?). Cela signifie que la fonction retourne le type spécifié ou NULL.

<?php
function get_item(): ?string {
    if (isset($_GET['item'])) {
        return $_GET['item'];
    } else {
        return null;
    }
}
?>

La source


7

Trois DOTS en tant qu'opérateur Splat (...) (depuis PHP 5.6)

PHP a un opérateur "..." (Trois points) qui est appelé Opérateur Splat. Il est utilisé pour passer un nombre arbitraire de paramètres dans une fonction et ce type de fonction est appelé Fonctions Variadiques. Prenons des exemples d'utilisation de "..." (trois points).

Exemple 1:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

echo calculateNumbers(10, 20, 30, 40, 50);

//Output 150
?>

Chaque argument de la fonction CalculateNumbers () passe par $ params en tant que tableau lors de l'utilisation de "…".

Il existe de nombreuses façons d'utiliser l'opérateur "…". Ci-dessous quelques exemples:

Exemple 2:

<?php
function calculateNumbers($no1, $no2, $no3, $no4, $no5){
    $total = $no1 + $no2 + $no3 + $no4 + $no5;
    return $total;
}

$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers(...$numbers);

//Output 150
?>

Exemple 3:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
$no1 = 70;
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers($no1, ...$numbers);

//Output 220
?>

Exemple 4:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

$numbers1 = array(10, 20, 30, 40, 50);
$numbers2 = array(100, 200, 300, 400, 500);
echo calculateNumbers(...$numbers1, ...$numbers2);

//Output 1650

?>

0

? -> Opérateur NullSafe

Pour l'instant, ce n'est qu'une proposition, vous pouvez la trouver ici . C'est le NullSafe Operator, il revient nullsi vous essayez d'appeler des fonctions ou d'obtenir des valeurs de null... Exemple

$objDrive = null;
$drive = $objDrive?->func?->getDriver()?->value; //return null
$drive = $objDrive->func->getDriver()->value; // Error: Trying to get property 'func' of non-object

Ajouter cela semble plutôt prématuré, personne ne verra cet opérateur dans aucun code en direct, et il pourrait même ne pas être ajouté. Il serait préférable d'attendre que les détails soient finalisés et de les documenter correctement.
IMSoP

Nous recevons déjà des questions à ce sujet. : / Si la proposition échoue, nous pouvons alors décider si cela vaut la peine d'être conservé.
John Conde

@JohnConde voyez? c'est ce que je disais ...
Berto99

@JohnConde Je serais tenté de les fermer comme hors sujet, car ils posent des questions sur un langage de programmation imaginaire; ou peut-être "cette question appartient à une autre partie de la chronologie, veuillez vérifier les paramètres de votre machine à voyager dans le temps";)
IMSoP

lol La pensée m'a traversé l'esprit. Je me suis demandé si cela offrirait de la valeur aux futurs visiteurs et, pour l'instant, la réponse est "oui". Mais cela pourrait changer ...
John Conde

0

Opérateur NullSafe "? ->" (éventuellement) depuis php8

Pour le moment, c'est juste une proposition, vous pouvez la trouver en entrant la description du lien ici . ?->c'est le NullSafe Operator, il revient nullsi vous essayez d'appeler des fonctions ou d'obtenir des valeurs de null...

Exemples:

<?php
$obj = null;
$obj = $obj?->attr; //return null
$obj = ?->funct(); // return null
$obj = $objDrive->attr; // Error: Trying to get property 'attr' of non-object
?>

Ajouter cela semble plutôt prématuré, personne ne verra cet opérateur dans aucun code en direct, et il pourrait même ne pas être ajouté. Il serait préférable d'attendre que les détails soient finalisés et de les documenter correctement.
IMSoP

@IMSoP je suis avec vous, mais j'ai été invité à le faire ici stackoverflow.com/questions/62178354/… ...
Berto99

Il semble que nous ayons maintenant deux réponses à ce sujet. Personnellement, j'aurais simplement voté pour clore l'autre question plutôt que d'essayer d'y répondre, car pour le moment il n'y a pas de tel opérateur.
IMSoP

@IMSoP il y a beaucoup de questions ici sur StackOverflow à propos de la proposition C ++, et elles ne sont pas fermées: malgré cela, je suis avec vous pour ne pas poster ici cet opérateur pour le moment
Berto99

Je ne sais pas grand-chose sur le processus C ++ et quand il est raisonnable de discuter des propositions, et pour être honnête, celui-ci semble assez susceptible de réussir la modification de l'entraînement, mais en général, il existe de nombreuses fonctionnalités proposées pour PHP qui ne parviennent jamais au langue, et il serait plutôt déroutant pour les utilisateurs de les trouver tous dans les listes de référence. Cela dit, je suis en partie juste un vieil homme grincheux ici: P
IMSoP
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.