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 у двійковій системах не записуються скінченно, тому сума втрачає хвіст
Як не наступити. Гроші ніколи не рахуй у дробах: зберігай копійки цілими числами (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 стає 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 пунктів зводяться до двох речей:
- Неявне перетворення типів. JavaScript із 1995 року намагається «здогадатись», що ти мав на увазі, і перетворює рядки на числа, масиви на рядки, об'єкти на примітиви. Іноді вгадує, іноді ні. Пункти 3, 4, 5, 8, 9 і десерт це саме воно.
- Сумісність важливіша за правильність.
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?+
Чому typeof null повертає object?+
Яка різниця між == і === у JavaScript?+
Чому [1, 2, 10].sort() дає [1, 10, 2]?+
Як перевірити, що значення є NaN?+
Усі 10 прикладів із цієї статті можна набрати в консолі браузера прямо зараз і побачити на власні очі. А щоб перетворення типів перестали дивувати назавжди, пройди уроки типи даних та оператори і умовні конструкції, де все це розібрано з практикою. Тримай поруч шпаргалку з основ JavaScript: там є таблиця truthy і falsy значень, яка закриває половину дивацтв із цього списку.