Вивчай
· 12 хв читання
javascriptпочатківцям

10 дивацтв JavaScript — чому [] + {} дає [object Object]

Крива вежа з дерев'яних кубиків із цифрами та знаками плюс і дорівнює, яка тримається всупереч законам фізикиКрива вежа з дерев'яних кубиків із цифрами та знаками плюс і дорівнює, яка тримається всупереч законам фізики

У січні 2012 року програміст Гері Бернгардт вийшов на сцену конференції CodeMash із п'ятихвилинною доповіддю «Wat». Він набирав у консолі [] + {}, отримував [object Object], робив паузу, і зал вибухав сміхом. Відео досі збирає перегляди, а JavaScript досі веде себе так само.

Але є нюанс: у кожного з цих «вибриків» є логічне пояснення. Не завжди гарне, іноді таке, що його автори самі шкодують, але логічне. І коли ти розумієш, чому мова так робить, дивацтво перестає бути пасткою і стає просто правилом, яке ти знаєш.

Нижче 10 дивацтв. Кожен результат перевірено в Node.js, і до кожного є правило, як не наступити на граблі. Поїхали.


1. 0.1 + 0.2 не дорівнює 0.3

0.1 + 0.2;          // 0.30000000000000004
0.1 + 0.2 === 0.3;  // false

Найвідоміше дивацтво, і найнесправедливіше звинувачення: JavaScript тут ні до чого. Так само поводяться Python, Java, C і майже всі мови, бо всі вони зберігають дробові числа за одним стандартом IEEE 754.

Чому так. Згадай, як ти записуєш 1/3 у десятковій системі: 0.3333… і так нескінченно. Доводиться десь обрізати. Якщо обрізати на четвертому знаку і скласти тричі, вийде 0.9999, а не 1. Нічого дивного, просто «хвіст» втратився.

Комп'ютер рахує у двійковій системі, і там ситуація дзеркальна: 0.1 перетворюється на нескінченний дріб 0.000110011001100…, бо 10 не є степенем двійки. Під число відведено 64 біти, хвіст обрізається, і 0.1 у пам'яті насправді дорівнює 0.1000000000000000055…. Сума двох таких «майже» дає «майже 0.3», і JavaScript чесно це показує.

Схема: 1/3 у десятковій і 0.1 у двійковій системах не записуються скінченно, тому сума втрачає хвістСхема: 1/3 у десятковій і 0.1 у двійковій системах не записуються скінченно, тому сума втрачає хвіст

Як не наступити. Гроші ніколи не рахуй у дробах: зберігай копійки цілими числами (1999, а не 19.99). Для порівняння дробів використовуй допуск:

Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON;  // true

А для виводу округлюй: (0.1 + 0.2).toFixed(2) дає "0.30".

2. typeof null — це "object"

typeof null;       // "object"
typeof undefined;  // "undefined"
null instanceof Object;  // false

Тобто null каже, що він об'єкт, але об'єктом не є. Це визнаний баг, якому понад 30 років.

Чому так. У першій версії JavaScript 1995 року кожне значення зберігалось як пара «тег типу + дані». Об'єкти мали тег 000. А null був реалізований як нульовий вказівник, тобто всі нулі. Коли typeof дивився на перші три біти, бачив 000 і чесно відповідав: «об'єкт».

Виправити пробували. Коли готували стандарт ES6, була пропозиція зробити typeof null === "null". Її відхилили: надто багато коду у світі вже спирався на стару поведінку, і виправлення одного рядка зламало б тисячі сайтів. Браузери обрали сумісність, і тепер цей баг офіційно частина специфікації.

Як не наступити. Перевіряй на null прямо:

if (value === null) { ... }
if (value !== null && typeof value === "object") { ... }

3. [] + {} дає [object Object], а {} + [] дає 0

[] + {};   // "[object Object]"
({}) + []; // "[object Object]"

А в консолі браузера набери {} + [] і побачиш 0. Те саме, але в іншому порядку, і результат інший. Це і є легендарний момент із доповіді «Wat».

Чому так. Оператор + з об'єктами працює за таким правилом: спершу перетворює обидва операнди на примітиви, і якщо хоч один з них рядок, склеює. Порожній масив перетворюється на порожній рядок "". Об'єкт перетворюється на рядок "[object Object]", бо так працює його стандартний toString(). Виходить "" + "[object Object]".

А от {} + [] на початку рядка в консолі JavaScript читає інакше: фігурні дужки вважає порожнім блоком коду (як тіло if без умови), а далі лишається +[], тобто унарний плюс від порожнього масиву. [] → "" → 0. Візьми об'єкт у дужки ({}) + [], і знову отримаєш [object Object].

Як не наступити. Ніколи не додавай масиви та об'єкти оператором +. Для об'єднання масивів є [...a, ...b] або a.concat(b), для об'єктів { ...a, ...b }.

4. "2" + 2 дає "22", а "2" - 2 дає 0

"2" + 2;   // "22"
"2" - 2;   // 0
"2" * "3"; // 6
1 + "1" - 1; // 10

Чому так. У JavaScript + робить дві різні роботи: додає числа і склеює рядки. Якщо хоча б один операнд рядок, перемагає склеювання. Решта арифметичних операторів (-, *, /) уміють лише одне: рахувати, тому вони мовчки перетворюють рядки на числа.

Уяви офіціанта, який отримує «2» і 2. Зі знаком плюс він вирішує, що ти диктуєш номер столика, і записує «22». Зі знаком мінус номери столиків не віднімають, тож він здогадується, що це кількість, і рахує.

Приклад 1 + "1" - 1 ще показовіший: спочатку 1 + "1" склеюється в "11", потім "11" - 1 перетворюється на 10.

Як не наступити. Усе, що приходить ззовні (поля форми, URL, localStorage), завжди рядок. Перетворюй явно, перш ніж рахувати: Number(input) або parseInt(input, 10).

5. [] == false дає true, а null == 0 дає false

[] == false;        // true
"" == 0;            // true
"0" == false;       // true
null == undefined;  // true
null == 0;          // false
null >= 0;          // true (!)

Останні два рядки особливо хороші: null не дорівнює нулю, але більший або рівний нулю.

Чому так. Нестрогий оператор == перед порівнянням намагається привести обидві сторони до спільного типу за алгоритмом із п'яти кроків. Ось він на схемі, разом із покроковим розбором [] == false:

Блок-схема алгоритму нестрогого порівняння == і покроковий розбір прикладу [] == falseБлок-схема алгоритму нестрогого порівняння == і покроковий розбір прикладу [] == false

Коротко: false стає 0, масив [] стає рядком "", рядок "" стає числом 0, і нарешті 0 == 0. Чотири перетворення заради одного порівняння.

А null особливий: за правилами == він рівний лише undefined і більше нікому, у число не перетворюється. Проте оператори >= і < живуть за іншим алгоритмом, де null таки стає 0. Тому null >= 0 дає true. Дві різні машини, два різні результати.

Як не наступити. Використовуй === і !==. Завжди. Єдиний виняток, який деякі команди дозволяють: value == null, щоб одним махом перевірити і null, і undefined. Але навіть його простіше замінити на value === null || value === undefined, щоб не пояснювати колегам.

6. NaN не дорівнює сам собі

NaN === NaN;          // false
typeof NaN;           // "number"
isNaN("привіт");      // true
Number.isNaN("привіт"); // false

Три дивацтва в одному. NaN розшифровується як Not a Number, і при цьому має тип number. Він не рівний навіть сам собі. А стара функція isNaN вважає, що слово «привіт» це NaN.

Чому так. NaN це результат безглуздої математичної операції: 0 / 0, Math.sqrt(-1), "abc" * 2. Стандарт IEEE 754 навмисно зробив його нерівним собі, щоб x !== x було швидким способом перевірити «а чи не зламалось у мене обчислення». Бо два різні безглузді результати нема сенсу вважати однаковими, як не вважають однаковими дві помилки в різних місцях.

Стара isNaN() спочатку перетворює аргумент на число. "привіт" стає NaN, і функція чесно каже true. Це поведінка «чи стане це NaN після перетворення», а не «чи це NaN зараз». Тому в ES2015 додали Number.isNaN(), яка нічого не перетворює.

Як не наступити. Перевіряй через Number.isNaN(x) або Object.is(x, NaN). І пам'ятай, що [NaN].indexOf(NaN) дає -1, а [NaN].includes(NaN) дає true, бо includes молодший і про цю проблему вже знав.

7. Math.max() без аргументів дає -Infinity

Math.max();  // -Infinity
Math.min();  // Infinity

Максимум із нічого це мінус нескінченність. Звучить як жарт, але це найлогічніший пункт у списку.

Чому так. Math.max працює як суддя, який тримає в голові «поточного чемпіона» і порівнює з ним кожного наступного учасника. З яким значенням починати, щоб перший же учасник гарантовано переміг? З найменшим можливим: -Infinity. Якщо учасників не прийшло взагалі, чемпіоном лишається стартове значення.

Де це кусається: Math.max(...[]). Передаєш порожній масив цін і отримуєш «максимальну ціну» мінус нескінченність, яка потім тихо ламає всі розрахунки.

Як не наступити. Перевіряй масив на порожність перед Math.max(...arr), або передавай запасне значення: Math.max(0, ...arr).

8. [1, 2, 10].sort() дає [1, 10, 2]

[1, 2, 10, 21, 3].sort();  // [1, 10, 2, 21, 3]
["b", "a", "C"].sort();    // ["C", "a", "b"]

Числа відсортовані так, ніби це слова у словнику: спочатку все, що починається на «1», потім на «2». А велика «C» опинилась перед маленькою «a».

Чому так. sort() без аргументів перетворює кожен елемент на рядок і порівнює їх посимвольно за кодами Unicode. У цьому порядку "10" менше за "2", бо перший символ "1" менший за "2". А великі латинські літери мають коди 65–90, маленькі 97–122, тому "C" іде першою.

Чому так зробили? Бо у 1995 році sort() мав працювати з будь-чим, а єдине, що є в усіх значень, це рядкове представлення. Універсально, але для чисел марно.

Як не наступити. Для чисел завжди передавай функцію порівняння:

[1, 2, 10, 21, 3].sort((a, b) => a - b);  // [1, 2, 3, 10, 21]
["b", "a", "C"].sort((a, b) => a.localeCompare(b));  // ["a", "b", "C"]

І ще: sort() змінює вихідний масив. Якщо потрібна копія, з 2023 року є toSorted().

9. parseInt(0.0000005) дає 5

parseInt(0.0000005);  // 5
parseInt(0.000005);   // 0
parseInt("12px");     // 12
Number("12px");       // NaN

Половина мільйонної перетворюється на п'ятірку. А на один нуль менше, і все нормально.

Чому так. parseInt чекає рядок. Якщо дати йому число, воно спершу перетвориться на рядок. String(0.000005) дає "0.000005", і parseInt чесно зчитує 0. Але дуже малі числа JavaScript записує в експоненційній формі: String(0.0000005) дає "5e-7". parseInt читає зліва направо, бачить 5, натикається на букву e, яка не цифра, і зупиняється. Відповідь: 5.

Та сама «читаю, поки можу» поведінка пояснює і parseInt("12px"). Функція придумана, щоб витягати числа з рядків типу "12px", і для цього вона ідеальна. А Number() строгіший: або весь рядок число, або NaN.

Як не наступити. parseInt лише для рядків, і завжди з основою: parseInt(str, 10). Для чисел бери Math.trunc(x) або Math.floor(x).

10. return з переносом рядка повертає undefined

function getUser() {
  return
  {
    name: "Оля"
  };
}

getUser();  // undefined

Функція виглядає так, ніби повертає об'єкт. Вона повертає undefined, і помилки не буде.

Чому так. У JavaScript крапка з комою наприкінці рядка необов'язкова, бо є механізм автоматичної вставки (ASI, Automatic Semicolon Insertion). Він корисний, але має свої правила. Одне з них: якщо після return іде перенос рядка, крапка з комою ставиться одразу. Виходить return;, а далі блок із міткою name: і рядком "Оля", який просто ніколи не виконується.

Це як лист, у якому ти написав «Надсилаю тобі» і перейшов на новий рядок, а поштар вирішив, що речення закінчене, і запечатав конверт порожнім.

Як не наступити. Відкривай дужку на тому самому рядку, що й return:

return {
  name: "Оля"
};

Те саме правило для throw, break і continue. Лінтери (ESLint) ловлять цю помилку автоматично, і це одна з причин їх увімкнути з першого дня.


Десерт: "b" + "a" + +"a" + "a"

"b" + "a" + +"a" + "a";  // "baNaNa"

Після всього прочитаного ти вже можеш пояснити це сам. Другий + перед "a" стоїть сам, без лівого операнда, тож це унарний плюс, який перетворює "a" на число. Буква числом не стає, виходить NaN. Далі звичайне склеювання: "b" + "a" + NaN + "a". Банан.

Що в цих дивацтвах спільного

Якщо придивитись, майже всі 10 пунктів зводяться до двох речей:

  1. Неявне перетворення типів. JavaScript із 1995 року намагається «здогадатись», що ти мав на увазі, і перетворює рядки на числа, масиви на рядки, об'єкти на примітиви. Іноді вгадує, іноді ні. Пункти 3, 4, 5, 8, 9 і десерт це саме воно.
  2. Сумісність важливіша за правильність. typeof null, рядковий sort(), стара isNaN відомі десятиліттями, але їх не виправляють, бо мільйони сайтів працюють на старій поведінці. Замість виправлення додають нові інструменти поруч: Number.isNaN, toSorted, ===.

Брендан Айк написав першу версію JavaScript за 10 днів у травні 1995 року. Для мови, зробленої у такий термін, вона тримається дивовижно добре. А дивацтва стали частиною культури: з них сміються, їх питають на співбесідах, і їх варто знати хоча б для того, щоб не витратити вечір на пошук бага, де "10" + 5 дало "105".

Для допитливих

Повний алгоритм == описано у специфікації ECMAScript у розділі IsLooselyEqual, він коротший, ніж здається. Сайт 0.30000000000000004.com показує, як 0.1 + 0.2 виглядає у 40+ мовах програмування, і JavaScript там далеко не найгірший. Оригінальна доповідь «Wat» Гері Бернгардта лежить на destroyallsoftware.com, це 4 хвилини сміху. А репозиторій wtfjs українця Дениса Довганя зібрав понад сотню подібних прикладів із поясненнями по специфікації. Про те, як працює this і чому воно теж «постійно не те», читай у сусідній статті.

Часті питання

Чому 0.1 + 0.2 не дорівнює 0.3 у JavaScript?+
Бо дробові числа зберігаються у двійковій системі за стандартом IEEE 754, а 0.1 і 0.2 у ній є нескінченними дробами, як 1/3 у десятковій. Їх обрізають до 64 біт, і при додаванні накопичується похибка: виходить 0.30000000000000004. Так само поводяться Python, Java і C. Для грошей рахуй у копійках цілими числами, для порівняння використовуй допуск Number.EPSILON.
Чому typeof null повертає object?+
Це баг першої реалізації JavaScript 1995 року: значення зберігались із тегом типу, об’єкти мали тег 000, а null був нульовим вказівником, тобто теж починався з нулів. typeof дивився на тег і бачив об’єкт. Виправлення пропонували при підготовці ES6, але відхилили через зворотну сумісність: надто багато коду залежить від старої поведінки. Перевіряй null через value === null.
Яка різниця між == і === у JavaScript?+
=== порівнює без перетворення типів: якщо типи різні, результат одразу false. == спершу приводить обидва значення до спільного типу за алгоритмом із кількох кроків (boolean стає числом, рядок стає числом, об’єкт стає примітивом) і лише потім порівнює. Через це [] == false дає true. Використовуй === завжди.
Чому [1, 2, 10].sort() дає [1, 10, 2]?+
sort() без аргументів перетворює елементи на рядки і порівнює їх посимвольно за кодами Unicode. Рядок 10 іде перед 2, бо символ 1 менший за 2. Для чисел передавай функцію порівняння: arr.sort((a, b) => a - b). Для копії замість зміни вихідного масиву використовуй toSorted().
Як перевірити, що значення є NaN?+
Через Number.isNaN(x) або Object.is(x, NaN). Порівняння x === NaN завжди false, бо NaN за стандартом не дорівнює сам собі. Стара глобальна isNaN() спершу перетворює аргумент на число, тому isNaN("текст") дає true, хоча це рядок, а не NaN. Number.isNaN нічого не перетворює і відповідає точно.

Усі 10 прикладів із цієї статті можна набрати в консолі браузера прямо зараз і побачити на власні очі. А щоб перетворення типів перестали дивувати назавжди, пройди уроки типи даних та оператори і умовні конструкції, де все це розібрано з практикою. Тримай поруч шпаргалку з основ JavaScript: там є таблиця truthy і falsy значень, яка закриває половину дивацтв із цього списку.