Как в js пишется логическое или

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

Для операций над логическими значениями в JavaScript есть || (ИЛИ), && (И) и ! (НЕ).

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

|| (ИЛИ)

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

Логическое ИЛИ в классическом программировании работает следующим образом: «если хотя бы один из аргументов true , то возвращает true , иначе – false «. В JavaScript, как мы увидим далее, это не совсем так, но для начала рассмотрим только логические значения.

Получается следующая «таблица результатов»:

Если значение не логического типа – то оно к нему приводится в целях вычислений. Например, число 1 будет воспринято как true , а 0 – как false :

Обычно оператор ИЛИ используется в if , чтобы проверить, выполняется ли хотя бы одно из условий, например:

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

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

JavaScript вычисляет несколько ИЛИ слева направо. При этом, чтобы экономить ресурсы, используется так называемый «короткий цикл вычисления».

Допустим, вычисляются несколько ИЛИ подряд: a || b || c || . . Если первый аргумент – true , то результат заведомо будет true (хотя бы одно из значений – true ), и остальные значения игнорируются.

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

При запуске примера ниже присвоение x не произойдёт:

…А в примере ниже первый аргумент – false , так что ИЛИ попытается вычислить второй, запустив тем самым присваивание:

Значение ИЛИ

|| запинается на «правде»,
&& запинается на «лжи».

Илья Канатов, участник курса JavaScript

Итак, как мы видим, оператор ИЛИ вычисляет ровно столько значений, сколько необходимо – до первого true .

При этом оператор ИЛИ возвращает то значение, на котором остановились вычисления. Причём, не преобразованное к логическому типу.

Это используют, в частности, чтобы выбрать первое «истинное» значение из списка:

Если все значения «ложные», то || возвратит последнее из них:

Итак, оператор || вычисляет операнды слева направо до первого «истинного» и возвращает его, а если все ложные – то последнее значение.

Иначе можно сказать, что » || запинается на правде».

&& (И)

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

В классическом программировании И возвращает true , если оба аргумента истинны, а иначе – false :

Как и в ИЛИ, в И допустимы любые значения:

К И применим тот же принцип «короткого цикла вычислений», но немного по-другому, чем к ИЛИ.

Если левый аргумент – false , оператор И возвращает его и заканчивает вычисления. Иначе – вычисляет и возвращает правый аргумент.

Можно передать и несколько значений подряд, при этом возвратится первое «ложное» (на котором остановились вычисления), а если его нет – то последнее:

Итак, оператор && вычисляет операнды слева направо до первого «ложного» и возвращает его, а если все истинные – то последнее значение.

Иначе можно сказать, что » && запинается на лжи».

Приоритет у && больше, чем у ||

Приоритет оператора И && больше, чем ИЛИ || , так что он выполняется раньше.

Поэтому в следующем коде сначала будет вычислено правое И: 1 && 0 = 0 , а уже потом – ИЛИ.

Не используйте && вместо if

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

Действие в правой части && выполнится только в том случае, если до него дойдут вычисления. То есть, alert сработает, если в левой части будет true .

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

! (НЕ)

Оператор НЕ – самый простой. Он получает один аргумент. Синтаксис:

1. Сначала приводит аргумент к логическому типу true/false .
2. Затем возвращает противоположное значение.

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

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

Логические операторы выступают в роли особенных символов, предназначенных для объединения или изменения логических выражений. В языке программирования JavaScript есть четыре основных логических оператора: «и» (`&&`), «или» (`||`), «не» (`!`) и оператор нулевого слияния (`??`).

Истинные и ложные значения

Истинные значения — это значения, которые при приведении к логическому типу с помощью функции Boolean( ) выведут true, например:

const num = 7; console.log(Boolean(num)) // выведет true

Ложные значения — это значения, которые при приведении к логическому типу выводят false. В логическом преобразовании существует шесть ложных значений: false, null, undefined, NaN, пустая строка и 0. Все остальное приводится к true.

Оператор «и» (`&&`)

JavaScript Оператор «и» возвращает последнюю истину, когда оба его операнда истинны. Если хотя бы один из операндов ложный — возвращается первая ложь. В случае если левый операнд был приведен к false, правый может не вычисляться.

let a = true; let b = false; let e = a && b; // e = false, так как один из операндов false let d = a && true; // d = true, так как оба операнда true

Логическое «и» запинается на лжи и возвращает то, на чем остановилось. Если ложных значений нет — выводится последний операнд.

let a = "Апельсин"; let b = 0; let c = 7; let d = a && b; // d = 0 let e = a && c; // e = 7

Оператор `&&` обладает более высоким приоритетом по сравнению с оператором `||`(«или»), что гарантирует его выполнение в первую очередь. Рассмотрим пример:

let a = "Апельсин"; let b = 0; let c = 7; let f = a || b && c; // f = "Апельсин", сначала выполняется И, а потом ИЛИ let g = (a || b) && c; // g = 7, сначала выполняется то, что в скобках

Оператор «и» используется для проверки нескольких условий одновременно. Например, мы хотим выполнить какое-то действие только тогда, когда пользователь авторизован и находится онлайн:

if (user.isAuthorized && user.isOnline) < // выполнить действие >

Книги для развития Soft Skills

7 янв. 2024 г.

Топ 11 книг как стать эффективнее

4 янв. 2024 г.

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

Операторы в JavaScript делятся на два основных типа: унарные и бинарные (есть еще тернарный оператор, но он всего один и о нем немного позже). Отличие между ними в том, что унарные работают только с одним операндом (примитивом или выражением), а бинарный с двумя или более. Проще всего это продемонстрировать на операторе “ + ”. В бинарном виде он складывает значения. При этом значениями могут быть не только числа, но и строки и в случае, если один из операндом строка — второй тоже будет преобразован в строку, а в унарном — пытается преобразовать строку в число. При этом унарный и бинарный плюс можно комбинировать:

console.log(1 + 2); //число 3 //бинароный плюс с числами console.log("1" + "2"); //12 строкой //банрный плюс со строками console.log(1 + "2"); //12 строкой //бинарный плюс со строкой и числом console.log(+"2"); //число 2 //унареый плюс со строкой console.log(+"строка без цифр"); //NaN //если в троке нет цифр, вернет NaN console.log(1 + +"2");//число 3 //комбинация бинарного и унарного плюса

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

console.log(-"-1");//число 1 console.log(+"-1");//число -1

• Умножение “ * ” — бинарный оператор, который умножает первый операнд на второй.
• Возведение в степень “ ** ” бинарный оператор, который возводит первый операнд в степень, указанную во втором.
• Деление “ / ” бинарный оператор, который делит первый операнд на второй.
• Остаток от деления “ % ” бинарный операнд, который возвращает остаток при делении нацело первого операнда на втрой. Часто используется для нахождения четных и нечетных чисел или кратных чисел.

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

console.log(5 * "2"); //число 10 console.log("5" ** "2"); //число 25 console.log("5" / 2); //число 2.5 console.log("5" % "2"); //число 1

Кроме того в JavaScript есть еще два унарных математических оператора: “`++`” инкремент и “`—`” декремент. Это просто синтаксический сахар, заменяющий прибавление или отнимание единицы. Пишутся они до или после операнда без пробела. Операндом могут быть только переменные, значения которых будут приведены к числу. При этом есть разница в том где они указаны. Оба вида записи изменяют значение переменной, но при указании до переменной оператор возвращает измененное значение, а при указании после — исходное.

let counter1 = 0; console.log(++counter1); //1 let counter2 = "0"; console.log(counter2++); //0 //обе переменные были увеличены на 1 console.log(counter1); //1 console.log(counter2); //1

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

Логические операторы в JavaScript следуют следующим правилам:

• ссылочные типы данный сравниваются по ссылке, а не по значению. Т.е. два массива с одинаковыми значениями, объекта с одинаковыми полями и т.д. не будут равны друг другу, а ссылки на них — да.
• Строки сравниваются посимвольно используя для сравнения каждого символа кодировку Unicode (фактически сравниваются не сами символы, а их код в кодировке).
• При сравнении разных примитивных типов данных они приводятся к числу.

Их можно разделить на строгие и не строгие. Всего существует шесть “нестрогих” операторов сравнения:

• “ > ” больше и “ < ” меньше - возвращает результат сравнения первого операнда со вторым.
• “ > = ” больше или равно и “ < = ” меньше или равно - то же, что предыдущие, но возвращают true и если операнды равны.
• “ == » равенство по значению — возвращает true, если значения операндов равны.
• “ ! = ” неравенство по значению — наоборот вернет true только если значения не равны.

console.log(1 > "1"); //false console.log(1 >= "1"); //true console.log(1 == "1"); //true console.log(1 != "1"); //false const a = [1, 2]; //массив это ссылочный тип данных console.log(a == [1, 2]); // false //поэтому сравнение его с лругим массивом всегда вернет false const b = a; console.log(a == b); //true //обе переменные ссылаются на один массив и сравнение вернет true

В реальных проектах равенство и неравенство по значению применяется очень редко из-за того что они могут возвращать true при сравнении разных типов данных. Вместо них рекомендуется использовать “строгие” варианты операторов “`===`” для равенства и “`! ==`” для неравенства. Эти операторы сравнивают не только значения, но и типы данных операндов.

console.log(1 == "1"); //true console.log(1 === "1"); //false console.log(1 != "1"); //false console.log(1 !== "1"); //true

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

console.log(null > 0); //false console.log(null == 0); //false console.log(null >= 0); //true console.log(undefined > 0); //false console.log(undefined < 0); //false console.log(undefined == 0); //false

Null приводится к числу со значением 0 только при сравнении через операторы `≤` b `≥`, а в остальных случаях остается собой. Undefined при любом сравнении выдает false потому что при приведении к числу возвращает NaN. При этом нестрогое сравнение null и undefined вернет true.

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

Существует 4 логических оператора:

• “ || ” логическое “ИЛИ”- бинарный оператор, который возвращает первое истинное значение т.е. проходится по всем операндам, проверяя их на преобразование в булево значение и возвращает первый операнд из цепочки, который при преобразовании в булево значение будет равен true. Если все значения ложные - возвращает последнее. Часто используется для записи условий с диапазонами доступных значений.
• ts function check(hour) = 8 || hour = 13 || hour else < return "closed";//если не соответствует ни одному >> “ && ” логическо “И” - бинарный операнд, который возвращает первое ложное значение или, если такого нет, возвращает последний операнд. Часто используется для проверки выполнения нескольких условий.
• ts const visitDateTime = < time: 12, dayOfWeek: "Monday" >; function check(dateTime) < if (dateTime.time >= 10 && dateTime.dayOfWeek !== "Sunday") < //если визит назначен не раньще 10 часов и не в всокресенье return "confirmed";//при выполнении обоих условий >else < return "unconfirmed";//при невыполнении хотя бы одного условия >> “ ?? ” оператор нулевого слияния - возвращает первое определенное (не равное null или undefined) значение или , если такого нет, возвращает последний операнд. Часто используется для задания значения по умолчанию.
• ts let first; //значение неопределено let second = undefined; // явно указан undefined let third = null; //явно указан null let fourth = "fourth"; // любое другое значение кроме undefined или null const res = first ?? second ?? third ?? fourth; console.log(res); //fourth //часто используется для установки значений по умолчанию let role; const userRole = role ?? "user"; console.log(userRole); //user “ ! ” логическое “НЕ” - унарный оператор который приводит операнд к виду булева значения и меняет его на противоположное. Часто используется для создания проверки на отсутствие каких-то данных или изменение переменных, содержащих булевы значения.

const userData = ""; //данные не заполнены или не пришли if (!userData) < console.log("Введите данные!"); >//берет пустую строку, которая после приведения к булеву // значению равна false и меняет его на true //т.е. условие в if() сработает let isReady = false; isReady = !isReady;//изменяет значение на противоположное console.log(isReady); //true

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

Кроме обычного оператора присваивания (” = ”) в JavaScript существуют бинарные операторы присваивания с операцией и операторы логического присваивания. Первые позволяют вместо простого присваивания переменной нового значения произвести операцию над его текущим значением. Синтаксис операторов присваивания с операцией объединяет синтаксис оператора нужной арифметической операции и простого присваивания (” *= ” - присваивание с умножением, “ += ” - присваивание со сложением и т.д.). Его вторым оперантом могут быть как числа, так и строки или переменные их содержащие.

let a = 2; let b = 4; b += 1; //b = 5 (5+1) b *= a; //b = 10 (5*2)

Операторы логического присваивания ”`||=`” - присвоение через логическое “ИЛИ”, “`&&=`" - присвоение через логическое “И” и “`??=`” - оператор нулевого присвоения ведут себя схоже со своими логическими собратьями, но вместо первого операнда используют текущее значение переменной.

const userData1 = < name: "", role: "user", age: undefined >; userData1.name ||= "John"; //поле имя имело ложное значение и будет изменено userData1.role ||= "admin"; //роль не была ложным значением и не будет изменена userData1.age ||= 22; //возраст был ложным значением и будет изменен console.log(userData1); // < name: 'John', role: 'user', age: 22 >const userData2 = < name: "", role: "user", age: undefined >; userData2.name &&= "John"; //поле имя имело ложное значение и не будет изменено userData2.role &&= "admin"; //роль не была ложным значением и будет изменена userData2.age &&= 22; //возраст был ложным значением и не будет изменен console.log(userData2); // < name: '', role: 'admin', age: undefined >const userData3 = < name: "", role: "user", age: undefined >; userData3.name ??= "John"; //поле имя не равно ни null ни undefined и не изменится userData3.role ??= "admin"; //роль не равна ни null ни undefined и не изменится userData3.age ??= 22; //возраст равен undefined и будет изменен console.log(userData3); //

Тернарный оператор

Единственным оператором в JavaScript, который принимает три операнда является тернарный оператор. Он принимает условие и два выражения ( условие ? выражение1 : выражение2 ), после чего возвращает первое выражение, если условие истинно или второе, если условие ложно.

const condition = 1; console.log(condition ? "first" : "second");//first //условие истино и вернется первое выражение condition = 0 console.log(condition ? "first" : "second");//second //условие ложно и вернется второе выражение

Операторы доступа к свойствам объектов и optional chaining

Так же в JavaScript операторами считаются точка при обращении к свойствам объектов или квадратные скобки при обращении к элементам массивов. Кроме этих операторов существует оператор опциональной цепочки (optional chaining) ” ?. ", который позволяет обратиться к свойству объекта только при его наличии не ломая исполнение кода. При этом его можно использовать и для обращения через квадратные скобки или вызове функции, являющейся свойством объекта.

const user1 = < name: "John" >; const usersDogName = user1.pets.dog.name; console.log(dog); //TypeError: Cannot read properties of undefined (reading 'dog') const usersCatName = user1.pets?.cat.name; console.log(usersCatName); //undefined //обращение через квадратные скобки const user2 = null; console.log(user2[name]); //ReferenceError: name is not defined console.log(user2?.[name]); //undefined //обращение к функции const someFuncs = < foo() < console.log("foo"); >, >; someFuncs.bar(); //TypeError: someFuncs.bar is not a function someFuncs.bar?.(); //гтчего не произойдет

Оператор “запятая”

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

const a = (1, 2, 3); console.log(a); //3 const myArr = [ //массив из 10 элементов, каждый элемент //которого тоже массив из 10 элементов ]; for (let i = 0, j = 9; i let a = 1,b = 2,c = 3,d = 4; //объявление нескольких переменных в одну строку

Побитовые операторы

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

Существует семь побитовых операторов:

• “ & ” побитовое “И” - бинарный оператор, который возвращает число, состоящее из битов, которые равны 1 у обоих чисел. Например, если a = 1011 и b = 1101, то a & b = 1001.
• “ | ” побитовое “ИЛИ” - бинарный оператор, который возвращает число, состоящее из битов, которые равны 1 хотя бы у одного из чисел. Например, если a = 1011 и b = 1101, то a | b = 1111.
• “ ^ ” побитовое “ИСКЛЮЧИТЕЛЬНОЕ ИЛИ” - бинарный оператор, который возвращает число, состоящее из битов, которые равны 1 только у одного из чисел. Например, если a = 1011 и b = 1101, то a ^ b = 0110.
• “ ~ ” побитовое “НЕ” - унарный оператор, который возвращает инвертированное число, т.е. число, где все биты перевернуты. Если a = 1011, то ~a = 0100.
• “ > ” левый и правый сдвиг - бинарные операторы, которые сдвигают биты числа a на b позиций влево или вправо соответственно, добавляя нули справа. Это эквивалентно умножению числа на 2(при левом сдвиге), возведённое в степень b или делению числа на 2(для правого сдвига), возведенное в степень b.
• “ >>> ” правый сдвиг с заполнением нулями - бинарный оператор, который действует как обычный правый сдвиг, но слева добавляются нули, а в отрицательных числах отбрасывается знак.

Следует отметить, что все числа сначала преобразуются в 32-битные перед применением операции. Результат также представляется как 32-битное целое. Для сокращения записи пример ниже будет представлен 4-битной виде.

const a = 12; // в двоичной системе: 1100 const b = 15; // в двоичной системе: 1111 console.log(a & b); // результат: 12 (в двоичной системе: 1100) const a = 12; // в двоичной системе: 1100 const b = 15; // в двоичной системе: 1111 console.log(a | b); // результат: 15 (в двоичной системе: 1111) const a = 12; // в двоичной системе: 1100 const b = 15; // в двоичной системе: 1111 console.log(a ^ b); // результат: 3 (в двоичной системе: 0011) const a = 12; // в двоичной системе: 1100 console.log(~a); // результат: -13 // Причина в том, что в компьютерах числа хранятся в дополнительном коде, // поэтому результат операции ~a будет равен -(a + 1). const a = 3; // в двоичной системе: 11 console.log(a > 2); // результат: 3 (в двоичной системе: 11) // Это эквивалентно делению числа 12 на 2 в степени 2 (12 / (2**2) = 3) const a = -12; // в двоичной системе: 1100 console.log(a >>> 2); // результат: 1073741821 // Этот оператор сдвигает все биты кправо и заполняет биты слева нулями. // Это отличается от >> тем, что >> сохраняет знак числа, // а >>> игнорирует знак и всегда добавляет нули слева.

Приоритет операторов и их группировка

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

console.log(1 + +"2"); //число 3 //сначала сработал унарный плюс, а потом бинарный console.log(+(1 + "2")); //число 12 // если изменить порядок срабатывания операторов с помощью //группировки скобками мы получим другой результат

Заключение:

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

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

Логический оператор ИЛИ ( || ) (дизъюнкция) для набора операндов истинен будет true только в случае, если один или несколько его операндов имеют значение true .

Обычно используется с булевыми (логическими) значениями. Тогда возвращается булевое значение. Однако фактически оператор || возвращает значение одного из операндов, поэтому если этот оператор используется с небулевыми значениями, он вернет небулевое значение.

Интерактивный пример

Синтаксис

|| expr2; 

Описание

Если expr1 может быть преобразовано в true , то вернётся expr1 ; в противном случае возвращается expr2 .

Если значение может быть преобразовано в true , то оно рассматривается как истиноподобное (truthy). Если же значение может быть преобразовано в false , то оно называется ложноподобным (falsy).

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

• null ;
• NaN ;
• 0 ;
• пустая строка ( "" , '' , `` );
• undefined .

Несмотря на то, что оператор || может использоваться с операндами без логических значений, это всё равно булевый оператор, поскольку его возвращаемое значение всегда можно преобразовать в булевый примитив. Чтобы явно преобразовать возвращаемое значение этого оператора (или вообще любое выражение) в соответствующее значение булевого типа, используйте двойной оператор НЕ или конструктор Boolean (en-US).

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

Оператор логического ИЛИ вычисляется слева направо, делая возможным сокращённое вычисление выражения, согласно следующему правилу:

(истинноподобное выражение) || следующее выражение — вычисление останавливается на истинноподобном выражении;

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

function A()  console.log("вызвана функция A"); return false; > function B()  console.log("вызвана функция B"); return true; > console.log(B() || A()); // В результате вызова функции B, в консоли будет выведено "вызвана функция B", // а далее в консоли появится false (это результат оператора) 

Приоритет операторов

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

true || (false && false); // вернёт true, поскольку сначала вычисляется && (true || false) && false; // вернёт false, поскольку у группировки выше приоритет 

Примеры

Использование оператора ИЛИ

В следующем коде показаны примеры использования оператора || (логическое ИЛИ).

= true || true; // t || t вернёт true o2 = false || true; // f || t вернёт true o3 = true || false; // t || f вернёт true o4 = false || 3 == 4; // f || f вернёт false o5 = "Cat" || "Dog"; // t || t вернёт "Cat" o6 = false || "Cat"; // f || t вернёт "Cat" o7 = "Cat" || false; // t || f вернёт "Cat" o8 = "" || false; // f || f вернёт false o9 = false || ""; // f || f вернёт "" o10 = false || varObject; // f || object вернёт varObject 

Примечание: Если вы используете этот оператор, чтобы задать значение по умолчанию для некоторой переменной, имейте в виду, что любое ложноподобное будет проигнорировано. Если вам нужно исключить только null или undefined , попробуйте воспользоваться оператором нулевого слияния.

Правила конвертации для булевых значений

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

Следующая операция с булевыми значениями: