Parte 1: Principales (1-5) preguntas comunes de JavaScript

Jan 30 2023

JavaScript es un lenguaje de programación que se ha convertido en una de las chuletas más demandadas en la demanda laboral. Es un lenguaje proteico que se utiliza para el desarrollo web, el desarrollo de aplicaciones móviles, la programación de Garçonside y más.

En esta publicación de blog, cubriremos 5 preguntas comunes de entrevistas de JavaScript que se hacen con frecuencia en entrevistas especializadas.

Estas preguntas cubrirán una variedad de motivos, desde generalidades introductorias similares a let y var, hasta motivos más avanzados como cierres y patrimonio. Al comprender estas preguntas y sus respuestas, estará más preparado para su próxima entrevista de JavaScript.

Pregunta 1: ¿Cuál es la diferencia entre let, const y var en JavaScript?

En JavaScript, las variables se pueden declarar usando tres palabras clave diferentes "var", "let" y "const". Cada una de estas palabras clave tiene sus propias características y casos de uso.

La principal diferencia entre "var" y "let" está en la brújula de las variables que declaran. Las variables declaradas con "var" tienen un alcance de función, lo que significa que solo son accesibles dentro de la función en la que fueron declaradas. Las variables declaradas con "let" tienen un alcance de bloque, lo que significa que solo son accesibles dentro del bloque en el que fueron declaradas.

La principal diferencia entre "let" y "const" es que las variables declaradas con "let" se pueden reasignar, mientras que las variables declaradas con "const" no se pueden reasignar. aun así, si la variable es un objeto, aún podemos cambiar sus parcelas.

Luego hay una ilustración para demostrar la diferencia entre "let" y "const" en términos de reasignación

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

En JavaScript, una verificación es una función que tiene acceso a las variables en su brújula principal, de hecho, después de que la función principal haya terminado de ejecutarse. Esto permite que la función interna "recupere" los valores de las variables en su brújula principal, de hecho, si ya no están en la memoria.

Luego hay una ilustración simple que demuestra la concepción del cheque.

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

Los cierres se usan con frecuencia en JavaScript para producir variables privadas, producir llamadas y aplicar módulos.

Luego hay una ilustración que demuestra cómo se pueden usar los cierres para producir variables 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

En resumen, los cierres son una generalidad importante en JavaScript que permite que las funciones internas retengan el acceso a las variables en su brújula principal después de que la función principal haya completado la ejecución. Se usan considerablemente en multitud de scripts diferentes para brindar una forma más importante y flexible de escribir código.

Pregunta 3: ¿Qué es izar en JavaScript?

En JavaScript, el levantamiento es un medio donde las afirmaciones de variables y funciones se mueven a la parte superior de su brújula antes de que se ejecute la ley. Esto significa que las variables y funciones se pueden usar antes de que se declaren en el código.

A modo de ilustración, la siguiente ley funcionará aunque la variable x se declare después de su uso

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

aún así, el levantamiento solo se aplica a las afirmaciones y no a las inicializaciones. por lo tanto, la siguiente ley arrojará un ReferenceError

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

Además, las afirmaciones de función también se elevan a la parte superior de su brújula, por lo que la siguiente ley funcionará

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

En resumen, el levantamiento es un mecanismo en JavaScript donde las declaraciones de variables y funciones se mueven a la parte superior de su alcance antes de que se ejecute el código. Esto permite usar variables y funciones antes de que se declaren en el código, pero puede hacer que el código sea más difícil de entender y puede provocar errores inesperados si no se usa con cuidado.

Pregunta 4: ¿Cómo funciona la palabra clave "esto" en JavaScript?

En JavaScript, la palabra clave "esto" se refiere al objeto del que la función es un método o al objeto al que se llama la función. El valor de "esto" puede cambiar dependiendo de cómo se llame a la función.

Aquí hay algunos ejemplos para demostrar cómo funciona "esto" en diferentes contextos:

En el ámbito global, "esto" se refiere al objeto global (ventana en el navegador y global en 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

En JavaScript, el doble igual (==) y el triple igual (===) se usan para comparar, pero funcionan de manera diferente.

El doble igual (==) compara valores para la igualdad, pero no comprueba el tipo de datos de los valores que se comparan. Esto significa que realizará coerción de tipo si es necesario para poder realizar la comparación.

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

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

En resumen, el doble es igual a (==) compara valores para la igualdad y realiza la conversión de tipos si es necesario, mientras que el triple es igual a (===) compara tanto el valor como el tipo de datos de los valores que se comparan y no realiza la conversión de tipos.

Si está interesado en aprender más sobre la codificación en Javascript, asegúrese de seguirme para obtener más fragmentos de código y ejemplos. Estaré compartiendo información valiosa y consejos sobre cómo dominar el lenguaje y mejorar tus habilidades como desarrollador. Entonces, estén atentos para más actualizaciones y sigamos aprendiendo juntos.