Parte 1: principais (1-5) perguntas comuns sobre JavaScript

Jan 30 2023

JavaScript é uma linguagem de programação que se tornou um dos cortes mais procurados na solicitação de trabalho. É uma linguagem proteana usada para desenvolvimento da Web, desenvolvimento de aplicativos móveis, programação garçon-side e muito mais.

Nesta postagem do blog, abordaremos 5 perguntas comuns sobre entrevistas em JavaScript que são feitas com frequência em entrevistas especializadas.

Essas perguntas cobrirão uma variedade de motivos, desde generalidades introdutórias semelhantes a let e var, até motivos mais avançados, como fechamentos e herança. Ao entender essas perguntas e suas respostas, você estará mais preparado para sua próxima entrevista sobre JavaScript.

Pergunta 1: Qual é a diferença entre let, const e var em JavaScript?

Em JavaScript, as variáveis podem ser declaradas usando três palavras-chave diferentes “var”,” let” e “const”. Cada uma dessas palavras-chave tem suas próprias características e casos de uso.

A principal diferença entre “var” e “let” está no compasso das variáveis que eles declaram. As variáveis declaradas com “var” têm escopo de função, o que significa que só podem ser acessadas dentro da função em que foram declaradas. As variáveis declaradas com “let” têm escopo de bloco, o que significa que só podem ser acessadas dentro do bloco em que foram declaradas.

A principal diferença entre “let” e “const” é que variáveis declaradas com “let” podem ser reatribuídas, enquanto variáveis declaradas com “const” não podem ser reatribuídas. ainda assim, se a variável for um objeto, ainda podemos alterar suas parcelas.

Segue uma ilustração para demonstrar a diferença entre “let” e “const” em termos de reatribuição

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

Em JavaScript, uma verificação é uma função que tem acesso às variáveis em sua bússola pai, na verdade, depois que a função pai termina de executar. Isso permite que a função interna “recupere” os valores das variáveis em sua bússola pai, mesmo se eles não estiverem mais na memória.

Segue uma ilustração simples que demonstra a concepção de cheque

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

Closures são frequentemente usados em JavaScript para produzir variáveis privadas, para produzir chamadas e para aplicar módulos.

A seguir, uma ilustração que demonstra como os encerramentos podem ser usados para produzir variáveis privadas

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

Em resumo, fechamentos são uma generalidade importante em JavaScript que permite que funções internas retenham acesso a variáveis em sua bússola pai mesmo depois que a função pai tiver concluído a execução. Eles são consideravelmente usados em vários scripts diferentes para fornecer uma maneira mais importante e flexível de escrever código.

Pergunta 3: O que é hoisting em JavaScript?

Em JavaScript, hoisting é um meio em que as afirmações de variáveis e funções são movidas para o topo de sua bússola antes que a lei seja executada. Isso significa que variáveis e funções podem ser usadas antes de serem declaradas no código.

Para ilustração, a seguinte lei funcionará de fato, embora a variável x seja declarada após ser usada

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

ainda assim, a elevação só se aplica a afirmações e não inicializações. assim, a seguinte lei lançará um ReferenceError

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

Além disso, as afirmações de função também são elevadas ao topo de sua bússola, então a seguinte lei funcionará

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

Em resumo, hoisting é um mecanismo em JavaScript onde as declarações de variáveis e funções são movidas para o topo de seu escopo antes que o código seja executado. Isso permite que variáveis e funções sejam usadas antes de serem declaradas no código, mas pode tornar o código mais difícil de entender e pode levar a erros inesperados se não for usado com cuidado.

Pergunta 4: Como a palavra-chave “this” funciona em JavaScript?

Em JavaScript, a palavra-chave “this” refere-se ao objeto do qual a função é um método ou ao objeto no qual a função é chamada. O valor de “this” pode mudar dependendo de como a função é chamada.

Aqui estão alguns exemplos para demonstrar como “isto” funciona em diferentes contextos:

No escopo global, “this” refere-se ao objeto global (janela no navegador e global no Node.js)

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

Em JavaScript, o igual duplo (==) e o igual triplo (===) são usados para comparação, mas funcionam de maneira diferente.

O double equals (==) compara valores para igualdade, mas não verifica o tipo de dados dos valores que estão sendo comparados. Isso significa que ele executará a coerção de tipo, se necessário, para fazer a comparação.

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

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

Resumindo, o double equals (==) compara valores para igualdade e executa a coerção de tipo, se necessário, enquanto o triple equals (===) compara o valor e o tipo de dados dos valores que estão sendo comparados e não executa a coerção de tipo.

Se você estiver interessado em aprender mais sobre codificação em Javascript, siga-me para mais exemplos e trechos de código. Estarei compartilhando informações e dicas valiosas sobre como dominar o idioma e aprimorar suas habilidades como desenvolvedor. Portanto, fique atento para mais atualizações e vamos continuar aprendendo juntos.