Const a null какое сравнение даст истину

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

Здесь мы рассмотрим первые пять, операторы ?? и ??= будут в следующей статье.

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

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

|| (ИЛИ)

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

result = a || b;

Традиционно в программировании ИЛИ предназначено только для манипулирования булевыми значениями: в случае, если какой-либо из аргументов true , он вернёт true , в противоположной ситуации возвращается false .

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

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

alert( true || true ); // true alert( false || true ); // true alert( true || false ); // true alert( false || false ); // false

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

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

Например, число 1 будет воспринято как true , а 0 – как false :

if (1 || 0) < // работает как if( true || false ) alert( 'истинно!' ); >

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

let hour = 9; if (hour < 10 || hour >18)

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

let hour = 12; let isWeekend = true; if (hour < 10 || hour >18 || isWeekend) < alert( 'Офис закрыт.' ); // это выходной >

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

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

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

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

result = value1 || value2 || value3;

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

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

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

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

alert( 1 || 0 ); // 1 (1 - истинное значение) alert( true || 'какая-то строка' ); // true alert( null || 1 ); // 1 (первое истинное значение) alert( null || 0 || 1 ); // 1 (первое истинное значение) alert( undefined || null || 0 ); // 0 (поскольку все ложно, возвращается последнее значение)

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

Получение первого истинного значения из списка переменных или выражений. Например, у нас есть переменные firstName , lastName и nickName , все они необязательные (т.е. они могут быть неопределенными или иметь ложные значения). Давайте воспользуемся оператором ИЛИ || , чтобы выбрать ту переменную, в которой есть данные, и показать её (или «Аноним», если ни в одной переменной данных нет):

let firstName = ""; let lastName = ""; let nickName = "Суперкодер"; alert( firstName || lastName || nickName || "Аноним"); // Суперкодер

null

Значение null представляет отсутствие какого-либо объектного значения. В JavaScript, null является примитивом, и в контексте логических операций, рассматривается как ложное (falsy).

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

Синтаксис

null

Описание

Значение null записывается литералом null . Оно является самостоятельным, а не свойством глобального объекта (как undefined ). В API, null часто присутствует в местах где ожидается объект, но подходящего объекта нет.

// переменная foo не существует - она не была определена и никогда не инициализировалась: > foo 'ReferenceError: foo is not defined' // переменная foo существует, но она не имеет ни типа, ни значения: > var foo = null; foo 'null' 

Отличия между null и undefined

null является определённым значением отсутствия объекта, тогда как undefined обозначает неопределённость. Например:

var element; // значение переменной element до её инициализации не определённо: undefined element = document.getElementById("not-exists"); // здесь при попытке получения несуществующего элемента, метод getElementById возвращает null // переменная element теперь инициализирована значением null, её значение определено 

При проверке на null или undefined , помните о различии между операторами равенства (==) и идентичности (===): с первым, выполняется преобразование типов.

typeof null; // object (не "null" из соображений обратной совместимости) typeof undefined; // undefined null === undefined; // false null == undefined; // true 

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

Specification
ECMAScript Language Specification # sec-null-value

Совместимость с браузерами

BCD tables only load in the browser

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

Found a content problem with this page?

• Edit the page on GitHub.
• Report the content issue.
• View the source on GitHub.

This page was last modified on 7 авг. 2023 г. by MDN contributors.

Your blueprint for a better internet.

MDN

Support

• Product help
• Report an issue

Our communities

Developers

• Web Technologies
• Learn Web Development
• MDN Plus
• Hacks Blog

• Website Privacy Notice
• Cookies
• Legal
• Community Participation Guidelines

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2024 by individual mozilla.org contributors. Content available under a Creative Commons license.

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

Операторы в 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.

Шпаргалка по операторам сравнения и преобразованию типов в JS

Тема сравнения значений и тесно переплетенная с ней тема приведения типов относятся к самой фундаментальной области знаний для программистов на Javascript, без этих знаний будет легко допустить ошибки, и в каких-то моментах поведение программы может показаться нелогичным. Эта тема — такой же фундамент, как и тема функций и ООП в JS, о которых я уже писал цикл статей (кстати, надо бы сесть и обновить их, привести к текущим реалиям языка). Итак, постараюсь изложить максимально коротко, насколько это позволяют важность темы и подводные камни языка.

Как известно, для управления ходом программы (в операторах if, for, while…) или для выбора значения (тернарный оператор … ? … : … ) используются логические значения — true и false. Получить их можно двумя способами (мы не будем рассматривать логические операторы, такие как &&, ||, они вторичны).

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

console . log ( Boolean ( 0 ) ) ; // false
console . log ( ! 0 ) ; // true
console . log ( ! ! 0 ) ; // false - аналог Boolean(0)

Правила преобразования довольно простые:

false получается из:

• Числа 0, специального значения NaN (Not a Number — число, которое не число, а ошибка)
• null
• undefined
• Пустой строки (совсем пустой, 0 символов)

true получается из всего остального:

• Любого числа, кроме 0 и NaN
• Непустой строки, в том числе, состоящей из пробелов или «0»
• Любого объекта, в том числе «пустого», пустого массива, функции, и даже если нечаянно создать объект класса Boolean:

console . log ( ! ! < >) ; // true
console . log ( ! ! [ ] ) ; // true
console . log ( Boolean ( 0 ) ) ; // false - все в порядке
console . log ( ! ! new Boolean ( 0 ) ) ; // true - осторожно, new создает объект!

Кстати, как узнать, что в переменной объект? Нужно определить, к какому из 6 типов она относится — это три примитивных (number, string, boolean), два специальных пустых типа (undefined, null) и, собственно, объектный тип (object). Для этого в JS существует оператор typeof, но у него есть некоторые тонкие моменты:

console . log ( typeof [ ] ) ; // "object" - массивы - это объекты, типа "массив" в JS нет
console . log ( typeof null ) ; // "object" - это официальный глюк JS, смиритесь
console . log ( typeof function ( ) < >) ; // "function" - хотя функция - объект

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

console . log ( [ ] instanceof Array ) ; // true
console . log ( Array . isArray ( [ ] ) ) ; // true

Второй способ: операторы сравнения

Строгое равенство (===)

Самый простой и понятный вариант: два операнда сравниваются сначала по типам, если тип один, идет сравнение по значению. Для примитивных типов есть одно исключение — NaN при любых сравнениях, даже с собой, всегда дает false. А объекты равны только в случае, если оба операнда ссылаются на один и тот же объект:

console . log ( 0 === 0 ) ; // true
console . log ( NaN === NaN ) ; // false - особый случай
console . log ( 0 === "0" ) ; // false - разные типы
console . log ( [ ] === [ ] ) ; // false - разные объекты, хоть и похожи
var a = [ ] , b = a ;
console . log ( a === b ) ; // true - один и тот же объект

Нестрогое или абстрактное равенство (==)

Запомните, что это опасная штука со множеством нюансов:

• null == undefined дает true — это надо запомнить (null === undefined при этом дает false)
• Нестрогое проверка на равенство null и undefined с чем угодно другим всегда дает false
• NaN, как и при строгом равенстве, ни с чем сравнивать нельзя — всегда будет false
• Два объекта равны, только если это один и тот же объект
• Два примитива одного типа сравниваются по значению — тут без сюрпризов
• Два операнда разного типа приводятся к числовому типу и после этого сравниваются по значению (об этом будет ниже)

Сравнение на больше-меньше (>, =, <=)

• Числа сравниваются без сюрпризов, не забываем про NaN, сравнение с которым всегда дает false
• Две строки сравниваются лексикографически, то есть «как в словаре», но учитывая расположение символов в кодовой таблице Unicode
• Во всех остальных случаях оба операнда приводятся к числовому типу и получившиеся значения сравниваются

Приведение к числовому типу в Javascript

• null и false превращаются в 0
• true превращается в 1
• undefined превращается в NaN со всеми вытекающими проблемами для сравнения — любое сравнение даст false!
• У строк сначала отбрасываются пробельные символы в начале и в конце, если ничего не осталось, то это 0, если остается какое-то число, в том числе с десятичной точкой («1.23»), с минусом в начале или заданное через экспоненту («1e3» — это 1*10³, то есть 1000), то оно считывается, иначе — это NaN, опять же, не сравнимая ни с чем величина. Учтите, что функции parseInt() и parseFloat() работают немного по-другому — они позволяют иметь в строке после числа любые другие символы, они просто проигнорируются. Кроме того, parseInt() умеет получать из строки не только десятичные числа, но и числа с другими основаниями — двоичные, шестнадцатеричные и т.д., но в случае строки «1e3» считывает только 1, остальное игнорирует
• У объектов вызывается метод valueOf(), а если его нет или он возвращает не примитив, то вызывается toString(). Далее, если полученный примитив не является числом, то идет следующий этап приведения к числу по правилам выше.

Некоторые дефолтные преобразования объектов в числа (если мы не задали соответствующие методы для объекта или его прототипа):

• Метод toString() у массивов дает строку, в которой через запятую перечислены элементы массива. Эту строку пробуем затем превратить в число, и тут уже все зависит от содержимого массива, см. примеры ниже
• Тот же метод для обычных объектов возвращает строку «[object Object]», поэтому результатом преобразования в число будет NaN
• Для функций возвращается строка с содержимым кода функции, начиная со слова function, поэтому преобразование в число снова дает NaN
• Для дат (объектов класса Date) метод valueOf() вернет количество миллисекунд с начала Эпохи Юникса. Поэтому есть интересное следствие: если есть два объекта даты, указывающие на одну и ту же временную точку, то строгое или нестрогое равенство (===, ==) вернет false, потому что это разные объекты, а вот если сравнить через >= или true, потому что число миллисекунд одинаково.