Ноль против Ложь против 0 в PHP
Мне сказали, что хорошие разработчики могут определить/использовать разницу между Null и False и 0 и всеми другими хорошими сущностями "ничего".
В чем заключается разница, особенно в PHP? Имеет ли это какое-то отношение к ===?
17 answers
Это зависит от языка, но в PHP:
Null означает "ничего". var не был инициализирован.
False означает " неверно в логическом контексте". Используется, чтобы явно показать, что вы имеете дело с логическими проблемами.
0 является int. Ничего общего с остальным выше, используемым для математики.
Теперь, что сложно, так это то, что в динамических языках, таких как PHP, все они имеют значение в логическом контексте, которое (в PHP) является False.
Если вы протестируете его с помощью ==, он проверяет логическое значение, поэтому вы получите равенство. Если вы протестируете его с помощью ===, он проверит тип, и вы получите неравенство.
Так почему же они полезны?
Ну, посмотрите на функцию strrpos(). Он возвращает False, если он ничего не нашел, но 0, если он нашел что-то в начале строки!
<?php
// pitfall :
if (strrpos("Hello World", "Hello")) {
// never exectuted
}
// smart move :
if (strrpos("Hello World", "Hello") !== False) {
// that works !
}
?>
И, конечно, если вы имеете дело с состояния:
Вы хотите провести различие между DebugMode = False (установлено в выключено), DebugMode = True (установлено в включено) и DebugMode = Null (не установлено вообще, приведет к жесткой отладке ;-)).
null является null. false - это false. Печально, но факт.
В PHP не так много согласованности. разработчики ПЫТАЮТСЯ сделать null означает "неизвестный" или "несуществующий". но часто False будет означать "несуществующий" (например, strrpos ("сбой", "поиск") вернет false, а не null)
Вы часто увидите, что используется null, когда они уже используют false для чего-то. например, filter_input(). Они возвращают значение false, если переменная не проходит фильтр. и null, если переменная не существует (не означает ли, что он также не прошел фильтр? так зачем вообще возвращать null?!?)
Php имеет удобство возврата данных в функции. и, конечно, разработчики втискивают все виды статуса сбоя вместо данных.
И в PHP нет разумного способа определить данные (int, str и т.д.) от сбоя (false, null)
Вам в значительной степени приходится всегда проверять наличие ===null или ===false, в зависимости от функции. или для обоих, в таких случаях, как filter_input()/filter_var()
фильтр_инпут()/фильтр_вар()А вот и забава с жонглированием типами. даже не включая массивы и объекты.
var_dump( 0<0 ); #bool(false)
var_dump( 1<0 ); #bool(false)
var_dump( -1<0 ); #bool(true)
var_dump( false<0 ); #bool(false)
var_dump( null<0 ); #bool(false)
var_dump( ''<0 ); #bool(false)
var_dump( 'a'<0 ); #bool(false)
echo "\n";
var_dump( !0 ); #bool(true)
var_dump( !1 ); #bool(false)
var_dump( !-1 ); #bool(false)
var_dump( !false ); #bool(true)
var_dump( !null ); #bool(true)
var_dump( !'' ); #bool(true)
var_dump( !'a' ); #bool(false)
echo "\n";
var_dump( false == 0 ); #bool(true)
var_dump( false == 1 ); #bool(false)
var_dump( false == -1 ); #bool(false)
var_dump( false == false ); #bool(true)
var_dump( false == null ); #bool(true)
var_dump( false == '' ); #bool(true)
var_dump( false == 'a' ); #bool(false)
echo "\n";
var_dump( null == 0 ); #bool(true)
var_dump( null == 1 ); #bool(false)
var_dump( null == -1 ); #bool(false)
var_dump( null == false ); #bool(true)
var_dump( null == null ); #bool(true)
var_dump( null == '' ); #bool(true)
var_dump( null == 'a' ); #bool(false)
echo "\n";
$a=0; var_dump( empty($a) ); #bool(true)
$a=1; var_dump( empty($a) ); #bool(false)
$a=-1; var_dump( empty($a) ); #bool(false)
$a=false; var_dump( empty($a) ); #bool(true)
$a=null; var_dump( empty($a) ); #bool(true)
$a=''; var_dump( empty($a) ); #bool(true)
$a='a'; var_dump( empty($a)); # bool(false)
echo "\n"; #new block suggested by @thehpi
var_dump( null < -1 ); #bool(true)
var_dump( null < 0 ); #bool(false)
var_dump( null < 1 ); #bool(true)
var_dump( -1 > true ); #bool(false)
var_dump( 0 > true ); #bool(false)
var_dump( 1 > true ); #bool(true)
var_dump( -1 > false ); #bool(true)
var_dump( 0 > false ); #bool(false)
var_dump( 1 > true ); #bool(true)
Ниже приведен пример:
Comparisons of $x with PHP functions
Expression gettype() empty() is_null() isset() boolean : if($x)
$x = ""; string TRUE FALSE TRUE FALSE
$x = null; NULL TRUE TRUE FALSE FALSE
var $x; NULL TRUE TRUE FALSE FALSE
$x is undefined NULL TRUE TRUE FALSE FALSE
$x = array(); array TRUE FALSE TRUE FALSE
$x = false; boolean TRUE FALSE TRUE FALSE
$x = true; boolean FALSE FALSE TRUE TRUE
$x = 1; integer FALSE FALSE TRUE TRUE
$x = 42; integer FALSE FALSE TRUE TRUE
$x = 0; integer TRUE FALSE TRUE FALSE
$x = -1; integer FALSE FALSE TRUE TRUE
$x = "1"; string FALSE FALSE TRUE TRUE
$x = "0"; string TRUE FALSE TRUE FALSE
$x = "-1"; string FALSE FALSE TRUE TRUE
$x = "php"; string FALSE FALSE TRUE TRUE
$x = "true"; string FALSE FALSE TRUE TRUE
$x = "false"; string FALSE FALSE TRUE TRUE
Пожалуйста, ознакомьтесь с этим для получения дополнительной информации о сравнениях типов в PHP и даст вам четкое представление.
В PHP вы можете использовать операторы === и !== для проверки не только того, равны ли значения, но и совпадают ли их типы. Так, например: 0 == false - это true, но 0 === false - это false. То же самое касается != по сравнению с !==. Также в случае, если вы сравниваете null с двумя другими, используя упомянутые операторы, ожидайте аналогичных результатов.
Теперь в PHP это качество значений обычно используется при возврате значения, которое иногда может быть 0 (ноль), но иногда может быть, что функция не удалась. В такие случаи в PHP вы возвращаете false, и вы должны проверить эти случаи с помощью оператора идентификации ===. Например, если вы ищете позицию одной строки внутри другой и используете strpos(), эта функция вернет числовую позицию, которая может быть равна 0, если строка найдена в самом начале, но если строка вообще не найдена, то strpos() вернет false, и вы должны учитывать это при работе с результатом.
Если вы будете использовать то же самое техника в ваших функциях любой, кто знаком со стандартной библиотекой PHP, поймет, что происходит и как проверить, соответствует ли возвращаемое значение требуемому или произошла какая-то ошибка при обработке. То же самое на самом деле относится и к параметрам функций, вы можете обрабатывать их по-разному в зависимости от того, являются ли они массивами или строками или чем-то еще, и этот метод также широко используется во всем PHP, так что каждый получит его довольно легко. Так что, я думаю, в этом и есть сила.
Ложь, Ноль, Ничего, 0, Неопределенный и т. Д. и т. Д.
Каждое из них имеет определенные значения, которые соотносятся с реальными понятиями. Иногда несколько значений перегружаются в одно ключевое слово или значение.
В C и C++, NULL, False и 0 перегружены до одного и того же значения.
В C# это 3 разных понятия.
null или NULL обычно указывает на отсутствие значения, но обычно не указывает, почему.
0 указывает натуральное число ноль и имеет эквивалентность по типу 1, 2, 3, и т.д. и в языках, поддерживающих отдельные понятия NULL, следует рассматривать только число.
Ложь указывает на неправду. И он используется в двоичных значениях. Это не означает, что он не установлен, и не означает 0. Он просто указывает одно из двух двоичных значений.
Ничто не может указывать на то, что значение специально установлено равным nothing, что указывает на то же самое, что и null, но с намерение.
Неопределенный в некоторых языках указывает на то, что значение еще не установлено, поскольку ни в одном коде не указано фактическое значение.
Я только что потратил 1/2 дня, пытаясь получить либо 0, нулевое, ложное возвращение от strpos!
Вот все, что я пытался сделать, прежде чем обнаружил, что логика течет не в правильном направлении, и кажется, что в php-кодировании есть черная дыра:
Концепция возьмите доменное имя, размещенное на сервере, и убедитесь, что оно не корневого уровня, хорошо, несколько разных способов сделать это, но я выбрал другой из-за других функций/конструкций php, которые я сделал.
В любом случае, здесь был основа косинуса:
if (strpos($_SERVER ['SERVER_NAME'], dirBaseNAME ()) { do this } else {or that}
{
echo strpos(mydomain.co.uk, mydomain);
if ( strpos(mydomain, xmas) == null ) {echo "\n1 is null"; }
if ( (strpos(mydomain.co.uk, mydomain)) == 0 ) {echo "\n2 is 0"; }else {echo "\n2 Something is WRONG"; }
if ( (mydomain.co.uk, mydomain)) != 0 ) {echo "\n3 is 0"; }else {echo "\n3 it is not 0"; }
if ( (mydomain.co.uk, mydomain)) == null ) {echo "\n4 is null"; }else {echo "\n4 Something is WRONG"; }
}
НАКОНЕЦ-то после прочтения этой темы, Я обнаружил, что это сработало!!!
{
if ((mydomain.co.uk, mydomain)) !== false )
{
echo "\n5 is True";
} else {
echo "\n5 is False";
}
}
Спасибо за эту статью, теперь я понимаю, что, хотя это Рождество, оно может быть не таким ложным, как Рождество, так как оно также может быть нулевым днем!
Потратив целый день на отладку какого-то простого кода, я пожалел, что не знал об этом раньше, так как смог бы идентифицировать проблему, а не ходить повсюду, пытаясь заставить ее работать, где она все равно не работала как False, Null и 0 не являются одинаковыми True, False или null?
Различия между этими значениями всегда сводятся к подробным языковым правилам. То, что вы изучаете для PHP, не обязательно верно для Python, или Perl, или C и т. Д. Хотя полезно изучить правила для языка (языков), с которыми вы работаете, слишком полагаться на них - значит напрашиваться на неприятности. Проблема возникает, когда следующему программисту нужно поддерживать ваш код, и вы использовали какую-то конструкцию, которая использует некоторые небольшие детали Null против Ложь (например). Ваш код должен выглядеть правильно (и наоборот, неправильный код должен выглядеть неправильно).
Значение Null используется в базах данных для обозначения "нет записи" или "нет информации". Таким образом, у вас может быть небольшое поле, описывающее "хочет ли этот пользователь, чтобы мы отправляли ему электронные письма", где True означает, что он это делает, False означает, что он ничего не хочет отправлять, но Null будет означать, что вы не знаете. Они могут возникать через внешние соединения и тому подобное.
Логические следствия Null часто различны - в некоторых языках NULL ничему не равно, поэтому if(a==NULL) всегда будет ложь.
Поэтому лично я всегда инициализировал бы логическое значение в значение FALSE, а инициализация одного значения в значение NULL выглядела бы немного неприглядно (даже в C, где оба значения равны 0... просто стильная вещь).
"*Чтобы явно преобразовать значение в логическое, используйте приведения (bool) или (boolean). Однако в большинстве случаев приведение не требуется, так как значение будет автоматически преобразовано, если оператор, функция или структура управления требуют логического аргумента. При преобразовании в логическое значение следующие значения считаются ЛОЖНЫМИ: * само логическое значение FALSE * целое число 0 (ноль) * поплавок 0.0 (ноль) * пустая строка, и строка "0" * массив с нулевыми элементами * объект с нулевыми переменными-членами (только для PHP 4) * специальный тип NULL (включая неустановленные переменные) * Объекты SimpleXML, созданные из пустых тегов Любое другое значение считается ИСТИННЫМ (включая любой ресурс).*"
Итак, в большинстве случаев это одно и то же.
С другой стороны, "===" и "==" - это не одно и то же. Регулярно вам просто нужен оператор "равно". Чтобы уточнить:
$a == $b //Equal. TRUE if $a is equal to $b.
$a === $b //Identical. TRUE if $a is equal to $b, and they are of the same type.
Для большего информацию, проверьте страницу " Операторы сравнения" в онлайн-документах PHP.
Надеюсь, это поможет.
Я думаю, что плохие разработчики находят все различные варианты использования null/0/false в этом коде.
Например, одной из наиболее распространенных ошибок разработчиков является возврат кода ошибки в виде данных с функцией.
// On error GetChar returns -1
int GetChar()
Это пример интерфейса sugar. Это объясняется в книге "Отладка процесса разработки программного обеспечения", а также в другой книге "написание правильного кода".
Проблема с этим заключается в выводах или предположениях, сделанных в отношении типа char. В некоторых компиляторах тип char может быть не подписанным. Таким образом, даже если вы возвращаете -1, компилятор может вместо этого вернуть 1. Такого рода допущения компилятора в C++ или C трудно обнаружить.
Вместо этого лучший способ - не смешивать код ошибки с вашими данными. Итак, следующая функция.
char GetChar()
Теперь становится
// On success return 1
// on failure return 0
bool GetChar(int &char)
Это означает, что независимо от того, насколько молод разработчик в вашем магазине разработки, он или она никогда не ошибется. Хотя это не говорит о редуцированности или зависимости в коде.
Так что в целом замена bool в качестве первого типа класса на языке в порядке вещей, и я думаю, что Джоэл говорил об этом в своем недавнем посткасте. Но старайтесь не использовать в своих процедурах смешивание и сопоставление булов с вашими данными, и у вас все будет в порядке.
В PHP это зависит от того, проверяете ли вы типы:
(
( false !== 0 ) && ( false !== -1 ) && ( false == 0 ) && ( false == -1 ) &&
( false !== null ) && ( false == null )
)
Технически значение null равно 0x00, но в PHP ( null == 0x00 ) && ( null !== 0x00 ).
0 является целочисленным значением.
Null - это ничто, False - это бит, а 0 - это (вероятно) 32 бита.
Не эксперт по PHP, но в некоторых более современных языках они не взаимозаменяемы. Я как бы скучаю по тому, чтобы 0 и false были взаимозаменяемыми, но с логическим типом, который является фактическим типом, у вас могут быть методы и объекты, связанные с ним, так что это просто компромисс. Однако нуль - это нуль, отсутствие чего-либо существенного.
Ну, я не могу вспомнить достаточно из моих дней PHP, чтобы ответить на часть "===", но для большинства языков в стиле C значение NULL следует использовать в контексте значений указателей, false как логическое значение и ноль как числовое значение, такое как int. "\0" - это обычное значение для контекста символов. Обычно я также предпочитаю использовать 0.0 для поплавков и двойников.
Итак.. быстрый ответ: контекст.
Практически во всех современных языках null логически относится к указателям (или ссылкам), не имеющим значения, или к переменной, которая не инициализирована. 0 - это целочисленное значение нуля, а false - логическое значение, ну, в общем, false. Чтобы усложнить ситуацию, в C, например, null, 0 и false представлены одинаково. Я не знаю, как это работает в PHP.
Затем, чтобы еще больше усложнить ситуацию, в базах данных есть понятие null, что означает отсутствие или отсутствие применимо, и в большинстве языков нет прямого способа сопоставить значение DBNull с их значением null. Например, до недавнего времени не было различия между значением int, равным нулю, и значением нуля, но это было изменено с помощью значений int, допускающих значение null.
Извините, что это звучит так сложно. Просто это было камнем преткновения в языках Гарри в течение многих лет, и до недавнего времени нигде не было четкого решения. Люди привыкли просто объединять вещи вместе или делать пустые или 0 представляют собой нули в базе данных, которая не всегда работает слишком хорошо.
Один интересный факт о NULL в PHP: Если вы установите значение var равным NULL, это будет то же самое, как если бы вы вызвали unset() для него.
NULL по сути означает, что переменной не присвоено значение; false - допустимое логическое значение, 0 - допустимое целочисленное значение, и PHP имеет довольно уродливое преобразование между 0, "0", "" и false.
False и 0 концептуально похожи, т. Е. Они изоморфны. 0 - начальное значение для алгебры натуральных чисел, а False - начальное значение для булевой алгебры.
Другими словами, 0 можно определить как число, которое при добавлении к некоторому натуральному числу дает то же самое число:
x + 0 = x
Аналогично, False - это такое значение, что его дизъюнкция и любое другое значение являются одним и тем же значением:
x || False = x
Null концептуально является чем-то совершенно различный. В зависимости от языка для него существует разная семантика, но ни один из них не описывает "начальное значение" как False и 0. Для Null не существует алгебры. Это относится к переменным, обычно для обозначения того, что переменная не имеет определенного значения в текущем контексте. В большинстве языков нет операций, определенных для Null, и использование Null в качестве операнда является ошибкой. В некоторых языках существует специальное значение, называемое "bottom", а не "null", которое является заполнителем для значение вычисления, которое не завершается.
В целом, языки программирования, как правило, имеют истинные и ложные значения. Правила того, что является правдой, а что ложью, варьируются от языка к языку.
Http://www.isolani.co.uk/blog/javascript/TruthyFalsyAndTypeCasting