1. Каким будет вывод кода ниже?
const nums = [1,2,3,4,5,6,7];
nums.forEach((n) => {
    if(n%2 === 0) 
      break;
    console.log(n);
});

Вывод: 1,2,3,4,5,6,7
Объяснение: Многие из вас могли подумать, что вывод будет таким — 1.< br /> Но breakstatement работает только с такими циклами, как for, while, do…while, а не с map(), forEach(). По сути, это функции по своей природе, которые принимают обратный вызов, а не циклы.

2. Что выведет приведенный ниже код?

function foo() {
  return "I'm the outer function";
};


function test() {
  console.log(bar);
  return foo();
  var bar = "I'm a variable";
  function foo() {
    return "I'm the inner function";
  }
}
console.log(test());

Вывод:
undefined
Я внутренняя функция
Объяснение: Когда мы вызываем функцию test(), мы обращаемся к bar до того, как она инициализация. Но так как это переменная, а переменные поднимаются в Javascript. Таким образом, мы можем получить к ним доступ, но их значение будет неопределенным до тех пор, пока мы не достигнем их инициализации.
Затем мы вызываем функцию foo(). Поскольку функции также подняты в Javascript и доступны в любом месте кода. Таким образом, будет вызвана и выполнена функция foo(), присутствующая внутри функции test().

3. Что выведет приведенный ниже код?

let a = true;
setTimeout(() => {
  a = false;
}, 2000)


while(a) {
  console.log(' -- inside whilee -- ');
}

Вывод: — — внутри while — — (бесконечное количество раз)
Объяснение: JavaScript синхронен по своей природе, он выполняет код, используя стек вызовов и стек вызовов ничего не ждет. Для выполнения асинхронных задач у нас есть очередь обратных вызовов, которая содержит все обратные вызовы, желающие быть выполненными. Цикл событий принимает их один за другим и помещает в стек вызовов только тогда, когда стек вызовов ничего не выполняет.
Теперь, в приведенном выше вопросе, у нас есть цикл while в нашем стеке вызовов. который представляет собой бесконечный цикл. Через 2 секунды обратный вызов setTimeout готов и ожидает выполнения, но, поскольку стек вызовов не простаивает, обратный вызов setTimeout никогда не получит шанса на выполнение.

4. Что выведет приведенный ниже код?

setTimeout(() => console.log(1), 0);

console.log(2);

new Promise(res => {
  console.log(3)
  res();
}).then(() => console.log(4));

console.log(5);

Вывод: 2,3,5,4,1
Объяснение:В приведенном выше вопросе мы обсуждали, как асинхронные задачи выполняются в JS с использованием цикла обработки событий.< br /> В этом вопросе есть 2 неточности.
a. Почему 3 печатается сразу после 2?
new Promise(res… — это создает новое обещание, и все, что написано внутри обратного вызова Promise(), является синхронной задачей, поэтому оно будет выполняться на ходу.
б. Почему 4 печатается раньше 1?
В приведенном выше коде есть 2 асинхронных задачи. Но очередь микрозадач имеет более высокий приоритет, чем очередь обратного вызова, и обещания хранятся в очереди микрозадач по сравнению с setTimeout, который хранится в очереди обратного вызова. Таким образом, Promise res() будет выполняться первым.

5. Что выведет приведенный ниже код?

async function foo() {
  console.log("A");
  await Promise.resolve();
  console.log("B");
  await new Promise(resolve => setTimeout(resolve, 0));
  console.log("C");
}

console.log("D");
foo();
console.log("E");

Выходные данные: D, A, E, B, C
Объяснение:
Основной контекст регистрирует «D», поскольку он является синхронным и выполняется немедленно.
Функция foo() выводит на консоль 'A', поскольку она синхронна и выполняется немедленно.
await Promise.resolve();: Эта строка ожидает разрешения промиса. Функция Promise.resolve() немедленно возвращает разрешенное обещание. Управление временно возвращается вызывающей функции (foo()), что позволяет выполнять другие синхронные операции.
Вернемся к основному контексту:
console.log("E");: эта строка выводит на консоль «E», поскольку это синхронная операция. . Функция foo() все еще не полностью выполнена и ожидает разрешения промиса внутри нее.
Внутри foo() (возобновление выполнения):
console.log("B");: Эта строка выводит в консоль 'B', поскольку это синхронная операция.
await new Promise(resolve => setTimeout(resolve, 0));: Эта строка ожидает разрешения обещания, возвращаемого функцией setTimeout. Несмотря на то, что задержка установлена ​​на 0 миллисекунд, обратный вызов setTimeout помещается в очередь обратных вызовов, позволяя продолжить выполнение синхронного кода.
Вернемся к основному контексту:
Элемент управления все еще ожидает выполнения функции foo(). завершено.
Внутри foo() (возобновление выполнения):
Обратный вызов от setTimeout берется из очереди обратных вызовов, и обещание разрешается. Это позволяет выполнить следующую await.
console.log("C");: Эта строка выводит на консоль «C», поскольку это синхронная операция.
Функция foo() завершается.