Часто мы оказываемся в ситуации, когда интервьюер дает фрагмент кода и ожидает его вывода. Сегодня я напишу о нескольких таких часто задаваемых вопросах в JavaScript-интервью.

What will the code below output to the console and why 
 
console.log(1 + "2" + "2"); 
console.log(1 + +"2" + "2"); 
console.log(1 + -"1" + "2"); 
console.log(+"1" + "1" + "2"); 
console.log( "A" - "B" + "2"); 
console.log( "A" - "B" + 2);?

Приведенный выше код выведет на консоль следующее:

"122"
"32"
"02"
"112"
"NaN2"
"NaN"

Вот почему…

Фундаментальная проблема здесь заключается в том, что JavaScript (ECMAScript) является языком со свободной типизацией и выполняет автоматическое преобразование типов значений для выполнения выполняемой операции. Давайте посмотрим, как это работает на каждом из приведенных выше примеров.

Пример 1: 1 + «2» + «2» Выходы: «122»

Объяснение: Первая операция должна быть выполнена в 1 + «2». Поскольку один из операндов («2») является строкой, JavaScript предполагает, что ему необходимо выполнить конкатенацию строк, и поэтому преобразует тип 1 в «1», 1 + «2» дает «12». Тогда «12» + «2» дает «122».

Пример 2: 1 + +”2 + “2” Выходы: “32”

Объяснение: В соответствии с порядком операций, первая операция, которую нужно выполнить, это +”2 (дополнительный + перед первой “2” рассматривается как унарный оператор). Таким образом, JavaScript преобразует тип «2» в числовой, а затем применяет к нему унарный знак + (т. е. рассматривает его как положительное число). В результате следующая операция теперь 1 + 2, что, конечно же, дает 3. Но тогда у нас есть операция между числом и строкой (т. е. 3 и «2»), поэтому еще раз JavaScript преобразует тип числовое значение в строку и выполняет конкатенацию строк, что дает «32».

Пример 3: 1 + -”1 + “2” Выходы: “02”

Объяснение: Объяснение здесь идентично предыдущему примеру, за исключением того, что унарный оператор — —, а не +. Таким образом, «1» становится 1, который затем становится -1, когда применяется -, который затем добавляется к 1, давая 0, который затем преобразуется в строку и объединяется с последним операндом «2», давая «02».

Пример 4: +"1 + "1" + "2" Выходы: "112"

Объяснение: Хотя первый операнд «1» приводится к числовому значению на основе предшествовавшего ему унарного оператора +, он сразу же преобразуется обратно в строку, когда он объединяется со вторым операндом «1», который затем объединяется. с последним операндом «2», что дает строку «112».

Пример 5: «А» — «В» + «2» Выходы: «NaN2»

Объяснение: Поскольку оператор — нельзя применять к строкам и поскольку ни «A», ни «B» не могут быть преобразованы в числовые значения, «A» — «B» дает NaN, который затем объединяется со строкой «2» в выход «NaN2».

Пример 6: «A» — «B» + 2 выхода: NaN

Объяснение: Как объяснялось в предыдущем примере, «A» — «B» дает NaN. Но любой оператор, примененный к NaN с любым другим числовым операндом, все равно даст NaN.

What will be the output when the following code is executed? 
Explain. console.log(false == '0') console.log(false === '0')

Код выведет:

true
false

В JavaScript есть два набора операторов равенства. Оператор тройного равенства === ведет себя так же, как любой традиционный оператор равенства: оценивается как истина, если два выражения на любой из его сторон имеют одинаковый тип и одно и то же значение. Однако оператор двойного равенства пытается привести значения перед их сравнением. Поэтому обычно рекомендуется использовать ===, а не ==. То же самое справедливо и для !== против !=

What is the output out of the following code?
 var a={};
 b={key:'b'};
 c={key:'c'};
 
 a[b]=123;
 a[c]=456;
 console.log(a[b]);

Вывод этого кода будет 456 (не 123).

Причина этого заключается в следующем: при установке свойства объекта JavaScript неявно «строит» значение параметра. В этом случае, поскольку b и c оба являются объектами, они оба будут преобразованы в «[object Object]». В результате a[b] и a[c] эквивалентны a[“[object Object]”] и могут использоваться взаимозаменяемо. Следовательно, установка или ссылка на a[c] точно такая же, как установка или ссылка на a[b].

What will this code print?
for (let i = 0; i < 5; i++) { 
        setTimeout(function() { console.log(i); }, i * 1000 ); 
}

Он напечатает 0 1 2 3 4, потому что здесь мы используем let вместо var. Переменная i видна только в области блока цикла for.

What will the code below output? 
console.log(0.1 + 0.2); console.log(0.1 + 0.2 == 0.3);

Образованный ответ на этот вопрос будет просто: «Вы не можете быть уверены. он может распечатать 0,3 и верно, а может и нет. Все числа в JavaScript обрабатываются с точностью с плавающей запятой и поэтому не всегда могут давать ожидаемые результаты».

Приведенный выше пример является классическим случаем, демонстрирующим эту проблему. Удивительно, но он распечатает:

0.30000000000000004
false
What will be the output of this code
 var x = 21; 
 var girl = function () {
   
   console.log(x); 
   
   var x = 20;
}
girl();

Ни 21, ни 20, результат не определен

Это потому, что инициализация JavaScript не поднимается.

Почему он не показывает глобальное значение 21?

Причина в том, что когда функция выполняется, она проверяет наличие локальной переменной x, но еще не объявляет ее, поэтому не будет искать глобальную.

What do the following lines output, and why? 
console.log(1 < 2 < 3); 
console.log(3 > 2 > 1);

Первый оператор возвращает true, как и ожидалось.

Второй возвращает false из-за того, как механизм работает в отношении ассоциативности операторов для ‹ и ›. Он сравнивает слева направо, поэтому 3 › 2 › 1 JavaScript преобразуется в true › 1. true имеет значение 1, поэтому затем он сравнивает 1 › 1, что является ложью.

What will the following code output and why? 
var b = 1; 
function outer(){
 
var b = 2
function inner(){ 
b++; 
var b = 3; 
console.log(b)
}
 
inner(); 
}
 
outer();

Вывод на консоль будет «3».

В примере есть три замыкания, каждое из которых имеет собственное объявление var b. Когда вызывается переменная, замыкания будут проверяться в порядке от локального к глобальному, пока не будет найден экземпляр. Так как внутреннее замыкание имеет собственную переменную b, это то, что будет выведено.

Кроме того, из-за подъема код во внутреннем коде будет интерпретироваться следующим образом:

function inner () {
    var b; // b is undefined
    b++; // b is NaN
    b = 3; // b is 3
    console.log(b); // output "3"
}

Надеюсь, эта статья будет полезной для подготовки к интервью!!