Нулевой против ложного против 0 в PHP

Различия между этими значениями всегда сводятся к подробным правилам, зависящим от языка. То, что вы изучаете для PHP, не обязательно верно для Python, Perl, C и т. д. Хотя полезно изучить правила для языка (ов), с которым вы работаете, слишком много на них полагаться - это к проблемам. . Проблема возникает, когда следующему программисту нужно поддерживать ваш код, а вы использовали некоторую конструкцию, которая использует некоторые небольшие детали Null vs. False (например). Ваш код должен выглядеть правильно (и наоборот, неправильный код должен выглядеть неправильно).

Null - это ничего, False - это бит, а 0 - это (вероятно) 32 бита.

Не эксперт по PHP, но в некоторых более современных языках они не взаимозаменяемы. Я как бы скучаю по тому, чтобы 0 и false были взаимозаменяемыми, но поскольку логическое значение является фактическим типом, вы можете иметь связанные с ним методы и объекты, так что это просто компромисс. Нулевое значение равно нулю, отсутствие чего-либо по существу.

Ложь, Ноль, Ничего, 0, Не определено и т. д. И т. Д.

У каждого из них есть определенные значения, которые соотносятся с реальными концепциями. Иногда несколько значений перегружаются в одно ключевое слово или значение.

В C и C++NULL, False и 0 перегружены до одного и того же значения. В C# это 3 разных понятия.

null или NULL обычно указывает на отсутствие ценности, но обычно не указывает, почему. 0 указывает натуральное число ноль и имеет типовой эквивалент 1, 2, 3, и т. д., А на языках, поддерживающих отдельные концепции NULL, следует рассматривать только число.

Ложь указывает на неправду. И он использовался в двоичные значения. Это не означает отключение и не означает 0. Он просто указывает одно из двух двоичных значений.

Ничто не может указывать на то, что значение специально установлено как ничто, что указывает на то же, что и null, но с намерением.

Не определено в некоторых языках означает, что значение еще не было установлено, поскольку в коде не указано фактическое значение.

Null используется в базах данных для обозначения «нет записи» или «нет информации». Таким образом, у вас может быть битовое поле, которое описывает, «хочет ли этот пользователь, чтобы мы отправляли ему электронные письма», где True означает, что они отправляют, False означает, что они не хотят ничего отправлять, но Null будет означать, что вы этого не сделаете. не знаю. Они могут возникать через внешние соединения и тому подобное.

Логические последствия Null часто различны - в некоторых языках NULL ничему не равно, поэтому if (a == NULL) всегда будет ложным.

Так что лично я всегда инициализирую логическое значение FALSE, и инициализация одного значения NULL выглядело бы немного неприглядно (даже в C, где оба значения равны 0 ... просто стиль).

Что ж, я не могу вспомнить достаточно из моих дней PHP, чтобы ответить на часть «===», но для большинства языков C-стиля NULL следует использовать в контексте значений указателя, false как логическое и ноль как числовое значение, например int. '\ 0' - обычное значение для символьного контекста. Я обычно также предпочитаю использовать 0,0 для поплавков и удвоений.

Итак ... быстрый ответ: контекст.

В PHP это зависит от того, проверяете ли вы типы:

( 
 ( false !== 0 ) && ( false !== -1 ) && ( false == 0 ) && ( false == -1 ) &&
 ( false !== null ) && ( false == null ) 
)

Технически нулевым является 0x00, но в PHP ( null == 0x00 ) && ( null !== 0x00 ).

0 - целое число.

Я думаю, что плохие разработчики находят в этом коде разные варианты использования null / 0 / false.

Например, одна из самых распространенных ошибок разработчиков - это возвращение кода ошибки в виде данных с функцией.

// On error GetChar returns -1
int GetChar()

Это пример сахарного интерфейса. Это объясняется в книге «Отладка процесса разработки программного обеспечения», а также в другой книге «Написание правильного кода».

Проблема с этим заключается в предположении или предположениях, сделанных для типа char. На некоторых компиляторах тип char может быть без подписи. Таким образом, даже если вы вернете -1, компилятор может вместо этого вернуть 1. Подобные предположения компилятора в C++ или C трудно обнаружить.

Вместо этого лучше не смешивать код ошибки с вашими данными. Итак, следующая функция.

char GetChar()

теперь становится

// On success return 1
// on failure return 0
bool GetChar(int &char)

Это означает, что независимо от того, насколько молод разработчик в вашем магазине разработки, он никогда не ошибется. Хотя это не говорит о избыточности или зависимостях кода.

В общем, замена bool в качестве первого типа класса в языке - это нормально, и я думаю, что Джоэл говорил об этом в своем недавнем посткасте. Но постарайтесь не использовать смешивание и сопоставление bools с вашими данными в своих процедурах, и все будет в порядке.

Практически во всех современных языках null логически относится к указателям (или ссылкам), не имеющим значения, или к переменной, которая не инициализирована. 0 - это целое число, равное нулю, а false - это логическое значение, ну, ложь. Чтобы усложнить ситуацию, в C, например, значения null, 0 и false представлены одинаково. Я не знаю, как это работает в PHP.

Затем, чтобы еще больше усложнить ситуацию, в базах данных есть концепция null, что означает отсутствие или неприменимость, и у большинства языков нет прямого способа сопоставить DBNull с их нулевым значением. До недавнего времени, например, не существовало разницы между нулевым значением int и нулевым, но это было изменено с помощью целых чисел, допускающих значение NULL.

Извините, что усложняю этот звук. Просто это было камнем преткновения в языках в течение многих лет, и до недавнего времени нигде не было четкого решения. Раньше люди просто собирали вещи вместе или делали пустым, или 0 представляли нули в базе данных, что не всегда работает слишком хорошо.

Из Онлайн-документация PHP:

To explicitly convert a value to boolean, use the (bool) or (boolean) casts.
However, in most cases the cast is unncecessary, since a value will be automatically converted if an operator, function or control structure requires a boolean argument.
When converting to boolean, the following values are considered FALSE:

• само логическое значение FALSE
• целое число п 0 (ноль)
• поплавок 0.0 (ноль)
• пустая строка, а строка "0"
• массив с нулевыми элементами
• объект с нулевыми переменными-членами (только PHP 4)
• специальный тип NULL (включая неустановленные переменные)
• Объекты SimpleXML, созданные из пустых тегов Любое другое значение считается TRUE (включая любой ресурс).

Так что в большинстве случаев это одно и то же.

С другой стороны, === и == - это не одно и то же. Обычно вам нужен только оператор «равно». Чтобы уточнить:

$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 в PHP: если вы установите переменную, равную NULL, она будет такой же, как если бы вы вызвали для нее unset().

NULL по сути означает, что переменной не присвоено значение; false - допустимое логическое значение, 0 - допустимое целочисленное значение, а в PHP есть довольно уродливые преобразования между 0, "0", "" и false.

Ложь и 0 концептуально похожи, т.е. они изоморфны. 0 - начальное значение для алгебры натуральных чисел, а False - начальное значение для булевой алгебры.

Другими словами, 0 можно определить как число, которое при добавлении к некоторому натуральному числу дает то же самое число:

x + 0 = x

Точно так же False - это такое значение, что его дизъюнкция и любое другое значение является одним и тем же значением:

x || False = x

Нуль - это концептуально нечто совершенно иное. В зависимости от языка для него существует разная семантика, но ни одна из них не описывает «начальное значение» как False и 0. Для Null нет алгебры. Это относится к переменным, обычно для обозначения того, что переменная не имеет определенного значения в текущем контексте. В большинстве языков для Null не определены операции, и использование Null в качестве операнда является ошибкой. В некоторых языках существует специальное значение, называемое «дно», а не «ноль», которое является заполнителем для значения вычисления, которое не завершается.

Я писал более подробно о значениях NULL в другом месте.

В PHP вы можете использовать операторы === и! == для проверки не только равенства значений, но и совпадения их типов. Так, например: 0 == false - это true, но 0 === false - это false. То же самое касается != по сравнению с !==. Также, если вы сравните null с двумя другими, используя упомянутые операторы, ожидайте аналогичных результатов.

Теперь в PHP это качество значений обычно используется при возврате значения, которое иногда может быть 0 (ноль), но иногда может случиться так, что функция не работает. В таких случаях в PHP вы возвращаете false, и вам необходимо проверить эти случаи с помощью оператора идентификации ===. Например, если вы ищете позицию одной строки внутри другой и используете strpos(), эта функция вернет числовую позицию, которая может быть 0, если строка найдена в самом начале, но если строка не найдена вообще, тогда strpos() вернет false, и вы должны это учитывать при работе с результатом.

Если вы будете использовать ту же технику в своих функциях, любой, кто знаком со стандартной библиотекой PHP, поймет, что происходит и как проверить, является ли возвращаемое значение тем, что нужно, или возникла какая-то ошибка во время обработки. То же самое на самом деле касается параметров функций, вы можете обрабатывать их по-разному в зависимости от того, являются ли они массивами или строками или чем-то еще, и этот метод также широко используется во всем PHP, поэтому каждый получит его довольно легко. Так что, думаю, в этом сила.

Это зависит от языка, но в PHP:

Null означает «ничего такого». Вар не инициализирован.

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 не так много единообразия (хотя в последних версиях он улучшается, слишком много обратной совместимости). Несмотря на то, что дизайн требует некоторой согласованности (изложен в выбранном ответе здесь), все это сбивает с толку, когда вы рассматриваете возвращаемые методы, которые используют false / null не такими простыми способами.

Вы часто будете видеть использование null, когда они уже для чего-то используют false. например filter_input (). Они возвращают false, если переменная не соответствует фильтру, и null, если переменная не существует (не означает ли, что она также не прошла фильтр?)

Методы, которые взаимозаменяемо возвращают false / null / string / etc - это взлом, когда автор заботится о типе сбоя, например, с filter_input() вы можете проверить ===false или ===null, если вас волнует, почему проверка не удалась. Но если вы этого не сделаете, это может быть ловушкой, так как можно забыть добавить проверку для ===null, если они не забыли написать тестовый пример для ===false. И большинство инструментов тестирования / покрытия php не обратят внимания на отсутствующий, непроверенный путь кода!

Наконец, вот немного забавного жонглирования шрифтами. даже не включая массивы или объекты.

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)

Я только что потратил половину дня, пытаясь вернуть 0, null, false из strops!

Вот все, что я пытался сделать, прежде чем обнаружил, что логика течет не в правильном направлении, и казалось, что в 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!

Потратив день на отладку какого-то простого кода, я пожалел, что не знал об этом раньше, так как смог бы определить проблему, вместо того, чтобы копаться во всем, пытаясь заставить ее работать. Это не сработало, поскольку False, NULL и 0 не все то же самое, что True or False or NULL?

Ниже приведен пример:

            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. Проблема нацелена на нечетко определенный скалярный тип.

'*' == true -> true (string match)
'*' === true -> false (numberic match)

(int)'*' == true -> false
(string)'*' == true -> true

Строгость PHP7 - это шаг вперед, но, возможно, этого недостаточно. https://web-techno.net/typing-with-php-7-what-you-shouldnt-do/

Кто-нибудь может объяснить мне, почему «NULL» - это не просто строка в экземпляре сравнения?

$x = 0;
var_dump($x == 'NULL');  # TRUE   !!!WTF!!!