JavaScript или LiveScript, известные вначале, существуют довольно давно и превратились из игрушки интернет-наркоманов в используется как серверный язык (Node.js).

Он претерпел множество изменений и стандартизации, когда Netscape представил его в ECMA International. Формально известный как ECMAScript с его последней девятой версией, JavaScript остается одним из самых универсальных языков программирования, от управления DOM API до создания гибридных мобильных приложений.

Все еще будучи JS-разработчиками, мы должны принять некоторые вещи в JavaScript, которые на самом деле кажутся странными, но понимание этого непредвзятого мнения заставит нас оценить его.

Почти все является объектом в JavaScript, за исключением чисел, строк, логических значений, null и undefined, которые являются примитивными типами данных и являются неизменяемыми.

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

Давайте рассмотрим простой пример,

> "5" + 2;
<- "52"
> 5 + "2";
<- "52"

арифметика работает как положено, не так ли? «5» добавляется 2 как целое число в обоих случаях и приводит к строке «52».

При добавлении дополнительного токена все идет немного странно. Давайте 17, а почему бы и нет?

//EXAMPLE-1
> "5"+2+"17";
<- "5217"
> "5"+2+17;
<- "5217"
> 17+2+"5";
<- "195"
//EXAMPLE-2
> 1+2+5+6+7+2+"001";
<- "23001"
> "001"+1+2+5+6+7+2;
<- "001125672"

Сначала это может показаться странным, но внимательно наблюдая, мы видим, что тип String получает больший приоритет. Результат превращается в строковый, как только символ будет перехвачен.

> '54'-52;
<- 2
> '52'-'32';
<- 20
> 8-'4';
<- 4
//FROM EXAMPLE ABOVE
> "001"+1+2+5+6+7+2-1;
<- 1125671
> var x = 5;
> '5' + x - x;
<- 50

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

«5» + x дает «53» (строка имеет большее предпочтение), а ’53'-3 возвращает 50.

Давайте посмотрим на этот фрагмент, связанный с числовыми операциями.

> 5--3; // hey this looks weird but it is 5 - (-3)
<- 8
> 2-+-3;  //chill out this is just 2 -(+(-3));
<- 5
> 5+-+---+1 ;//Similarly it is just 5 + (-(+(-(-(-(+(1)))))))
<- 6

Просто это арифметическая операция над примитивом «число», которая обрабатывает - (+ (1)) как число, поскольку +1 - это число, и поэтому - (+ 1), просто :-)

[ПРИМЕЧАНИЕ: new Number () возвращает объект Number, заключенный в оболочку, тогда как Number () используется для преобразования типа] .

Как и «!», «+» также рассматривается как унарный оператор.

Нам известен тот факт, что «!» - это унарный оператор, выполняющий инверсию. Точно так же «+» выполняет приведение типа к числовому типу.

> !0;
<- true
> !1;
<- false
//Meh, obvious!
> !!!!!0; //translates to !(!(!(!(!0))))
<- true //Still ok
//NOW
> +'5'; // type conversion
<- 5
> !!'0'+!+'0'; // !(!'0')=> !(false)=> true | !(+'0')=> !0=> true
<- 2 // true+true=2 ('boolean' to 'Number' casting takes place)

Давайте поговорим о «числе», которое «не является числом» или просто NaN.

В JavaScript есть число с именем ‘NaN’, которое является аббревиатурой от «Not a Number», в основном оно представляет все, что не является числом в форме числа. Если мы хотим принудительно преобразовать строку или объект в число, javascript представляет эту строку или объект как NaN.

> typeof(NaN);
<- "number"
> NaN==NaN;
<- false

Согласно ECMA-262, любая сторона == или === содержит NaN, тогда это приведет к ложному значению. Выражаясь интуитивно, мы должны понимать, что NaN - это просто представление чего-либо, что не является числом, поэтому оно не равно другому объекту, не являющемуся числом. Можно привести аналогию, сравнивая все, что не является яблоком, с тем, что не является яблоком.

> +'Hello';
<- NaN
> 'Hello'+ +'world';
<- HelloNaN

Унарный оператор «+» перед «Hello» вызывает преобразование «Hello» в «число», и js теперь представляет это как NaN.

'Hello'+ +'world'Translates to «Hello» + (+ ’world’) = ›« Hello »+ NaN, происходит приведение типов, и NaN преобразуется в« NaN », в результате чего получается« HelloNaN ».

Вот еще один случайный забавный случай.

> [['1']+ +!0]+ ++[[1]][0];
<- "112"

А теперь вы знаете, [[‘1’] + +! 0], а добавление другой части - ++ [1] [0]. В первой части ['1'] + +! [] = ›['1'] (одиночный элемент) + (+! 0) (! 0 возвращает истину, а префикс '+' приводит его к 1) и заключен в массиве = ›[['1'] + 1] =› ['1' + 1] (происходит приведение общего типа, и, таким образом, он становится массивом с одним элементом '11' = ›['11'].

Во второй части ++ [[1]] [0]. Пусть A = [[1]], и это переводится в ++ A [0], мы увеличиваем первый элемент A с [1] и интерпретируем как 1 на 1 с помощью оператора ++, в результате чего числовое значение 2.

Таким образом, [‘11’] + 2, [‘11’] с одним элементом обрабатывается как «11’ при добавлении к нему 2, поскольку строка имеет более высокий приоритет, таким образом, мы получаем «112».

Если вам понравилась статья, пожалуйста, оставьте мне аплодисменты и начните любить странные части JS!