JavaScript и то, что вы о нем не знали логические операции


Оглавление (нажмите, чтобы открыть):

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

В этом уроке описаны логические операторы. JavaScript поддерживает три логических оператора: || (ИЛИ), && (И) и ! (НЕ), которые очень часто используются в условных конструкциях, например if , while или for . Благодаря логическим операторам можно объединять два выражения в одно более сложное.

JavaScript: Табnица истинности

Основными логическими или булевыми операциями, названными в честь одного из математиков — Джорджа Буля (1815-1864), являются:

  • ИЛИ || – логическое сложение (дизъюнкция) – OR;
  • И && – логическое умножение (конъюнкция) – AND;
  • НЕ ! – логическое отрицание (инверсия) – NOT.

Логические операторы работают с операндами так же, как и с булевыми значениями, возвращая true или false , поэтому эти операции можно описать таблицей истинности, в которой полностью описано их поведение:

Табnица истинности дпя логических операторов

X Y X || Y X && Y !X
false false false false true
true false true false false
false true true false true
true true true true false

Из этой таблицы видно, что результатом работы оператора ИЛИ || будет false , только если оба его операнда – false ; результатом оператора И && будет true , только если оба из его операндов – true . Оператор НЕ ! прост – он получает один операнд и возвращает обратное значение.

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

На заметку: Ложными ( false ) значениями являются false , null , undefined , 0 , –0 , NaN и «» (пустя строка). Все другие значения, включая все объекты, являются истинными ( true ).

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

Логический оператор И && выполняет логическую операцию конъюнкции двух булевых значений. Конъюнкция – это сложное логическое выражение, которое считается истинным true только в том случае, когда оба его операнда (выражения) являются истинными true , во всех остальных случаях данное сложное выражение ложно false .

Логические операторы &&, || и ! в JavaScript

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

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

&& — логическое И

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

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

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

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

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

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

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

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

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

  • Число 0 (ноль).
  • Пустая строка «».
  • Логическое значение false 🙂
  • Значение null.
  • Значение undefined.
  • Значение NaN (Not a Number — не число).

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

|| — логическое ИЛИ

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

Логические выражения вычисляются слево направо. Как только оператор ИЛИ обнаружит значение true — он вернёт его, далее вычеслений не будет. Если не встретит ни одно значение true, то вернёт последнее значение, а оно точно будет false. Мы видим, ИЛИ вычисляет ровно столько значений, сколько необходимо.

! — логическое НЕ

Логическое НЕ — унарный оператор. Он принимает операнд и изменяет его значение истина/ложь на противоположное.

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


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

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

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

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

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

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

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

&& вместо if

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

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

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

Системный интегратор

Логические операции в JavaScript и алгебра логики.

Порядок выполнения логических операций:

  1. ! — НЕ (!1 = 0, !0 = 1)
  2. && — И (1 && 1 = 1 В остальных случаях 0 )
  3. || — ИЛИ (0 || 0 = 0 В остальных случаях 1 )

Закон противоречия A && !A = 0 Законисключенного третьего A || !A = 1 Законы де Моргана !(A || B) = !A && !B !(A && B) = !A || !B Законы повторения A && A = A A || A = A Законы исключения констант A && 1 = A A && 0 = 0 Законы склеивания (A && B) || (!A && B) = B (A || B) && (!A || B) = B Коммутативный закон A && B = B && A Ассоциативный закон A && (B && C) = (A && B) && C

JavaScript — Условные и логические операторы

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

Условные операторы JavaScript

Условные операторы — это операторы языка JavaScript (ECMAScript), которые в зависимости от некоторого условия позволяют выполнить одно или несколько определённых инструкций.

Формы условных операторов в JavaScript:

  • условный оператор if (с одной ветвью);
  • условный оператор if. else (с двумя ветвями);
  • условный оператор else if. (с несколькими ветвями);
  • тернарный оператор ( ?: );
  • оператор выбора switch .

Условный оператор if

Синтаксис оператора if:

Условный оператор if состоит из:

  • ключевого слова if ;
  • условия (выражения в круглых скобках), которое должно равняться true или false (или быть приведено к одному из этих значений);
  • инструкции, которую нужно выполнить , если условие является true или приведено к нему.

В этом примере в качестве условия используется значение true . Это означает, что инструкция count = 4 будет выполняться всегда. Данный пример просто приведен для пояснения принципа работы оператора if , т.к. он лишён всякого смысла.

Например , увеличим значение переменной votes на 1, если она (её тип) является числом:

Если необходимо выполнить несколько инструкций, то их необходимо поместить в фигурные скобки :

Рекомендуется, использовать фигурные скобки даже когда используется одна инструкция:

Мастер Йода рекомендует:  Быстрый живой поиск для сайта

Оператор if. else

Оператор if. else используется, когда необходимо при истинности условия выполнить одни инструкции, а при ложности — другие.


Например , выведем в консоль сообщение о том, является ли число четным или нет:

Правило приведения условия к true или false

Если выражение в условии оператора if не равно true или false , то JavaScript приведёт его к одному из этих значений. Данное действие он выполняет с помощью так называемого «правила лжи».

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

  • false (ложь);
  • «» или » (пустая строка);
  • NaN (специальный числовой тип данных «не число»);
  • 0 (число «ноль»);
  • null («пустое» значение);
  • undefined («неопределённое» значение).

Например , выведем в консоль браузера приветственное сообщение, в зависимости от того какое значение хранится в переменной nameUser :

Если переменная nameUser будет содержать пустую строку , то по правилу лжи, она будет приведена к значению false . Следовательно, в консоль будет выведено сообщение «Привет, гость!» .

А если, например, переменная nameUser будет содержать строку «Тимур» , то выражение в условии будет приведено к значению true . В результате, в консоли отобразится сообщение «Привет, Тимур!» .

Оператор else if. (несколько условий)

Условный (тернарный) оператор (?:)

Тернарный оператор – оператор JavaScript, который можно использовать, когда необходимо в зависимости от условия выполнить одно из двух заданных выражений.

Тернарный оператор состоит из трех операндов, которые разделяются с помощью символов ? и : . Условие тернарного оператора задаётся в первом операнде. Его также можно заключить в скобки. Если условие равно true или будет приведено к этому значению будет выполнено выражение1 , иначе — выражение 2 .

В JavaScript допустимы множественные тернарные операторы ( ?: ):

Вышеприведённый пример, но с использованием множественной записи оператора if. else :

Оператор switch

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

Синтаксис оператора switch :

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

Инструкция break является необязательной. Она предназначена для прерывания выполнения оператора switch и передачи управлению инструкции, идущей после него.

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

В вышеприведенном примере вычисленное выражение равно 3. Следовательно, будет выполнены инструкции message = ‘Две или три конфеты’ и break . Инструкция break прервёт дальнейшее выполнение оператора switch и передаст управление инструкции, идущей после него, т.е. console.log(message) . Она выведет в консоль сообщение «Две или три конфеты» .

Например , выведем выведем в консоль текущий день недели:

Пример, в котором не используется инструкция break :

В этом примере выражение оператора switch равно success . Следовательно, будет выполнена инструкция console.log(‘Успех!’) , которая выведет сообщение «Успех!» в консоль. Но так как после неё нет инструкции break , то выполнение скрипта будет продолжено в следующем варианте. Таким образом, инструкции будут выполняться до тех пока пока на пути не встретиться break или не будет достигнут конец оператора switch . В результате выполнения этого примера в консоль будут выведены 3 сообщения: «Успех!» , «Неверная капча!» и «Ошибка!» .

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

Исправленный вариант примера:

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

В JavaScript различают следующие логические операторы:

Если в логическом выражении operand1 || operand2 используются булевы значения, то результатом этого выражения будет значение true , если хотя бы один из них равен true ; иначе значением этого выражения будет значение false .

Если в логическом выражении operand1 || operand2 используются не булевы значения, то результатом этого выражения будет operand1 , если его можно привести к true ; иначе результатом этого выражения будет operand2 .

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

12 хитростей JavaScript, которых вы не найдете в большинстве уроков

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


С тех пор я пополняю этот список, и в этой статье я поделюсь 12 советами, которые кажутся мне особенно умными или полезными.

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

Итак, вот 12 изящных способов написания более лаконичного и производительного кода.

1. Фильтр уникальных значений

Тип Set был введен в ES6, и наряду с оператором «spread» . мы можем использовать его для создания нового массива с уникальными значениями.

До ES6 фильтрация уникальных значений потребовала бы гораздо больше кода, чем сейчас!

Этот трюк работает для массивов, содержащих примитивные типы: undefined, null, boolean, string и number. (Если бы у вас был массив, содержащий объекты, функции или дополнительные массивы, вам понадобился бы другой подход!)

2. Кешируем длину массива в циклах

Когда нас учат циклам for, нам рекомендуется следовать этой стандартной структуре:

Однако, используя этот синтаксис, цикл for пересматривает длину массива при каждой итерации.

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

Этот код почти такой же лаконичный, как и приведенный выше, но он работает таким образом, что при увеличении размера массива мы не теряем время на перепроверку array.length .

3. Вычисление короткого замыкания

Тернарный оператор — это быстрый способ написать простые (а иногда и не очень простые) условные конструкции, например:

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

Как это работает

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

Использование && вернет первое false или ‘ложноe’ значение. Если каждый операнд оценивается как true, будет возвращено последнее вычисленное выражение.

Использование || вернет первое true или ‘правдивоe’ значение. Если каждый операнд оценивается как false , будет возвращено последнее вычисленное выражение.

Пример 1

Допустим, мы хотим вернуть свойство length переменной, но мы не знаем её тип.

Мы можем использовать оператор if/else оператор для проверки, что foo это приемлемый тип, однако это может быть довольно долго. Короткое замыкание позволяет сделать это таким образом:

Если переменная foo имеет свойство length, оно будет возвращено. В противном случае вернется length пустого массива: 0.

Пример 2

Были ли у вас проблемы с доступом к вложенному объекту? Вы можете не знать, существует ли у объекта свойство или одно из под-свойств, и это может вызвать неприятные ошибки.

Допустим, мы хотели получить доступ к свойству data , которое находится внутри this.state , но data — undefined до тех пор, пока программа не вернет респонз.

В зависимости от того, где мы используем этот код, вызов this.state.data может помешать запуску нашего приложения. Чтобы обойти это, мы могли бы обернуть все в условное выражение:

Это кажется довольно скучным. Оператор «или» предоставляет более краткое решение:

Мы не можем изменить код выше, чтобы использовать && . Утверждение ‘Fetching Data’ && this.state.data вернется this.state.data независимо от того, равно оно undefined или нет. Это потому, что ‘Fetching Data’ «правдиво», и поэтому && всегда будет пропускать его, когда он указан первым.

Новая предлагаемая фича: опциональная последовательность

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

Например, мы могли бы привести свой пример выше к this.state.data?.() — вернет data, только если оно не null .

Или, если мы сомневаемся в переменной state , мы могли бы вернуть this.state?.data .


Предложение в настоящее время находится на Stage 1 в качестве экспериментальной функции. Вы можете прочитать об этом тут, и можете использовать его в своем JavaScript через Babel, добавив @babel/plugin-proposal-optional-chaining в ваш .babelrc файл.

Мастер Йода рекомендует:  GUI в Java c помощью JFace Создание окна приложения

4. Преобразование в Boolean

Помимо обычных логических значений true и false, JavaScript также обрабатывает все другие значения как «правдивые» или «ложные».

Если не указано иное, все значения в JavaScript являются «правдивыми» за исключением 0, «», null, undefined, NaN и, конечно false — которые являются «falsy».

Мы можем легко переключаться между true и false, используя отрицательный оператор !, который также преобразует тип в «boolean» .

Этот тип преобразования типов может быть полезен в условных выражениях, хотя единственная причина, по которой вы бы решили определить false как !1, это если бы вы играли в code golf!

5. Преобразование в String

Чтобы быстро преобразовать число в строку, мы можем использовать оператор конкатенации + , за которым следует пустой набор кавычек «» .

6. Преобразование в Number

Обратное можно быстро сделать с помощью оператора сложения + .

Это также может быть использовано для преобразования boolean в числа, как показано ниже:

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

Тильда, известная как «побитовый оператор НЕ», является оператором, эквивалентным -n — 1 . Так, например,

Использование двух тильд подряд отрицает операцию, потому что — ( — n — 1) — 1 = n + 1 — 1 = n . Другими словами,

Хотя я не могу придумать много вариантов использования, но побитовый оператор NOT также можно использовать в логических значениях:

7. Быстрое возведение в степень

Начиная с ES7 стало возможным использовать оператор возведения в степень ** как сокращение для степеней, что быстрее, чем запись Math.pow(2, 3). Это простой материал, но он попал в список, потому что не так много учебных содержит этот оператор!

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

До ES7 сокращение существовало только для степеней с основанием 2 с использованием оператора побитового сдвига влево FrontEndDev и Web Stack в Telegram, чтобы не пропустить самое интересное из мира Web!

JavaScript и то, что вы о нем не знали: логические операции

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

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

Таблица 1. Логические операции
Операция Результат
|| Логическое ИЛИ
&& Логическое И
! Логическое НЕ

Рассмотрим примеры использования логических операций.

Результат работы скрипта приведен на рисунке 1.

Рис.1. Использование логических операций

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

Начнем с последнего оператора присваивания. Вам известно, что отрицание «лжи» есть «истина» и наоборот. Предпоследнее присваивание говорит нам о том, что в JavaScript «ложью» являются значения null (пусто), 0, пустая строка («») или undefined (неопределенное значение). Значение переменной var1 отлично от вышеперечисленных, поэтому оно рассматривается как «истина», а отрицание «истины» есть «ложь».

Обратимся теперь к первым трем оператором присваивания. Наиболее простым из них является конструкция b = var2 && var3; : так как один из операндов есть «ложь» и используется операция логическое И , то результат, естественно, будет «ложь».

Первый оператор присваивания JavaScript выполняет, пользуясь следующим правилом: операция «Логическое И» возвращает значение первого операнда, если его можно конвертировать в «ложь»; иначе, возвращает значение второго операнда.

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

Для выполнения третьего оператора присваивания воспользуйтесь следующим правилом: операция «Логическое ИЛИ» возвращает значение первого операнда, если его можно конвертировать в «истину»; иначе, возвращает значение второго операнда. Проведите аналогичные рассуждения для третьего оператора присваивания.

Замечание . Напоминаем, что эти правила используются только тогда, когда ни один из операндов не является логическим. Если хотя бы один из операндов имеет значение логического типа, то операции || и && выполняются обычным образом. Измените последний скрипт следующим образом и объясните результаты:

  • var1 = «»;
  • var1 = fasle;
  • var2 = 0;
  • var2 = fasle;
  • var3 = «Собака»;
  • var3 = 0;
  • var3 = -1;


На следующем шаге мы рассмотрим функции в JavaScript .

JavaScript и то, что вы о нем не знали: логические операции

61439 просмотра

13 ответа

5118 Репутация автора

Почему в JavaScript нет логического xor?

Ответы (13)

4 плюса

301549 Репутация автора

Вы можете имитировать это примерно так:

Автор: Sarfraz Размещён: 27.12.2010 05:17

9 плюса

19977 Репутация автора

или проще читать:

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

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

Я лично думаю, что у него есть исторические причины, которые берут начало от языков синтаксиса на основе c, где, насколько мне известно, xor отсутствует или, по крайней мере, крайне необычен.

315 плюса

243719 Репутация автора

JavaScript ведет свое происхождение от C, а C не имеет логического оператора XOR. Главным образом потому, что это не полезно. Побитовое XOR чрезвычайно полезно, но за все мои годы программирования мне никогда не требовался логический XOR.

Если у вас есть две логические переменные, вы можете имитировать XOR с помощью:

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

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

67 плюса

5216 Репутация автора

В JavaScript есть побитовый оператор XOR: ^

Вы можете использовать его с логическими значениями, и результат будет равен 0 или 1 (например, вы можете преобразовать его обратно в логическое значение result = !!(op1 ^ op2) ). Но, как сказал Джон, это эквивалентно result = (op1 != op2) , что более понятно.

Автор: Pikrass Размещён: 27.12.2010 05:24

27 плюса

2066 Репутация автора

В Javascript нет реальных логических логических операторов (хотя это ! довольно близко). Логический оператор будет принимать только true или false как операнды и будет только возвращать true или false .

В Javascript && и || принимайте всевозможные операнды и возвращайте всевозможные забавные результаты (что бы вы ни вводили в них).

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


В Javascript && и || ленивый ярлык и не оценивают второй операнд в определенных случаях и тем самым пренебрегают его побочными эффектами. Такое поведение невозможно воссоздать с логическим xor.

a() && b() оценивает a() и возвращает результат, если он ложный. В противном случае он оценивает b() и возвращает результат. Следовательно, возвращаемый результат верен, если оба результата верны, и ложен в противном случае.

a() || b() оценивает a() и возвращает результат, если он правдив. В противном случае он оценивает b() и возвращает результат. Следовательно, возвращаемый результат ложен, если оба результата ложны, и истинен в противном случае.

Итак, общая идея — сначала оценить левый операнд. Правильный операнд оценивается только при необходимости. И последнее значение — результат. Этот результат может быть чем угодно. Объекты, числа, строки . что угодно!

Это позволяет писать такие вещи, как

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

Это позволяет писать такие вещи, как

Но «логический» оператор xor ( ^^ ) всегда должен оценивать оба операнда. Это отличает его от других «логических» операторов, которые оценивают второй операнд только при необходимости. Я думаю, именно поэтому в Javascript нет «логического» xor, чтобы избежать путаницы.

Так что же должно произойти, если оба операнда ложные? Оба могут быть возвращены. Но только один может быть возвращен. Который из? Первый? Или второй? Моя интуиция подсказывает мне вернуть первые, но обычно «логические» операторы, вычисленные слева направо, и вернуть последнее оцененное значение. Или, может быть, массив, содержащий оба значения?

И если один операнд является правдивым, а другой — ложным, xor должен возвращать правдивый. Или, может быть, массив, содержащий истинный, чтобы сделать его совместимым с предыдущим случаем?

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

При использовании массива вы получите такие условия, как if ((a ^^ b).length !== 1) < . Очень запутанно.

Автор: Robert Размещён: 14.03.2012 01:23

4 плюса

2688 Репутация автора

Как насчет преобразования результата int в bool с двойным отрицанием? Не очень красиво, но очень компактно.

-2 плюса

7333 Репутация автора

Попробуйте это коротко и легко понять

Это будет работать для любого типа данных

7 плюса

1241 Репутация автора

Да, просто сделай следующее. Предполагая, что вы имеете дело с логическими значениями A и B, тогда значение XOR B можно вычислить в JavaScript с помощью следующего

Предыдущая строка также эквивалентна следующей

Лично я предпочитаю xor1, так как мне приходится печатать меньше символов. Я считаю, что xor1 тоже быстрее. Он просто выполняет два вычисления. xor2 выполняет три вычисления.

Визуальное объяснение . Прочитайте приведенную ниже таблицу (где 0 обозначает ложь, а 1 обозначает истину) и сравнивает 3-й и 5-й столбцы.

Автор: asiby Размещён: 05.08.2013 06:14

2 плюса

7333 Репутация автора

В приведенной выше функции xor это приведет к ПОДОБНОМУ результату, так как логический xor не совсем логический xor, означает, что это приведет к «false для равных значений» и «true для разных значений» с учетом соответствия типов данных.

Эта функция xor будет работать как фактический xor или логический оператор , это означает, что она будет иметь значение true или false в соответствии с передаваемыми значениями true или false . Используйте в соответствии с вашими потребностями

6 плюса

2396 Репутация автора

XOR двух логических выражений просто означает, отличаются ли они, поэтому:


Автор: DomQ Размещён: 25.06.2015 07:38

плюса

1 Репутация автора

Причина отсутствия логического XOR (^^) в том, что в отличие от && и || это не дает никакого ленивого логического преимущества. Это состояние обоих выражений справа и слева должны быть оценены.

плюса

3139 Репутация автора

В Typescript (+ меняется на числовое значение):

плюса

2326 Репутация автора

Вы используете тот факт, что cond1 xor cond2 эквивалентно cond1 + cond 2 == 1 :

Javascript логические операторы и результаты

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

Так каков результат логических операторов? Если один операнд равен 0 или 1, тогда он работает как ожидалось. Если оба отличны от нуля и отличны от 1, то

  1. В случае логического or возвращается первый операнд
  2. В случае логического and возвращается второй операнд

Это общее правило?

Еще одна вещь, которую я не знаю, это оператор | ,

Я попробовал оператора | и получил разные результаты:

Что на самом деле делает этот оператор?

2 ответа

Поскольку javascript не является типизированным языком, любой объект может быть использован в логических операторах, если этот объект имеет значение null, ложное логическое значение, пустую строку, 0 или неопределенную переменную, то он действует как false если это что-то еще, то это как true

В конце логической операции возвращается последнее проверенное значение.

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

Это действительно так же, как в

Остановите операцию и верните последнее проверенное значение: 0.

| Оператор — это совсем другое, он просто выводит логическое ИЛИ на биты входных значений, как объяснено в другом ответе с помощью akp.

Почему логические операторы (&& и ||) всегда возвращают логический результат?

Почему эти логические операторы возвращают объект, а не логическое?

Я хочу понять, почему он возвращает результат obj.fn() (если он определен) OR obj._ , но не boolean result.

будет возвращать значение boolean.

Обратите внимание, что это основано на моем тестировании. Я не должен полностью полагаться.

Это выражение, которое не присваивает true или false значение. Скорее он присваивает вычисленное значение.

Посмотрим на это выражение.

В JavaScript, как || и && являются логическими операторами короткого замыкания, которые возвращают первое полностью определенное «логическое значение» при оценке слева направо.


В выражении X || Y сначала оценивается X и интерпретируется как булево значение. Если это логическое значение «true», оно возвращается. И Y не оценивается. (Потому что неважно, является ли Y истинным или Y является ложным, X || Y полностью определено.) Это часть короткого замыкания. Если это логическое значение является «ложным», мы до сих пор не знаем, является ли X || Y истинным или ложным, пока мы не оценим Y и не интерпретируем его как булево значение. Затем возвращается Y.

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

Первая сложная часть состоит в том, что, когда выражение оценивается как «истина», возвращается само выражение. Что считается «истинным» в логических выражениях, но вы также можете его использовать. Вот почему вы видите возвращаемые фактические значения.

Вторая сложная часть заключается в том, что когда выражение оценивается как «ложное», то в JS 1.0 и 1.1 система возвращает логическое значение «false»; тогда как в JS 1.2 на нем возвращается фактическое значение выражения.

В JS, null, false, 0, «» и undefined все считаются ложными.

[Здесь я, конечно, цитирую логические значения для обсуждения. Конечно, буквальная строка «f a l s e» «false» не совпадает с значением false, и поэтому является истиной. ]

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

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

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

Логические операции JavaScript

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

&&- оператор логическое И вернет true, только если 2 операнда сравнения тоже возвращают true, в других случаях вернет false:

|| оператор логическое ИЛИ возвращает true, если хотя бы один операнд сравнения возвращают true, в другом случае вернет false:

! оператор логическое НЕ Возвращает true, если операнд сравнения возвращает ложь то есть все наоборот:

Операции со строками в JavaScript.

Строки как и числа также могут использовать оператор + для склеивания строк или конкатенации. Например:

Если надо переменную вставить в строке, которая выводится на экран то это тоже можно сделать с помощью оператора «+».

По новому стандарту JS2015 для того чтобы в строку вставить переменную необязательно использовать оператор «+», а сделать так:

То есть строка заключается в обратные одинарные кавычки `, находятся там где клавиша ё в английской раскладке клавиатуры, а переменная помещается в конструкцию $<> при этом не надо разрывать строку и ставить знак «+».

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

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

Здесь в нашем сценарии создаются 3 переменные: summa, procent и itog. Переменная itog будет вычисляться по остальным 2 переменным с помощью соответственно операций умножения и деления. И в самом конце ее значение будет суммироваться со значением переменной summa.

ЗАДАНИЯ:

Что выведет alert (ИЛИ)?

Что будет в результате выполнения этого кода?

Что выведет alert (ИЛИ)?

Что будет в результате выполнения этого кода?

Что выведет alert (И)?

Что будет в результате выполнения этого кода?

Что выведет alert (И)?

Что будет в результате выполнения этого кода?

Что выведет этот код?

Что будет в результате выполнения этого кода?

В заключении смотрите видео о логических операторах в JavaScript.

Мастер Йода рекомендует:  Контролируемая отдача файлов PHP
Добавить комментарий