JavaScript Essentials: Как сделать жизненные решения с заявлениями Ef / else

Автор оригинала: Zell Liew.

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

Вы остановитесь, не так ли?

И что происходит, когда свет снова становится зеленым? Вы начинаете ходить.

Мы можем поставить эту аналогию в код тоже. Это звучит что-то вроде: «Если свет становится красным, перестань ходить. В противном случае продолжайте ходьба».

И что мой друг, это основа Если/else утверждение.

Заявление IF/Evel

Если/else Заявление помогает контролировать, что делает ваша программа в указанных ситуациях. Похоже, это выглядит:

if (condition) {     // Do something } else {     // Do some other thing }

Состояние Рассказывает JavaScript, что нужно проверить, прежде чем продолжить. Если условие оценивает правда JavaScript выполняет код в Если блокировать.

Если условие оценивает ложь JavaScript выполняет код из еще блокировать.

В примере светофора мы проверяем, красный ли свет:

// Note: This example doesn't contain valid code yet if (light is red) {  stop walking } else {  continue walking }

Если вам нужно проверить более одного условия, вы можете использовать еще если , который идет между Если и еще Отказ

Когда бы вам потребовалось такое второе условие?

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

В коде это будет выглядеть так:

if (light is red) {   // Stop walking } else if (cars around) {   // Stop walking } else if (yet another condition) {   // Do yet another thing } else {   // Do the final thing }

В этом случае, если первое условие оценивает правда JavaScript выполняет код в Если блокировать.

Если первое условие оценивается на ложь JavaScript проверяет состояние в следующем еще если блок и видит, оценивает ли он правда Отказ Он продолжается и продолжается до всех еще если блоки исчерпаны.

Чтобы проверить, оценивает ли условие для правда или ложь JavaScript полагается на две вещи:

Операторы сравнения
Пвердые и фальсивые ценности

Давайте сначала поговорим о операторах сравнения.

Операторы сравнения

Есть четыре основных типа операторов сравнения:

Больше, чем ( & gt;) или больше или равен t o (> =)
Меньше, чем ( & lt;) или меньше или равен t o (<=)
Строго равны ( === ) или равны ==.
Строго неравные ( ! == ) или неравные знак равно

Первые два типа операторов сравнения просты. Вы используете их для сравнения числа.

24 > 23 // True 24 > 24 // False 24 >= 24 // True

24 < 25 // True 24 < 24 // False 24 <= 24 // True

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

24 === 24 // True 24 !== 24 // False

Тем не менее, существует разница между строго равным ( === ) против равным ( == ), а строго неравное ( ! == ) против неравных ( ! = ):

'24' === 24 // False '24' == 24 // True

'24' !== 24 // True '24' != 24 // False

Как вы можете видеть из примера выше, когда вы сравниваете строку 24 против № 24, === оценивает ложь в то время как == оценивает правду.

Почему это так? Давайте посмотрим на разницу между строго равными и равными.

=== vs == (или! =)

JavaScript – это свободно напечатанный язык. Что это значит, что, когда мы объявляем переменные, нам все равно, какое значение имеет значение в переменной.

Вы можете объявить любой примитивный или объект, и JavaScript делает остальные для вас автоматически:

const aString = 'Some string' const aNumber = 123 const aBoolean = true

При сравнении вещей со строго равным ( === ) или строго неравным ( ! == ), JavaScript проверяет тип переменной. Вот почему строка 24 и а Номер 24 не приравнивать.

'24' === 24 // False '24' !== 24 // True

При сравнении вещей с равным ( == ) или неравным ( ! = ), JavaScript преобразует (или отказывается) типы, чтобы они соответствовали друг другу.

Как правило, JavaScript пытается преобразовать все типы на номера при использовании оператора преобразования. В примере ниже строка 24 преобразуется в Номер 24 до сравнения.

Вот почему строка 24 приравнивает к ряду 24 при использовании == Отказ

'24' == 24 // True '24' != 24 // False

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

0 == false // True 1 == true // True 2 == true // False

Автоматическое преобразование типа (при использовании операторов сравнения) является одной из распространенных причин труднодоступных ошибок. Всякий раз, когда вы сравниваете для равенства, всегда используйте строгие версии ( === или ! == ).

Сравнение объектов и массивов

Попробуйте сравнить объекты и массивы с === или == Отказ Вы будете очень удивлены.

const a = { isHavingFun: true } const b = { isHavingFun: true }

console.log(a === b) // false console.log(a == b) // false

В примере выше, оба А и B Смотри точно так же. Они оба объекта, у них такие же значения.

Странная вещь, А всегда будет ложным. Почему?

Допустим, у вас есть идентичный брат-близнецы/сестра. Вы смотрите точно так же, как ваш близнец. Та же цвет волос, то же лицо, та же одежда, то же самое. Как люди могут дифференцировать вас от вас? Это будет трудно.

В JavaScript каждый объект имеет «удостоверение личности». Эта идентификационная карта называется Ссылка к объекту. Когда вы сравниваете объекты с операторами равенства, вы просите JavaScript проверить, имеют ли два объекта одинаковую ссылку (та же удостоверение личности).

Это сюрприз, что А всегда будет ложным сейчас?

Давайте настроим это немного и назначить А к B Отказ

const a = { isHavingFun: true } const b = a

В этом случае А оценивает правду, потому что B Теперь указывает на одинаковую ссылку, что и А Отказ

console.log(a === b) // true

Пвердые и фальсины

Если вы пишете одну переменную (например HasaPty в примере ниже) как условие Если/else Заявление, JavaScript проверяет правду или ложное значение.

const hasApples = 'true'

if (hasApples) {   // Eat apple } else {   // Buy apples }

А Falsy Значение – это значение, которое оценивает ложь при преобразовании в логическое значение. В JavaScript есть шесть возможных фальсифицированных значений:

ложный
неопределенный
значение NULL
0 (числовой ноль)
"" (пустой строкой)
Нан (Не число)

А правда Значение, с другой стороны, это значение, которое оценивает на правда при преобразовании в логическое значение. В случае чисел, все, что не 0 Преобразуется в правда Отказ

Автоматическое преобразование типа в правдоподобные и фальсивые значения сильно поощряются в JavaScript , потому что они делают код короче и легче понять.

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

const str = ''

if (str) {   // Do something if string is not empty } else {   // Do something if string is empty }

Обертывание

Если/else Заявления используются для контроля того, какова ваша программа в определенных ситуациях. Это позволяет вам определить, ходить или пересекать дорогу, в зависимости от условий, данных вам.

Чтобы проверить, является ли условие истинным или ложным, JavaScript полагается на две вещи:

Операторы сравнения
Пвердые/Falsy ценности

Если вы любили эту статью, вам понравится учиться Учите JavaScript – курс, который помогает вам научиться Создайте реальные компоненты с нуля с JavaScript. Нажмите здесь, чтобы узнать больше о изучении JavaScript если тебе интересно.

(О, кстати, если вам понравилась эта статья, я был бы признателен, если бы вы могли поделиться этим .?)

Первоначально опубликовано zellwk.com .