PHP opérateur ternaire null vs la coalescence de l'opérateur

Lors de votre premier argument est nul, ils sont fondamentalement les mêmes, sauf que la valeur null coalescence de ne pas sortir un E_NOTICE lorsque vous avez une variable non définie. Le PHP 7.0 migration docs a ceci à dire:

Le nul de la coalescence de l'opérateur (??) a été ajouté en tant que sucre syntaxique
pour le cas courant d'avoir besoin d'utiliser un ternaire en conjonction avec
la fonction isset(). Elle renvoie son premier opérande si elle existe et n'est pas NULLE;
sinon, elle retourne sa deuxième opérande.

Voici un exemple de code pour le démontrer:

<?php

$a = null;

print $a ?? 'b'; //b
print "\n";

print $a ?: 'b'; //b
print "\n";

print $c ?? 'a'; //a
print "\n";

print $c ?: 'a'; //Notice: Undefined variable: c in /in/apAIb on line 14
print "\n";

$b = array('a' => null);

print $b['a'] ?? 'd'; //d
print "\n";

print $b['a'] ?: 'd'; //d
print "\n";

print $b['c'] ?? 'e'; //e
print "\n";

print $b['c'] ?: 'e'; //Notice: Undefined index: c in /in/apAIb on line 33
print "\n";

Les lignes qui ont les avis sont ceux où je suis en utilisant le raccourci opérateur ternaire, par opposition à la nulle la coalescence de l'opérateur. Cependant, même avec l'avis, PHP va donner la même réponse en retour.

Exécuter le code: https://3v4l.org/McavC

Bien sûr, c'est toujours en supposant que le premier argument est null. Lorsqu'il n'est plus nulle, alors vous vous retrouvez avec des différences dans la ?? opérateur retourne toujours le premier argument alors que le ?: abréviation voudrais seulement si le premier argument est le truthy, et qui repose sur la façon dont PHP serait-type-cast choses à un booléen.

Donc:

$a = false ?? 'f';
$b = false ?: 'g';

aurait alors $a être égal à false et $b égal à 'g'.

La différence majeure est que

1. Opérateur ternaire expression expr1 ?: expr3 retourne expr1 si expr1 évalue à
   TRUE mais d'un autre côté Null Coalescence Opérateur expression (expr1) ?? (expr2)
   évalue à expr1 si expr1 est pas NULL

2. Ternaire
   Opérateur expr1 ?: expr3 émettent un avis si la gauche
   valeur (expr1) n'existe pas mais d'un autre côté Null Coalescence Opérateur (expr1) ?? (expr2) En particulier, n'émet pas un avis si le côté gauche de la valeur (expr1) n'
   n'existe pas, tout comme isset().

3. TernaryOperator est associativité à gauche

   ((true ? 'true' : false) ? 't' : 'f');

   Null Coalescence Opérateur est droit associatif

   ($a ?? ($b ?? $c));

Maintenant permet d'expliquer la différence entre par exemple :

Opérateur Ternaire (?:)

$x='';
$value=($x)?:'default';
var_dump($value);

//The above is identical to this if/else statement
if($x){
  $value=$x;
}
else{
  $value='default';
}
var_dump($value);

Null Coalescence Opérateur (??)

$value=($x)??'default';
var_dump($value);

//The above is identical to this if/else statement
if(isset($x)){
  $value=$x;
}
else{
  $value='default';
}
var_dump($value);

Voici le tableau qui expliquent la différence et la similitude entre '??' et ?:

Note spéciale : null coalescence de l'opérateur et l'opérateur ternaire est une
d'expression, et qu'il n'a pas d'évaluer à une variable, mais à la
résultat d'une expression. C'est important de savoir si vous voulez
de retour d'une variable par référence. L'instruction return $foo ?? $bar; et
return $var == 42 ? $a : $b; dans un retour par référence en fonction de
donc pas de travail et un avertissement est émis.

Deux d'entre eux se comportent différemment quand il s'agit de dynamique de traitement des données.

Si la variable est vide ( " ) null la coalescence permettra de traiter la variable comme vrai, mais l'abréviation opérateur ternaire ne sera pas. Et c'est quelque chose à avoir à l'esprit.

$a = NULL;
$c = '';

print $a ?? '1b';
print "\n";

print $a ?: '2b';
print "\n";

print $c ?? '1d';
print "\n";

print $c ?: '2d';
print "\n";

print $e ?? '1f';
print "\n";

print $e ?: '2f';

Et la sortie:

1b
2b

2d
1f

Notice: Undefined variable: e in /in/ZBAa1 on line 21
2f

Lien: https://3v4l.org/ZBAa1

Faites défiler vers le bas sur cette lien et la vue de la section, il vous donne un comparatif exemple comme ci-dessous:

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

Cependant, il n'est pas conseillé de la chaîne d'opérateurs, il est plus difficile de comprendre le code lors de la lecture plus tard.

Le nul de la coalescence de l'opérateur (??) a été ajouté en tant que sucre syntaxique pour le cas courant d'avoir besoin d'utiliser un ternaire en conjonction avec la fonction isset(). Elle renvoie son premier opérande si elle existe et n'est pas NULLE; sinon, elle renvoie son deuxième opérande.

Essentiellement, à l'aide de la coalescence de l'opérateur permettra de faire de l'auto de vérifier la valeur null à la différence de l'opérateur ternaire.

Pour les débutants:

Null coalescence de l'opérateur (??)

Tout est vrai, sauf null des valeurs et de l'indéfini (variable/index de tableau/les attributs de l'objet)

ex:

$array = [];
$object = new stdClass();

var_export (false ?? 'second');                           # false
var_export (true  ?? 'second');                           # true
var_export (null  ?? 'second');                           # 'second'
var_export (''    ?? 'second');                           # ""
var_export ('some text'    ?? 'second');                  # "some text"
var_export (0     ?? 'second');                           # 0
var_export ($undefinedVarible ?? 'second');               # "second"
var_export ($array['undefined_index'] ?? 'second');       # "second"
var_export ($object->undefinedAttribute ?? 'second');     # "second"

c'est essentiellement la vérification de la variable(index de tableau, objet, attribut, etc...) est d'exister et de ne pas null. semblable à isset fonction

Opérateur ternaire abrégée (?:)

toutes les choses fausses (false,null,0,chaîne vide) sont venus comme faux, mais si c'est un indéfini proviennent, elles aussi, comme faux, mais Notice va jeter

ex

$array = [];
$object = new stdClass();

var_export (false ?: 'second');                           # "second"
var_export (true  ?: 'second');                           # true
var_export (null  ?: 'second');                           # "second"
var_export (''    ?: 'second');                           # "second"
var_export ('some text'    ?? 'second');                  # "some text"
var_export (0     ?: 'second');                           # "second"
var_export ($undefinedVarible ?: 'second');               # "second" Notice: Undefined variable: ..
var_export ($array['undefined_index'] ?: 'second');       # "second" Notice: Undefined index: ..
var_export ($object->undefinedAttribute ?: 'second');     # "Notice: Undefined index: ..

Espère que cette aide

Null Coalescing operator effectue seulement deux tâches: il vérifie whether the variable is set et whether it is null. Regardez l'exemple suivant:

<?php
# case 1:
$greeting = 'Hola';
echo $greeting ?? 'Hi There'; # outputs: 'Hola'

# case 2:
$greeting = null;
echo $greeting ?? 'Hi There'; # outputs: 'Hi There'

# case 3:
unset($greeting);
echo $greeting ?? 'Hi There'; # outputs: 'Hi There'

Le code ci-dessus exemple stipule que Null Coalescing operator traite un non-existant variable et d'une partie variable qui est définie à NULL de la même manière.

Null Coalescing operator est une amélioration par rapport à la ternary operator. Regardez l'extrait de code suivant en comparant les deux:

<?php /* example: checking for the $_POST field that goes by the name of 'fullname'*/
# in ternary operator
echo "Welcome ", (isset($_POST['fullname']) && !is_null($_POST['fullname']) ? $_POST['fullname'] : 'Mr. Whosoever.'); # outputs: Welcome Mr. Whosoever.
# in null coalecing operator
echo "Welcome ", ($_POST['fullname'] ?? 'Mr. Whosoever.'); # outputs: Welcome Mr. Whosoever.

Donc, la différence entre les deux est que Null Coalescing operator opérateur est conçu pour gérer des variables non définies mieux que le ternary operator. Attendu que, le ternary operator est un raccourci pour if-else.

Null Coalescing operator n'est pas destiné à remplacer ternary operator, mais dans certains cas d'utilisation, comme dans l'exemple ci-dessus, il vous permet d'écrire du code propre avec moins de tracas.

Crédits: http://dwellupper.io/post/6/php7-null-coalescing-operator-usage-and-examples