Часть 1. Самые распространенные (1–5) вопросы по JavaScript

Jan 30 2023
JavaScript — это язык программирования, который стал одним из самых востребованных в запросе на работу. Это многообразный язык, который используется для веб-разработки, разработки мобильных приложений, программирования на стороне гарсона и многого другого.

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

В этом сообщении блога мы рассмотрим 5 распространенных вопросов на собеседованиях по JavaScript, которые часто задают на специализированных собеседованиях.

Эти вопросы будут охватывать ряд мотивов, от вводных обобщений, таких как let и var, до более сложных мотивов, таких как замыкания и наследие. Поняв эти вопросы и ответы на них, вы будете лучше подготовлены к предстоящему собеседованию по JavaScript.

Вопрос 1: В чем разница между let, const и var в JavaScript?

В JavaScript переменные могут быть объявлены с использованием трех разных ключевых слов: «var», «let» и «const». Каждое из этих ключевых слов имеет свои особенности и варианты использования.

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

Основное различие между let и const заключается в том, что переменные, объявленные с помощью let, могут быть переназначены, в то время как переменные, объявленные с помощью const, не могут быть переназначены. тем не менее, если переменная является объектом, мы все равно можем изменить ее посылки.

Затем иллюстрация, демонстрирующая разницу между «let» и «const» с точки зрения переназначения.

let x = 1;
x = 2; // allowed

const y = 1;
y = 2; // not allowed, will throw an error

const z = {a: 1};
z.a = 2; // allowed, we can change the properties of the object

В JavaScript проверка — это функция, которая имеет доступ к переменным в своем родительском компасе, даже после того, как родительская функция завершила выполнение. Это позволяет внутренней функции "воспроизвести" значения переменных в родительском компасе, даже если они больше не находятся в памяти.

Затем простая иллюстрация, демонстрирующая концепцию чека.

function outerFunction(x) {
    function innerFunction() {
        console.log(x);
    }
    return innerFunction;
}
let myClosure = outerFunction(10);
console.log(myClosure()); // Output: 10

Замыкания часто используются в JavaScript для создания закрытых переменных, вызовов и применения модулей.

Затем приведена иллюстрация, демонстрирующая, как замыкания могут использоваться для создания закрытых переменных.

function createCounter() {
    let count = 0;
    return {
        increment: function() {
            count++;
        },
        getCount: function() {
            return count;
        }
    }
}
let counter = createCounter();
counter.increment();
console.log(counter.getCount()); // Output: 1

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

Вопрос 3: Что такое подъем в JavaScript?

В JavaScript подъем — это среда, в которой подтверждения переменных и функций перемещаются на вершину их компаса до того, как закон будет выполнен. Это означает, что переменные и функции можно использовать до того, как они будут объявлены в коде.

Например, следующий закон действительно будет работать, несмотря на то, что переменная x объявлена ​​после ее использования.

console.log(x); // Output: undefined
var x = 5;

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

console.log(x); // ReferenceError: x is not defined
let x = 5;

Кроме того, функциональные утверждения также поднимаются на вершину компаса, поэтому следующий закон будет работать.

example(); // Output: "I am a hoisted function"
function example() {
    console.log("I am a hoisted function");
}

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

Вопрос 4: Как ключевое слово this работает в JavaScript?

В JavaScript ключевое слово this относится к объекту, методом которого является функция, или к объекту, для которого функция вызывается. Значение this может меняться в зависимости от того, как вызывается функция.

Вот несколько примеров, демонстрирующих, как «это» работает в разных контекстах:

  1. В глобальной области «это» относится к глобальному объекту (окну в браузере и глобальному в Node.js).
  2. console.log(this); // Output: window or global
    

    let person = {
      name: "John",
      sayName: function() {
        console.log(this.name);
      }
    };
    person.sayName(); // Output: "John"
    

    function Person(name) {
        this.name = name;
    }
    let john = new Person("John");
    console.log(john.name); // Output: "John"
    

    <button id="myButton">Click me</button>
    <script>
        let button = document.getElementById("myButton");
        button.addEventListener("click", function() {
            console.log(this); // Output: the button element
        });
    </script>
    

    let person = {
      name: "John",
      sayName: () => {
        console.log(this.name);
      }
    };
    person.sayName(); // Output: undefined
    

В JavaScript двойное равенство (==) и тройное равенство (===) используются для сравнения, но они работают по-разному.

Двойное равенство (==) сравнивает значения на равенство, но не проверяет тип данных сравниваемых значений. Это означает, что он будет выполнять приведение типов, если это необходимо для выполнения сравнения.

console.log(1 == "1"); // Output: true
console.log(true == 1); // Output: true

console.log(1 === "1"); // Output: false
console.log(true === 1); // Output: false

Короче говоря, двойное равенство (==) сравнивает значения на равенство и при необходимости выполняет приведение типов, тогда как тройное равенство (===) сравнивает как значение, так и тип данных сравниваемых значений и не выполняет приведение типов.

Если вы хотите узнать больше о программировании на Javascript, обязательно подпишитесь на меня, чтобы получить дополнительные фрагменты кода и примеры. Я буду делиться ценной информацией и советами о том, как освоить язык и улучшить свои навыки разработчика. Итак, следите за обновлениями, и давайте продолжим учиться вместе.

Спасибо за прочтение. Удачного обучения

Поддержите нашу публикацию, подписавшись на нее

Введение в архитектуру Spark Узнайте больше об объектах-компаньонах в Kotlin Java Реализация ServiceLocatorFactoryBean Эффективное определение простых чисел (1 — n) в JavaScript: пошаговое руководство — Погрузитесь в…