Почему JavaScript не похож ни на один другой язык ?

Избегайте создания переменных с использованием `var`

console.log(varVariable) // undefined
var varVariable = 10; 
console.log(varVariable) // 10

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

А как насчет `const` и `let`?

console.log(letVariable) // ReferenceError
let letVariable = 10; 

console.log(constVariable) // ReferenceError
const constVariable = 10;

Ссылка на значение переменной, объявленной с использованием const и let перед ее объявлением, приведет к ReferenceError.

Приведение типов, т. е. неявное преобразование типов

Javascript выполняет приведение типов, когда операция имеет несовпадающие типы. вместо того, чтобы выдавать ошибки типа.

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

"50" + 1 // "501"
"50" - 1 // 49
true + true + true // 3
false - true // -1
[] + [] // ""
{} + [] // 0
[] + {} // "[object Object]"
"foo" + + "bar" // "fooNaN"
Number.MIN_VALUE > 0 // true
null == false // false
"222" - -"111" // 333
3 > 2 > 1 // false
true == "true" // true
false == "false" // false
[1, 2, 3] + [4, 5, 6] // "1,2,34,5,6"
!+[]+[]+![] // "truefalse"

"50" + 1 приводит к "501". Число 1 преобразуется в строку и объединяется с другой строкой. Следовательно, окончательный результат равен "501".
"50" - 1 приводит к 49. Строка "50" приводится к числу и выполняет вычитание. Следовательно, окончательный результат равен 49.
true + true + true приводит к 3. true при принуждении к номеру возвращает 1. Поэтому 1 + 1 + 1 приводит к 3.
false - true приводит к -1. Подобно true, false при принуждении к числу возвращает 0. Следовательно, 0 - 1 приводит к -1.
[] + [] приводит к "". [] приводится к пустой строке. Поэтому "" + "" приводит к "".
{} + [] приводит к 0. {} — пустой блок. а + [] приводит [] к числу, равному 0. Следовательно, окончательный результат равен 0.
[] + {} приводит к "". [] приводится к пустой строке. {} — это объект, и при объединении его с пустой строкой получится "[object Object]".
"foo" + + "bar" приводит к "fooNaN". 'foo' - это строка. + "bar" преобразовать строку "bar" в число, которое вернет NaN. 'foo' + NaN вернет "fooNaN".
Number.MIN_VALUE > 0 результаты верны. Number.MIN_VALUE возвращает 5e-324, которое является наименьшим положительным числом, которое может быть представлено с точностью до числа с плавающей запятой, то есть максимально близко к нулю.
null == false приводит к false. Поскольку null можно сравнить только с null или undefined, чтобы вернуть true, иначе будет возвращено false.
"222" - -"111" приводит к 333. - "111" преобразуется в число и возвращает -111. затем "222" в "222" - -111 приводится к числу 222. Наконец, 222 - -111 приводит к 333.
3 > 2 > 1 приводит к false. Сначала оценивается 3 > 2, в результате чего получается true. Далее true > 1 в этом случае true преобразуется в число 1 > 1, которое возвращает false.
true == "true" возвращает true, так как и true, и "true" верны.
false == "false" возвращает ложь, потому что false ложно, а "false" правдиво.
[1, 2, 3] + [4, 5, 6] приводит к "1,2,34,5,6". Оба массива сначала преобразуются в строки, которые выглядят как "1,2,3" + "4,5,6", что приводит к "1,2,34,5,6".
!+[]+[]+![] приводит к "truefalse". Вот как вычисляется выражение
+[] преобразуется в число, в результате которого получается 0,
![], [] является правдой, поэтому !true ложно,
[]+![] становится []+false, где [] покрывается до "" . Следовательно, ""+false приводит к "false",
!+[] становится !false, что приводит к true.
Наконец, !+[]+[]+![] становится true+"false", что приводит к "truefalse"

`typeof null === "object"`

В первой реализации JavaScript значения JavaScript были представлены в виде тега типа и значения. Тег типа для объектов был 0. null был представлен как указатель NULL ( 0x00 на большинстве платформ). Следовательно, null имеет 0 в качестве тега типа, поэтому typeof возвращает значение "object".

Из документации MDN см..

`x !== x` может быть правдой

Когда x = NaN, NaN является единственным значением, которое сравнивается с неравным самому себе. Следовательно, если вам нужно проверить условие NaN, мы должны использовать Number.isNaN() или isNaN().

Причина, по которой NaN не равно самому себе. Можно создать два числа с плавающей запятой с разными двоичными представлениями, но оба они NaN.

Изменяемые глобальные переменные

var console = {}
console.log() // Uncaught TypeError: console.log is not a function
const example = () => {
var undefined = 10;
console.log(undefined) // 10
}
example()

undefined — это свойство глобального объекта. Он может быть изменен в любой области, кроме глобальной.

Изменение глобальной переменной — это «хороший способ усложнить себе жизнь».

Автоматическая вставка точки с запятой

// How to intend the code to execute.
const getUser = () => {
    return
    { name: 'John' };
}
console.log(getUser()); // { name: 'John' }

Это то, что видит Javascript, JS автоматически добавляет точку с запятой, если за оператором return следует новый разделитель строки.

// How JS executes the code.
const getUser = () => {
    return;
    { name: 'John' }; // Unreachable code.
}
console.log(getUser()); // undefined

Массивы

const arr = [];
console.log(arr.length); // 0
arr.length = 50;
console.log(arr.length); // 50
arr.length = 30;
console.log(arr.length); // 30

Array автоматически синхронизирует содержимое массива при изменении значения длины. Его можно использовать для увеличения или уменьшения содержимого массива. Значение длины всегда должно быть положительным целым числом.

Минимальное и максимальное сравнение

Math.min() < Math.max() // false
Math.max() // -Infinity
Math.min() // Infinity

Math.min(), чтобы найти наименьшее число в параметре, начнет сравнение с наибольшим положительным целым числом, которое равно Infinity. Поскольку параметров для сравнения нет, возвращается Infinity.

Точно так же Math.max() для нахождения наибольшего числа в параметрах начнет сравнение с наименьшим отрицательным целым числом, которое равно -Infinity. Поскольку параметры для сравнения отсутствуют, возвращается -Infinity.

Числовая сортировка массива

const arr = [10,1,3,40,8,9,23]
arr.sort()
console.log(arr) // [1, 10, 23, 3, 40, 8, 9]

Array.sort() преобразует число в строку, а затем сравнивает строки в порядке единиц кода UTF-16. В этом случае "10" предшествует "9".

Первоначально опубликовано на https://yogendrakumarvr.com.

Почему JavaScript не похож ни на один другой язык ?

Избегайте создания переменных с использованием var

А как насчет const и let?