Может ли кто-нибудь объяснить различия между сокращением тернарных операторов (?:
) и нулевым коалесцирующим оператором (??
) в PHP?
Когда они ведут себя по-разному и когда одинаково (если это происходит)?
$a ?: $b
VS.
$a ?? $b
Может ли кто-нибудь объяснить различия между сокращением тернарных операторов (?:
) и нулевым коалесцирующим оператором (??
) в PHP?
Когда они ведут себя по-разному и когда одинаково (если это происходит)?
$a ?: $b
VS.
$a ?? $b
Когда ваш первый аргумент равен нулю, они в основном одинаковы, за исключением того, что объединение с нулем не будет выводить E_NOTICE
, когда у вас есть неопределенная переменная. Документация по миграции на PHP 7.0 содержит следующее:
Нулевой оператор объединения (??) был добавлен как синтаксический сахар для общего случая необходимости использовать троичный в сочетании с Исеть(). Возвращает свой первый операнд, если он существует и не равен NULL; в противном случае возвращается второй операнд.
Вот пример кода, чтобы продемонстрировать это:
<?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";
Строки, в которых есть уведомление, - это те, в которых я использую сокращенный троичный оператор, а не оператор объединения нулей. Однако даже с уведомлением PHP ответит тем же.
Выполните код: https://3v4l.org/McavC
Конечно, это всегда предполагает, что первый аргумент - null
. Как только он перестанет иметь значение null, вы получите различия в том, что оператор ??
всегда будет возвращать первый аргумент, а сокращение ?:
будет только в том случае, если первый аргумент верен, и это зависит от того, как PHP будет приведение типов к логическому значению.
Итак:
$a = false ?? 'f'; // false
$b = false ?: 'g'; // 'g'
тогда будет иметь $a
равным false
и $b
равному 'g'
.
Если вы используете так называемый кратковременный оператор, это вызовет уведомление, если $_GET['username']
не установлено:
$val = $_GET['username'] ?: 'default';
Итак, вы должны сделать что-то вроде этого:
$val = isset($_GET['username']) ? $_GET['username'] : 'default';
Оператор нулевой коалесценции эквивалентен приведенному выше оператору и будет возвращать значение по умолчанию, если $_GET['username']
не задано или null
:
$val = $_GET['username'] ?? 'default';
Обратите внимание, что он не проверяет правду. Он проверяет только если он установлен и не равен нулю.
Вы также можете сделать это, и будет возвращено первое определенное (set, not null
) значение:
$val = $input1 ?? $input2 ?? $input3 ?? 'default';
Теперь это правильный коалесцирующий оператор.
Основное различие заключается в том, что
Терминальное выражение оператора expr1?: expr3
возвращает expr1
если expr1
значение TRUE
но, с другой стороны, выражение Null Coalescing Operator (expr1)?? (expr2)
(expr1)?? (expr2)
вычисляет expr1
если expr1
не является NULL
Терминальный оператор expr1?: expr3
испускает уведомление, если значение левой стороны (expr1)
не существует, а с другой стороны Null Coalescing Operator (expr1)?? (expr2)
(expr1)?? (expr2)
В частности, не выделяет уведомление, если значение левой стороны (expr1)
не существует, как isset()
.
ТернарОператор оставлен ассоциативным
((true ? 'true' : false) ? 't' : 'f');
Оператор Null Coalescing является правильным ассоциативным
($a ?? ($b ?? $c));
Теперь давайте объясним разницу между примером:
Тернарный оператор (?:)
$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 Coalescing (??)
$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);
Вот таблица, объясняющая разницу и сходство между '??'
и ?:
Специальное примечание. Оператор коалесценции и тернарный оператор являются выражением и что он не оценивает переменную, а результат выражения. Это важно знать, хотите ли вы вернуть переменную по ссылке. Утверждение возвращает $ foo?? $ Бар; и вернуть $ var == 42? $ a: $ b; в функции возврата-ссылки не будет работать и выдается предупреждение.
Запустите ниже в интерактивном режиме php -a
(php -a
на терминале). Комментарий к каждой строке показывает результат.
var_dump (false ?? 'value2'); # bool(false)
var_dump (true ?? 'value2'); # bool(true)
var_dump (null ?? 'value2'); # string(6) "value2"
var_dump ('' ?? 'value2'); # string(0) ""
var_dump (0 ?? 'value2'); # int(0)
var_dump (false ?: 'value2'); # string(6) "value2"
var_dump (true ?: 'value2'); # bool(true)
var_dump (null ?: 'value2'); # string(6) "value2"
var_dump ('' ?: 'value2'); # string(6) "value2"
var_dump (0 ?: 'value2'); # string(6) "value2"
??
:??
как "ворота", который пропускает только NULL.NULL
.??
такое же, как ( !isset() || is_null() )
?:
?:
как ворота, которые пропускают anything falsy
- включая NULL
0
, empty string
, NULL
, false
!isset()
, empty()
.. все, что пахнет ложьюecho ($x? $x: false)
?:
Выдает PHP NOTICE
на неопределенные (unset
или !isset()
) переменные??
и ?:
..?:
Когда empty($x)
проверок!empty($x)? $x: $y
!empty($x)? $x: $y
можно сократить до $x?: $y
if(!$x) { fn($x); } else { fn($y); }
if(!$x) { fn($x); } else { fn($y); }
можно укоротить до fn(($x?: $y))
??
когда !isset() || is_null()
!isset() || is_null()
$object = $object?? new objClassName();
$object = $object?? new objClassName();
Тернарный оператор может быть уложен в стопку...
echo 0 ?: 1 ?: 2 ?: 3; //1
echo 1 ?: 0 ?: 3 ?: 2; //1
echo 2 ?: 1 ?: 0 ?: 3; //2
echo 3 ?: 2 ?: 1 ?: 0; //3
echo 0 ?: 1 ?: 2 ?: 3; //1
echo 0 ?: 0 ?: 2 ?: 3; //2
echo 0 ?: 0 ?: 0 ?: 3; //3
Источник и кредит для этого кода
Это в основном последовательность:
if( truthy ) {}
else if(truthy ) {}
else if(truthy ) {}
..
else {}
Оператор Null Coalese может быть уложен...
$v = $x ?? $y ?? $z;
Это последовательность:
if(!isset($x) || is_null($x) ) {}
else if(!isset($y) || is_null($y) ) {}
else {}
Используя укладку, я могу сократить это:
if(!isset($_GET['name'])){
if(isset($user_name) && !empty($user_name)){
$name = $user_name;
}else {
$name = 'anonymous';
}
} else {
$name = $_GET['name'];
}
К этому:
$name = $_GET['name'] ?? $user_name ?: 'anonymous';
Круто, правда? :-)
Оба они ведут себя по-разному, когда речь заходит о динамической обработке данных.
Если переменная пуста (''), нулевое коалесцирование будет обрабатывать переменную как true, но сокращенный тернарный оператор не будет. И это что-то иметь в виду.
$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';
И вывод:
1b
2b
2d
1f
Notice: Undefined variable: e in /in/ZBAa1 on line 21
2f
Ссылка: https://3v4l.org/ZBAa1
Оба являются сокращениями для более длинных выражений.
?:
коротка для $a? $a: $b
$a? $a: $b
. Это выражение будет иметь значение $ a, если $ a равно TRUE.
??
сокращение от isset($a)? $a: $b
isset($a)? $a: $b
. Это выражение будет иметь значение $ a, если $ a установлено и не равно нулю.
Их варианты использования перекрываются, когда $ a не определено или равно нулю. Когда $ a не определено ??
не будет выдавать E_NOTICE, но результаты будут такими же. Когда $ a равно нулю, результат тот же.
Для начинающих:
Нулевой оператор объединения (??)
Все верно, кроме null
значений и неопределенных (переменная/индекс массива/атрибуты объекта)
например:
$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"
это в основном проверка того, что переменная (индекс массива, атрибут объекта и т.д.) существует и не равна null
. аналогично функции isset
Сокращенное обозначение троичного оператора (? :)
каждое ложное (false
, null
, 0
, пустая строка) принимается за false, но если оно не определено, оно также принимается за false, но Notice
выдаст
бывший
$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: ..
Надеюсь это поможет
Прокрутите вниз по эту ссылку и просмотрите раздел, это дает сравнительный пример, как показано ниже:
<?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';
?>
Однако, не рекомендуется связывать операторы, так как это затрудняет понимание кода при чтении позже.
Нулевой коалесцирующий оператор (??) был добавлен в качестве синтаксического сахара для общего случая использования тройной связи в сочетании с isset(). Он возвращает свой первый операнд, если он существует, и не является NULL; в противном случае он возвращает свой второй операнд.
По сути, использование коалесцирующего оператора сделает его автоматической проверкой на значение null в отличие от тернарного оператора.
Кажется, есть плюсы и минусы использования ??
или ?:
. Про использование ?:
заключается в том, что он оценивает значение false и null и "" то же самое. Кон является то, что он сообщает E_NOTICE, если предыдущий аргумент равен null. С ??
pro - это отсутствие E_NOTICE, но con - это то, что он не оценивает значение false и null. По моему опыту, я видел, что люди начинают использовать нулевые и ложные взаимозаменяемые, но затем они в конечном итоге прибегают к модификации своего кода, чтобы быть совместимыми с использованием либо нулевого, либо ложного, но не того и другого. Альтернативой является создание более сложного тернарного состояния: (isset($something) or !$something) ? $something : $something_else
.
Ниже приведен пример различия в использовании оператора ??
с использованием как null, так и false:
$false = null;
$var = $false ?? "true";
echo $var . "---<br>";//returns: true---
$false = false;
$var = $false ?? "true";
echo $var . "---<br>"; //returns: ---
Однако, разрабатывая троичный оператор, мы можем сделать ложную или пустую строку "", как если бы это был нуль, не выбрасывая e_notice:
$false = null;
$var = (isset($false) or !$false) ? $false : "true";
echo $var . "---<br>";//returns: ---
$false = false;
$var = (isset($false) or !$false) ? $false : "true";
echo $var . "---<br>";//returns: ---
$false = "";
$var = (isset($false) or !$false) ? $false : "true";
echo $var . "---<br>";//returns: ---
$false = true;
$var = (isset($false) or !$false) ? $false : "true";
echo $var . "---<br>";//returns: 1---
Лично я считаю, что было бы очень хорошо, если бы в будущем rev PHP включался другой новый оператор: :?
, который заменил вышеупомянутый синтаксис. то есть:
// $var = $false :? "true";
Этот синтаксис будет одинаково оценивать значение null, false и "" и не вызывать E_NOTICE...
class a
{
public $a = 'aaa';
}
$a = new a();
echo $a->a; // Writes 'aaa'
echo $a->b; // Notice: Undefined property: a::$b
echo $a->a ?? '$a->a does not exists'; // Writes 'aaa'
// Does not throw an error although $a->b does not exist.
echo $a->b ?? '$a->b does not exist.'; // Writes $a->b does not exist.
// Does not throw an error although $a->b and also $a->b->c does not exist.
echo $a->b->c ?? '$a->b->c does not exist.'; // Writes $a->b->c does not exist.
Другие ответы идут глубоко и дают большие объяснения. Для тех, кто ищет быстрый ответ,
$a ?: 'fallback'
- это $a ? $a : 'fallback'
в то время как
$a ?? 'fallback'
- это $a = isset($a) ? $a : 'fallback'
Основное отличие будет в том случае, если левый оператор либо:
0
, ''
, false
, []
,...) Null Coalescing operator
выполняет только две задачи: он проверяет whether the variable is set
и whether it is null
. Взгляните на следующий пример:
<?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'
В приведенном выше примере кода указано, что Null Coalescing operator
обрабатывает несуществующую переменную и переменную, которая установлена на NULL
таким же образом.
Null Coalescing operator
является улучшением по сравнению с ternary operator
. Посмотрите на следующий фрагмент кода, сравнивающий два:
<?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.
Таким образом, разница между ними заключается в том, что оператор Null Coalescing operator
предназначен для обработки переменных undefined лучше, чем ternary operator
. В то время как ternary operator
является сокращением для if-else
.
Null Coalescing operator
не предназначен для замены ternary operator
, но в некоторых случаях использования, как в приведенном выше примере, он позволяет писать чистый код с меньшими проблемами.
Кредиты: http://dwellupper.io/post/6/php7-null-coalescing-operator-usage-and-examples
При использовании суперглобальных переменных, таких как $ _GET или $ _REQUEST, вы должны знать, что они могут быть пустой строкой. В этом конкретном случае этот пример
$username = $_GET['user'] ?? 'nobody';
потерпит неудачу, потому что значение $ username теперь является пустой строкой.
Поэтому при использовании $ _GET или даже $ _REQUEST вы должны использовать вместо этого троичный оператор, например:
$username = (!empty($_GET['user'])?$_GET['user']:'nobody';
Теперь значение $ username равно "nobody", как и ожидалось.