Что вернет логические операторы 0 undefined 10 foo

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

Как правило. на самом деле эти операторы и называются «логическими», но в JavaScript могут оперировать значениями любого типа и возвращать также значения любого типа.

С логическим И на первый взгляд всё просто, если оба операнда истины, то выражение истинно:

Этот пример можно немного усложнить и записать операндами выражения сравнения.

Но на самом деле всё не так просто. В данном примере мы использовали операторы сравнения, они возвращают логические значения true / false. Но операндами логического И могут быть выражения с арифметическими операторами.

Давайте изменим пример:

В этом примере оператор && вернёт 11. Дело в том, что на самом деле оператор && возвращает последний операнд, если все операнды истинны.

Если хоть один из операндов равен лжи, то && возвратит первый операнд со значением ложь.

В этом примере оператор && вернёт цифру 0. Можно, для более глубокого понимания, усложнить пример.

Что есть ложь в JavaScript

Сейчас хороший повод повторить что есть ложь в JavaScript.

Всё остальное в логическом контексте будет истиной.

Оператор логического ИЛИ возвращает первое значение true (истина). А если истинных значений нет, то последнее ложное.

Также становится очевидно, при помощи двойного логического НЕ мы можем преобразовать литерал в тип Boolean.

Короткий цикл вычислений

Оператор || (ИЛИ)

Переменная result будет равна «Привет!». Постфиксный инкремент myVar++ сработает после вычисления выражения, а префиксный инкремент ++myVar не будет выполнен, так как ранее оператор || обнаружит истину.

Оператор && (И)

Вычисления слево направо, если аргумент — false, оператор && возвращает его и заканчивает вычисления. Иначе — вычисляет дальше, если false в списке нет, возвращает последний правый аргумент, а он будет true.

Вычисления остановятся на переменной myStr, именно её значение «» и будет присвоено в переменную result.

&& вместо if

В простых случаях можно использовать оператор && вместо инструкции if:

В этом примере правый операнд выполнится только в том случае, если левый имеет логический тип истина.

Такая запись плохо читаема, рекомендуется использовать конструкцию JavaScript: if и else.

Источник

Логические операторы

Описание

В таблице приведены описания логических операторов:

Примеры значений выражений, которые могут быть преобразованы в false :

Хоть операторы && и || могут использовать операнды с не булевыми значениями, но они всёравно рассматриваются, как булевы операторы, т.к. их возвращаемые ими значения всегда могут быть сконвертированы в булевы значения.

Выполнение короткого замыкания

Так как логические операторы выполняются слева направо, они тестируются на возможные «короткие замыкание», при использовании следующих прав:

Например, следующие 2 функции делают одно и то же:

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

Логическое И ( && )

Следующий код показывает пример оператора && (логическое И).

Логическое ИЛИ ( || )

Это код представляет собой пример оператора || (логическое ИЛИ).

Правила преобразования

Конвертирование И в ИЛИ

следующая операция использует булев тип:

Конвертирование ИЛИ в И

эта операция использует булев тип:

Конвертирование многих НЕ

следующая операция использует булев тип:

Удаление вложенных скобок

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

Удаление вложенных И

Это составное выражение использует булев тип:

Удаление вложенного ИЛИ

Следующее составное выражение использует булев тип:

Спецификации

Поддержка браузерами

Смотрите также

Метки документа и участники

© 2005-2016 Mozilla Developer Network и отдельные соучастники.

Содержимое доступно на условиях этих лицензий.

Источник

Операторы Javascript

В JavaScript существует множество различных операторов: арифметические операторы, операторы присваивания, строковые операторы, операторы сравнения, логические операторы, операторы типов, побитовые операторы.

Оператор присваивания (=) присваивает значение переменной:

Оператор сложения (+) складывает числа:

Оператор умножения (*) перемножает числа:

Арифметические операторы JavaScript

Арифметические операторы используются для выполнения арифметических операций с числами:

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

Операторы присваивания присваивают значения переменным JavaScript.

Строковые операторы JavaScript

Оператор сложения (+) также может использоваться для объединения (конкатенации) строк.

Также, для конкатенации строк можно использовать оператор присваивания +=:

При использовании со строками оператор + еще называют оператором конкатенации.

Сложение строк и чисел

Сложение двух чисел вернет сумму этих чисел, однако сложение числа и строки вернет строку:

В результате в переменных x, y, z мы получим 10, 55, Hello5 соответственно.

Помните! Если сложить число и строку, в результате получится строка!

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

Внимание! В примерах в таблице выше приведены 4-битные числа без знака. В действительности же JavaScript использует 32-битные числа со знаком. Таким образом, в JavaScript выражение

00000000000000000000000000000101 возвращает 11111111111111111111111111111010.

Источник

Логические операторы

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

Давайте рассмотрим их подробнее.

Оператор «ИЛИ» выглядит как двойной символ вертикальной черты:

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

Существует всего четыре возможные логические комбинации:

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

Обычно оператор || используется в if для проверки истинности любого из заданных условий.

Можно передать и больше условий:

ИЛИ «||» находит первое истинное значение

Описанная выше логика соответствует традиционной. Теперь давайте поработаем с «дополнительными» возможностями JavaScript.

Расширенный алгоритм работает следующим образом.

При выполнении ИЛИ || с несколькими значениями:

Оператор || выполняет следующие действия:

Значение возвращается в исходном виде, без преобразования.

Другими словами, цепочка ИЛИ «||» возвращает первое истинное значение или последнее, если такое значение не найдено.

Это делает возможным более интересное применение оператора по сравнению с «чистым, традиционным, только булевым ИЛИ».

Получение первого истинного значения из списка переменных или выражений.

Сокращённое вычисление.

Операндами могут быть как отдельные значения, так и произвольные выражения. ИЛИ вычисляет их слева направо. Вычисление останавливается при достижении первого истинного значения. Этот процесс называется «сокращённым вычислением», поскольку второй операнд вычисляется только в том случае, если первого недостаточно для вычисления всего выражения.

Это хорошо заметно, когда выражение, указанное в качестве второго аргумента, имеет побочный эффект, например, изменение переменной.

В приведённом ниже примере x не изменяется:

Присваивание – лишь один пример. Конечно, могут быть и другие побочные эффекты, которые не проявятся, если вычисление до них не дойдёт.

Как мы видим, этот вариант использования || является «аналогом if «. Первый операнд преобразуется в логический. Если он оказывается ложным, начинается вычисление второго.

Оператор И пишется как два амперсанда && :

Источник

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

Проверь себя

Вот список интересных выражений, о которых мы только что говорили:

Тут полно такого, что выглядит более чем странно, но без проблем работает в JS, задействуя неявное приведение типов. В подавляющем большинстве случаев неявного приведения типов в JS лучше всего избегать. Рассматривайте этот список как упражнение для проверки ваших знаний о том, как работает приведение типов в JavaScript. Если же тут для вас ничего нового не нашлось — загляните на wtfjs.com.

JavaScript полон странностей

Неявное преобразование типов и явное преобразование типов

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

Три вида преобразования типов

Первая особенность работы с типами в JS, о которой нужно знать, заключается в том, что здесь есть только три вида преобразований:

Примитивные типы данных

▍Преобразование к типу String

Все примитивные типы преобразуются в строки вполне естественным и ожидаемым образом:

В случае с типом Symbol дело несколько усложняется, так как значения этого типа можно преобразовать к строковому типу только явно. Здесь можно почитать подробности о правилах преобразования типа Symbol.

▍Преобразование к типу Boolean

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

▍Преобразование к типу Number

Неявное приведение значения к числовому типу — тема более сложная, так как оно применяется, пожалуй, чаще чем преобразование в строку или в логическое значение. А именно, преобразование к типу Number выполняют следующие операторы:

Вот как в числа преобразуются примитивные значения:

Вот два особых правила, которые стоит запомнить:

При применении оператора == к null или undefined преобразования в число не производится. Значение null равно только null или undefined и не равно ничему больше.

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

Преобразование типов для объектов

Вот псевдо-реализация метода [[ToPrimitive]] :

В целом, работа алгоритма выглядит следующим образом:

Вот пример поведения Date при преобразовании типов:

Стандартные методы toString() и valueOf() можно переопределить для того, чтобы вмешаться в логику преобразования объекта в примитивные значения.

Метод Symbol.toPrimitive ES6

Разбор примеров

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

Разберём каждый из этих примеров.

▍true + false

Оператор + с двумя операндами вызывает преобразование к числу для true и false :

▍12 / ‘6’

▍«number» + 15 + 3

▍15 + 3 + «number»

▍[1] > null

Оператор сравнения > выполняет числовое сравнение [1] и null :

▍«foo» + + «bar»

▍’true’ == true и false == ‘false’

▍[] + null + 1

Логические операторы || и && в процессе работы приводят значение операндов к логическому типу, но возвращают исходные операнды (которые имеют тип, отличный от логического). Значение 0 ложно, а значение ‘0’ истинно, так как является непустой строкой. Пустой объект <> так же преобразуется к истинному значению.

▍[1,2,3] == [1,2,3]

Этот пример лучше объяснить пошагово в соответствии с порядком выполнения операций.

▍new Date(0) — 0

▍new Date(0) + 0

Итоги

Преобразование типов — это один из базовых механизмом JavaScript, знание которого является основой продуктивной работы. Надеемся, сегодняшний материал помог тем, кто не очень хорошо разбирался в неявном преобразовании типов, расставить всё по своим местам, а тем, кто уверенно, с первого раза, никуда не подсматривая, смог решить «вступительную задачу», позволил вспомнить какой-нибудь интересный случай из их практики.

Уважаемые читатели! А в вашей практике случалось так, чтобы путаница с неявным преобразованием типов в JavaScript приводила к таинственным ошибкам?

Источник