Обновите свои знания до высшего уровня!

Делают ли строгие равные то, о чем мы думали?

Свободное равенство также проверяет ваши типы

JavaScript будет настоящим функциональным языком.

- Дуглас Крокфорд

Я думал о том, как начать эту историю, и, в конце концов, мне стало ясно, что Дуглас прямо рассказывает историю JS. Его предсказание, казалось, сбылось. JavaScript становится мощным функциональным языком!

Благодаря силе динамической типизации, JS успешно справляется со всеми новыми методами программирования.

Решает ли двойное равенство наши проблемы?

Иногда вы можете задаться вопросом, почему у нас проблемы не с арифметическими операторами или условными операторами, а с равенствами. Самое серьезное принуждение, с которым люди борются, - это проверка на равенство.

В этой истории я хочу углубиться в некоторые проблемы, связанные с различием между свободно и строго равно. Когда мы сравниваем ‘==’ и ‘===’, это большая ложь:

МИФ: Разница между ‘==’ и ‘===’ заключается в том, что ‘==’ проверяет значение (свободное равенство), а ‘===’ проверяет значение в типе (строгое равенство).

Это понятие очень распространено. Но, к сожалению, это не так. Если вы хотите понять этот процесс и почему это ложное утверждение, вы должны понять свой код. Вы должны начать думать как JavaScript. Взглянем на спецификацию:

Эта часть называется Сравнение абстрактного равенства и отвечает за определение того, как работает свободное равенство. Это наиболее надежное доказательство того, что проигравшие равные не только проверяют ценность.

Заключение. Первое правило гласит, что если два значения имеют один и тот же тип, то будет выполнено строгое сравнение на равенство.

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

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

Принятие правильной ментальной модели - это фундаментальная вещь. Не тратьте время на чтение недостоверных рассказов и книг о двойных равных. Они редко ссылаются на единственный надежный источник - документацию.

В документации нетрудно разобраться. Это просто набор условных утверждений, которые вы можете понять, поскольку вы разработчик. Следующий пример отделит факты от слухов:

В первой строке у нас есть строка "Jamie", которая присваивается переменной person1. В следующей строке я создаю копию первой переменной. Когда я пробую свободное и строгое равенство, он говорит, что они равны в обоих случаях. Оказывается, когда типы совпадают, они делают тройное равенство.

Вывод: Двойное равенство и тройное равенство одинаковы при совпадении типов. Когда типы совпадают, сделайте тройное равенство.

Лучше всего объединять типы в пары, насколько это возможно, но это не значит, что у вас не будет принуждения. Избежать принуждения невозможно, но можно уменьшить количество принуждения.

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

Превосходно ли работают тройные равные?

Вам может быть интересно, что, черт возьми, делает тройное равенство? Это проверка типов, и все. Не имеет значения, когда значения, если типы разные. Это своего рода обход, который останавливает алгоритм, когда типы различаются (возвращает false).

Итак, в чем разница между двойным и тройным равным? Ответ может вас удивить:

Настоящая разница между строгим равенством и свободным равенством заключается в том, допустим ли мы какое-либо принуждение или нет.

Давайте посмотрим на документацию, чтобы прояснить ситуацию:

Что делает Strict Equality Comparison, если типы совпадают? Он выполняет то, что указано в документации (изображение выше). Например: если мы сравним NaN, он вернет false. Следующий отличный пример: если мы сравним ноль с отрицательным нулем, он вернет true.

У нас есть несколько предостережений, о которых нам нужно подумать (например, два примера выше), но это только тогда, когда типы уже совпадают.

Вывод: Они оба проверяют типы, но строгое равенство прекращается раньше.

С объектами все обстоит немного иначе. Приведу пример:

У нас есть два разных объекта. Чем они разные, у них одинаковые свойства? Это разные объекты.

Не попадитесь в ловушку и не запутайтесь с движком JS, который не проверяет весь объект (сравнивает структуру объектов), а сравнивает, на какие объекты указывают переменные (ссылаются). Я не уверен, что какой-либо язык делает что-то еще, кроме сравнения идентичностей.

Если movie1 и movie2 являются объектной ссылкой на один и тот же объект, он вернет true. В приведенном выше примере это не так, потому что переменные указывают на отдельные объекты.

В нашем примере результат такой же. Свободное равенство разрешает принуждение, когда типы были разными, а строгое равенство запрещает принуждение, когда типы совпадают.

Разъяснение

Очень важно знать, какие механизмы участвуют в каждой операции. Задайте себе вопрос: я знаю типы, нужно ли мне использовать принуждение; это полезно? Не существует универсального закона, который побуждает нас решать, применять ли принуждение или нет.

Иногда вам нужно подумать о крайних случаях, поэтому вы можете спросить себя: безопасно ли использовать принуждение? Вы должны мыслить нестандартно. На мой взгляд, выбор между строгим равенством и свободным равенством - это вопрос разборчивости и чистоты кода.

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

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

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

Вывод: знание того, какие типы вы используете в конкретном случае, позволяет улучшить кодовую базу.