Как определяется истинность ложность условного выражения в js

Тип Boolean, логические операторы и операторы сравнения

Логический тип Boolean в JavaScript представляет одно из двух значений: true (истина) или false (ложь).

Значения Boolean

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

• ДА / НЕТ
• ВКЛ / ВЫКЛ
• ИСТИНА / ЛОЖЬ

Именно для этих случаев в JavaScript существует логический тип данных Boolean, который может принимать только значение true (истина) или false (ложь).

Функция Boolean()

Чтобы определить, является ли выражение (или переменная) истиной (возвращает значение true), можно воспользоваться функцией Boolean():

 Boolean(10 > 9) // возвращает true 

Или можно сделать еще проще:

 (10 > 9) // также возвращает true 10 > 9 // также возвращает true 

Все имеет «значение» True или False

Любое значение отличное от 0 имеет логическое значение true.

 // следующие выражения возвращают true Boolean(100) Boolean( 3.14) Boolean(-15) Boolean("Hello") Boolean("false") Boolean(7 + 1 + 3.14) 

Логическое значение 0 (ноль) — false.

 var x = 0; Boolean(x); // возвращает false 

Логическое значение -0 (минус ноль) — false.

 var x = -0; Boolean(x); // возвращает false 

Логическое значение «» (пустая строка) — false.

 var x = ""; Boolean(x); // возвращает false 

Логическое значение undefined — false.

 var x; Boolean(x); // возвращает false 

Логическое значение null — false.

 var x = null; Boolean(x); // возвращает false 

Логическое значение false — false.

 var x = false; Boolean(x); // возвращает false 

Логическое значение NaN — false.

 var x = 10 / "H"; Boolean(x); // возвращает false 

Значения типа Boolean могут быть объектами

Обычно, логические значения типа Boolean определяются примитивными литералами:

 var x = false; 

Однако, в JavaScript при помощи ключевого слова new логические значения также можно определить и как объекты:

 var y = new Boolean(false); 

 var x = false; var y = new Boolean(false); // typeof x вернет тип boolean // typeof y вернет тип object 

Тем не менее, не определяйте значения типа Boolean как объекты. Это замедляет скорость выполнения скрипта. Кроме этого, ключевое слово new в данном случае усложняет код и может привести к неожиданным результатам:

При использовании оператора сравнения ==, одинаковые значения типа Boolean равны:

 var x = false; var y = new Boolean(false); // (x == y) будет истинным (true), потому что x и y имеют равные значения 

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

 var x = false; var y = new Boolean(false); // (x === y) будет ложным (false), потому что x и y не равны по типу (boolean и object) 

Или еще хуже. Объекты не сравниваются:

 var x = new Boolean(false); var y = new Boolean(false); // (x == y) - false, потому что x и y разные объекты 

Обратите внимание на разницу между (x==y) и (x===y).

Сравнение двух объектов JavaScript всегда возвращает ложь (false).

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

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

Значения типа Boolean лежат в основе всех сравнений и условий в JavaScript.

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

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

Предположим, что у нас есть x = 5. Следующая таблица объясняет операторы сравнения:

Оператор	Описание	Выражение	Возвращает
==	равно	x == 8 x == 5 x == «5»	false true true
===	равно по значению и типу	x === 5 x === «5»	true false
!=	не равно	x != 8	true
!==	не равно ни по значению, ни по типу	x !== 8 x !== 5 x !== «5»	true false true
>	больше чем	x > 8	false
	меньше чем	x < 8	true
>=	больше или равно	x >= 8	false
	меньше или равно	x	true

Как это можно использовать

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

 if (age < 18) text = "Слишком молод"; 

Подробнее об условных выражениях будет рассказано в следующей главе этого учебника.

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

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

Предположим, у нас есть x = 6 и y = 3. Следующая таблица объясняет логические операторы:

Оператор	Описание	Пример
&&	И	(x < 10 && y >1) - true
||	ИЛИ	(x == 5 || y == 5) - false
!	НЕ	!(x == y) - true

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

 !!"string" = true !!null = false 

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

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

имя_переменной= (условие) ?значение1:значение2

 var voteable = (age < 18) ? "Слишком молод" : "Возраст подходит"; 

В данном примере если в переменной age значение меньше 18, то переменной voteable будет присвоена строка "Слишком молод", в обратном случае переменной voteable будет присвоена строка "Возраст подходит".

Сравнение разных типов

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

При сравнении строки и числа JavaScript будет преобразовывать строку в числовое значение. Пустая строка преобразуется в 0. Не числовая строка преобразуется в значение NaN, которое всегда равно false.

Выражение	Значение
2 < 12	true
2 < "12"	true
2 < "John"	false
2 > "John"	false
2 == "John"	false
"2" < "12"	false
"2" > "12"	true
"2" == "12"	false

При сравнении двух строк значение строки "2" будет больше значения строки "12", потому что в алфавитной последовательности 1 меньше 2.

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

 age = Number(age); if (isNaN(age)) < voteable = "Введенное значение не является числом"; >else

JavaScript Урок 8 Сравнение и Логические Операторы

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

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

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

Пусть x=5, таблица ниже объясняет операторы сравнения:

Оператор	Описание	Пример
==	равно	x==8 это ложь x==5 это истина
===	точно равно (значение и тип совпадают)	x===5 это истина x==="5" это ложь
!=	не равно	x!=8 это истина
>	больше чем	x>8 это ложь
	меньше чем	x
>=	больше или равно	x>=8 это ложь
	меньше или равно	x

Как Это Можно Использовать

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

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

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

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

Пусть x=6 и y=3, таблица ниже объясняет логические операторы:

Оператор	Описание	Пример
&&	логическое И	(x < 10 && y >1) это истина
||	логическое ИЛИ	(x==5 || y==5) это ложь
!	логическое НЕ	!(x==y) это истина

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

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

Синтаксис

имя_переменной=(условие)?значение1:значение2

Пример

greeting=(visitor=="ВАСЯ")?"Привет Вася ":"Привет";

Если переменная visitor имеет значение "ВАСЯ", то переменной greeting будет присвоено значение "Привет Вася ", в противном случае ей будет присвоено значение "Привет".

Логические операторы в 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) < // выполнить действие >

Data Science в медицине

16 янв. 2024 г.

Что такое биометрические данные

12 янв. 2024 г.

Логика и истина

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

Вот пример простого выражения if в JavaScript. В нём оценивается на истину число 1; поскольку 1 истинно, код внутри блока, ограниченный < и >, будет выполнен.

if ( 1 ) < // этот код будет выполнен! console.log( '1 - истина' ); >

Как выясняется, большинство значений в JavaScript являются истинными — на деле только пять значений в JavaScript ложны:

• undefined (значение по умолчанию объявленных переменных, которым не присвоено значение);
• null ;
• NaN (not a number, не число);
• 0 (ноль);
• '' (пустая строка).

Когда мы хотим проверить, является ли значение «ложно», то можем использовать оператор ! :

var a = ''; if ( !a ) < // этот код будет выполнен если a ложно console.log( 'a - ложно' ); >

NaN это особый случай. Значения, которые NaN будет оценивать на ложь, в простом условном выражении:

var notANumber = 'four' - 'five'; if ( !notANumber ) < // этот код будет выполнен console.log( '!notANumber - истинно' ); >

Тем не менее, если мы сравним значение NaN с false , то вернёмся к ложному значению:

var notANumber = 'four' - 'five'; if ( notANumber == false ) < // этот код не будет выполнен! console.log( 'notANumber - ложно' ); >else < // этот код будет выполнен console.log( 'notANumber - истинно' ); >

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

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

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

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

var foo = 1; var bar = 0; var baz = 2; foo || bar; // возвращает 1, которое истинно bar || foo; // возвращает 1, которое истинно foo && bar; // возвращает 0, которое ложно foo && baz; // возвращает 2, которое истинно

В случае оператора || возвращается первое значение, если оно истинно, или последнее значение. В случае оператора && возвращается первое значение, если оно ложно, или последнее значение.

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

foo && bar(); // выполняет bar() только если foo истинно var bar = baz || createBar(); // использовать baz в качестве значения для bar если // baz не ложно; в противном случае вызвать createBar

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

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

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

Внимание! Неудачное решение

var propertyName; if (dim === 'width') < propertyName = 'clientWidth'; >else

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

var propertyName = ( dim === 'width' ) ? 'clientWidth' : 'clientHeight';

Выражение перед ? оценивается на его истинность. Если оно истинно, в качестве значения переменной propertyName используется первое значение ( clientWidth ); в противном случае применяется второе значение ( clientHeight ).

Автор: Ребекка Мёрфи
Последнее изменение: 01.09.2015

• Основы JavaScript
  • Объекты
  • Массивы
  • Логика и истина
  • Подводные камни JavaScript
  Похожие публикации:

  1. Как найти сообщения от конкретного пользователя в телеграм
  2. Как управлять подсветкой кулера процессора
  3. Куда прикручивать госномер хонда nc750s
  4. Что делать если в панели управления nvidia нет параметра дисплей