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

Question

Qu'est-ce que c'est?

Ceci est une collection de questions qui reviennent de temps en temps sur la syntaxe en PHP. Il s’agit également d’un wiki de la communauté. Tous sont invités à participer au maintien de cette liste.

Pourquoi est-ce?

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 le dépassement de pile, 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 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 avec les questions liées répondront probablement à votre question à ce moment-là. Si tel est le cas, vous êtes encouragé à voter en amont de la réponse. Cette liste ne vise pas à remplacer l'aide fournie par les autres.

La liste

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

_&_ Opérateurs sur les bits ou Références

_=&_ Références

_&=_ Opérateurs binaires

_&&_ Opérateurs logiques

_%_ Opérateurs arithmétiques

_!!_ Opérateurs logiques

Opérateur double pas (!!) en PHP

_@_ Opérateurs de contrôle d'erreur

_?:_ Opérateur ternaire

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

L'opérateur de coalescence nul de C # (??) en PHP

_?string_ _?int_ _?array_ _?bool_ _?float_ Déclaration de type de retour nullable (depuis PHP 7.1)

déclaration de type de retour Nullable

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

_::_ Opérateur de résolution d'étendue

_\_ Namespaces

_->_ Classes Et Objets

_=>_ Tableaux

_^_ Opérateurs binaires

_>>_ Opérateurs binaires

Qu'est-ce que >> signifie en PHP?

_<<_ Opérateurs binaires

Comportement étrange en PHP?

_<<<_ Heredoc ou Nowdoc

_=_ Opérateurs d'assignation

Les 3 égaux différents

_==_ 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 binaires

_||_ Opérateurs logiques

_~_ Opérateurs binaires

Qu'est-ce que cet ~ opérateur signifie ici?

_+_ Opérateurs arithmétiques , Opérateurs de tablea

opérateur + pour tableau en PHP?

_+=_ et _-=_ Opérateurs d'assignation

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

_.=_ Opérateurs d'assignation

_._ Opérateurs de chaîne

_,_ Arguments de la fonction

Différence entre point et virgule lors de la concaténation écho/retour?

_,_ Déclarations de variables

Que signifient les virgules dans une déclaration de variable?

_$$_ Variables variables

_`_ Opérateur d'exécution

Quels sont les backticks `` appelés?

_<?=_ Balises ouvertes courtes

_[]_ Tableaux (syntaxe courte depuis PHP 5.4)

_<?_ Balises d'ouverture et de fermeture

Est-ce que PHP balises courtes sont acceptables?

_..._ Décompression de l'argument (depuis PHP 5.6)

_**_ Exponentiation (depuis PHP 5.6)

_#_ Commentaire sur le style shell à une ligne

Puis-je utiliser des hachages pour les commentaires en PHP?

_:?_ types de retour nullables

type d'argument de méthode php faisant allusion avec un point d'interrogation (? type)

Peter Ajtai · Accepted Answer

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

++ opérateur d'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 en premier , puis le résultat est renvoyé. Si elle est placée après la variable, la variable est renvoyée en premier , puis l'opération 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.
"; }

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--, car vous souhaitez d’abord afficher le nombre actuel de pommes, puis , puis vous souhaitez en soustraire un. il.

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 simples ASCII (a-z et A-Z) sont pris en charge.

Messages de débordement de pile:

Comprendre l'incrémentation

Ankur Saxena · Answer

Opérateur binaire

C'est quoi 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 maximale d'un octet est 255, ce qui voudrait dire que chaque bit est activé. 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 mieux comprendre

L'opérateur "AND": `&`

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

Cela produirait le nombre 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| -------------------------------------------

Vous pouvez donc voir sur la table que 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, une fois ajoutés, renvoient 36.

L'opérateur "Ou": `|`

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

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

Habeeb Perwad · Answer

_ Alias pour gettext ()

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

Ankur Saxena · Answer

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"

Sherif · Answer

`<=>` Opérateur de vaisseau spatial

Ajouté dans PHP 7

Le opérateur de vaisseau spatial <=> est le dernier opérateur de comparaison ajouté dans PHP 7. Il s'agit d'un non associatif opérateur binaire ayant la même priorité que les opérateurs d'égalité (==, !=, ===, !==). Cet opérateur permet une comparaison tripartite 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 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 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 en est un exemple.

Avant PHP 7, vous écririez ...

$arr = array(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; });

Sumoanand · Answer

Constantes magiques : Bien qu'il ne s'agisse pas simplement de symboles, mais d'une partie importante de cette famille de jetons. Il y a huit constantes magiques qui changent en fonction de l'endroit où elles sont utilisées.

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

__FILE__: Le chemin complet et le nom 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 versions antérieures, 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é. Ceci équivaut à dirname(__FILE__). Ce nom de répertoire ne comporte pas de barre oblique, sauf s'il s'agit du répertoire racine. (Ajouté dans PHP 5.3.0.)

__FUNCTION__: Le nom de la fonction. (Ajouté dans PHP 4.3.0) À partir de PHP 5, cette constante renvoie le nom de la fonction telle qu'elle a été déclarée (sensible à la casse). Dans PHP 4, sa valeur est toujours en minuscule.

__CLASS__: Le nom de la classe. (Ajouté dans PHP 4.3.0) À partir de PHP 5, cette constante renvoie le nom de la classe telle qu'elle a été déclarée (sensible à la casse). Dans PHP 4, sa valeur est toujours en minuscule. Le nom de la classe inclut l'espace de noms dans lequel il a été déclaré (par exemple, Foo\Bar). Notez qu'à partir de 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 de la caractéristique. (Ajouté dans PHP 5.4.0) À partir de 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 nom dans lequel il a été déclaré (par exemple, Foo\Bar).

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

__NAMESPACE__: Nom de l'espace de nom actuel (sensible à la casse). Cette constante est définie au moment de la compilation (ajoutée à PHP 5.3.0).

Source

Maulik patel · Answer

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)

Reason: Exemple ci-dessus $a est un objet de mclass, utilisez donc uniquement une donnée mclass dont l'instance n'est pas 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)

John Slegers · Answer

Un aperçu des opérateurs en PHP :

opérateurs logiques:

$ a && $ b: VRAI si $ a et $ b sont VRAI.
$ a || $ b: VRAI si $ a ou $ b est VRAI.
$ a xor $ 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 $ 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: VRAI 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 : TRUE 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 : 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 de fusion 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 jusqu'au pouvoir $ b'th (introduit dans PHP 5.6)

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

++ $ a : Incrémente $ a par 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 sur les bits:

$ 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 sont pas définis, et inversement.
$ a << $ b : décale les bits de $ a $ b pas à gauche (chaque pas signifie "multiplie 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 : VRAI 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 : TRUE si $ a n'est pas égal à $ b.
$ a <> $ b : VRAI 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

Les opérateurs and et or ont une priorité inférieure à 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 comporte d'une manière connue des langages tels que C, Java ou JavaScript.

rajangupta · Answer

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

Exemples pour <=> Opérateur de vaisseau spatial (PHP 7, Source: PHP Manuel):

Entiers, flotteurs, chaînes, tableaux et objets pour la comparaison tridirectionnelle de 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

mnv · Answer

{} Accolades

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

VIPIN A ROY · Answer

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

devpro · Answer

PHP Strings: PHP Les chaînes peuvent être spécifiées de quatre manières différentes, pas seulement de deux manières:

1) Chaînes de devis simples:

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

2) Double Quote Strings:

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

) 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

Webeng · Answer

QUESTION:

Que signifie =>?

REPONSE:

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

ELABORATION:

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 année 2016, l'index [1] du tableau est un - greetings, et l'index [2] du tableau est un simple valeur entière. L'alternative que nous aurions alors est 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 puisqu'il incrémente l'indice utilisé dans une séquence prédéterminée, par incrémentation 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 le value de ce que vous voulez mettre dans le tableau, vous mettez également la valeur d'index (appelée key) que vous voulez utiliser. utiliser lors de l'appel du tableau dans les parties ultérieures du code. La syntaxe suivante est utilisée lors de la déclaration: "key" => "value".
Lors de l'utilisation du tableau associatif, la valeur key serait alors placée dans l'index du tableau pour extraire le value souhaité.

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 valeur key serait utilisée dans l'index des tableaux:

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

FINAL POINT:

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 key et value d'un tableau - PENDANT l'initiation des valeurs dans le tableau.

dev.meghraj · Answer

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 que 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 "
"; } 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

Parth Nayak · Answer

== est utilisé pour vérifier l’égalité sans considérant la variable type de données

=== est utilisé pour vérifier l'égalité pour les deux la variable valeur * et ** type de données

Exemple

$a = 5

if ($a == 5) - sera évalué à true
if ($a == '5') - sera évalué à true, car lors de la comparaison, php convertit en interne cette valeur de chaîne en entier, puis compare les deux valeurs.
if ($a === 5) - sera évalué à true
if ($a === '5') - sera évalué à false, car la valeur est 5, mais cette valeur 5 n'est pas un entier.

mshomali · Answer

Opérateur NULL Coalesce php

L'opérateur de fusion nul (??) a été ajouté à PHP7 pour le cas habituel d'utilisation d'un ternaire conjointement 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';

Yogi Ghorecha · Answer

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

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

Dans 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

Dans PHP 7, nous obtenons également le ?? L’opérateur qui, plutôt que d’indiquer une confusion extrême, c’est comme cela que j’utilise habituellement deux points d’interrogation, nous permet plutôt de chaîner ensemble 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 pour revenir en toute sécurité à une valeur par défaut donnée si cette configuration est manquante. C’est un peu une petite fonctionnalité, mais je sais que je vais l’utiliser dès que mes applications passeront à PHP 7.

John Conde · Answer

Déclaration de type de retour Nullable

PHP 7 ajoute le support pour les 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 pour les déclarations de type d'argument.

Le typage strict a également un effet sur les déclarations de type de retour. Dans le mode faible par défaut, les valeurs renvoyées seront forcées dans le type correct si elles ne sont pas déjà de ce type. En mode fort, la valeur renvoyée doit être du type correct, sinon une erreur TypeError sera générée.

À partir de PHP 7.1.0, les valeurs renvoyées peuvent être marquées comme nullables en préfixant le nom du type d'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; } } ?>

Source

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

Qu'est-ce que c'est?

Pourquoi est-ce?

Que dois-je faire ici?

La liste

Opérateur binaire

Quelques exemples pour mieux comprendre

L'opérateur "AND": &

L'opérateur "Ou": |

<=> Opérateur de vaisseau spatial

Ajouté dans PHP 7

Avant PHP 7, vous écririez ...

Depuis PHP 7, vous pouvez écrire ...

Opérateurs de type

Exemple avec héritage

Exemple avec Clone

Un aperçu des opérateurs en PHP :

Remarque

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

opérateur PHP "&"

Exemple que vous allez aimer

Exemple

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

Déclaration de type de retour Nullable

L'opérateur "AND": `&`

L'opérateur "Ou": `|`

`<=>` Opérateur de vaisseau spatial

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