Teil 1: Top(1-5) häufige JavaScript-Fragen

Jan 30 2023

JavaScript ist eine Programmiersprache, die bei Stellenausschreibungen zu den gefragtesten Sprachen zählt. Es handelt sich um eine vielseitige Sprache, die für die Webentwicklung, die Entwicklung mobiler Apps, die Garçon-Side-Programmierung und mehr verwendet wird.

In diesem Blogbeitrag gehen wir auf fünf häufig gestellte JavaScript-Interviewfragen ein, die in Fachinterviews häufig gestellt werden.

Diese Fragen decken eine Reihe von Motiven ab, von einleitenden allgemeinen Themen wie let und var bis hin zu fortgeschritteneren Motiven wie Abschlüssen und Erbe. Wenn Sie diese Fragen und ihre Antworten verstehen, sind Sie besser auf Ihr bevorstehendes JavaScript-Interview vorbereitet.

Frage 1: Was ist der Unterschied zwischen let, const und var in JavaScript?

In JavaScript können Variablen mit drei verschiedenen Schlüsselwörtern deklariert werden: „var“, „let“ und „const“. Jedes dieser Schlüsselwörter hat seine eigenen Eigenschaften und Anwendungsfälle.

Der Hauptunterschied zwischen „var“ und „let“ liegt im Umfang der Variablen, die sie deklarieren. Mit „var“ deklarierte Variablen sind funktionsbezogen, was bedeutet, dass auf sie nur innerhalb der Funktion zugegriffen werden kann, in der sie deklariert wurden. Mit „let“ deklarierte Variablen sind blockbezogen, was bedeutet, dass auf sie nur innerhalb des Blocks zugegriffen werden kann, in dem sie deklariert wurden.

Der Hauptunterschied zwischen „let“ und „const“ besteht darin, dass mit „let“ deklarierte Variablen neu zugewiesen werden können, während mit „const“ deklarierte Variablen nicht neu zugewiesen werden können. Wenn es sich bei der Variablen jedoch um ein Objekt handelt, können wir ihre Pakete dennoch ändern.

Dann folgt eine Illustration, um den Unterschied zwischen „let“ und „const“ im Hinblick auf die Neuzuweisung zu veranschaulichen

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

In JavaScript ist eine Prüfung eine Funktion, die Zugriff auf die Variablen in ihrem übergeordneten Kompass hat, und zwar erst dann, wenn die Ausführung der übergeordneten Funktion abgeschlossen ist. Dadurch kann die innere Funktion die Werte der Variablen in ihrem übergeordneten Kompass „rückblenden“, auch wenn sie nicht mehr im Speicher sind.

Dann folgt eine einfache Illustration, die das Konzept des Schecks veranschaulicht

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

Abschlüsse werden in JavaScript häufig verwendet, um private Variablen zu erzeugen, Aufrufe zu erzeugen und Module anzuwenden.

Dann folgt eine Illustration, die zeigt, wie Abschlüsse zum Erzeugen privater Variablen verwendet werden können

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

Zusammenfassend lässt sich sagen, dass Abschlüsse eine wichtige Allgemeingültigkeit in JavaScript sind, die es inneren Funktionen ermöglichen, den Zugriff auf Variablen in ihrem übergeordneten Kompass auch dann beizubehalten, wenn die übergeordnete Funktion die Ausführung abgeschlossen hat. Sie werden häufig in zahlreichen anderen Skripten verwendet, um eine wichtigere und flexiblere Möglichkeit zum Schreiben von Code zu bieten.

Frage 3: Was ist Heben in JavaScript?

In JavaScript ist das Heben ein Medium, bei dem Variablen- und Funktionsbestätigungen an die Spitze ihres Kompasses verschoben werden, bevor das Gesetz ausgeführt wird. Dies bedeutet, dass Variablen und Funktionen verwendet werden können, bevor sie im Code deklariert werden.

Zur Veranschaulichung: Das folgende Gesetz funktioniert tatsächlich, auch wenn die Variable x nach ihrer Verwendung deklariert wird

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

Dennoch gilt das Hochziehen nur für Bestätigungen und nicht für Initialisierungen. Daher löst das folgende Gesetz einen ReferenceError aus

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

Außerdem werden Funktionsbejahungen auf die Spitze getrieben, sodass das folgende Gesetz funktioniert

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

Zusammenfassend ist Hoisting ein Mechanismus in JavaScript, bei dem Variablen- und Funktionsdeklarationen an den Anfang ihres Gültigkeitsbereichs verschoben werden, bevor der Code ausgeführt wird. Dadurch können Variablen und Funktionen verwendet werden, bevor sie im Code deklariert werden. Dies kann jedoch das Verständnis des Codes erschweren und bei unsachgemäßer Verwendung zu unerwarteten Fehlern führen.

Frage 4: Wie funktioniert das Schlüsselwort „this“ in JavaScript?

In JavaScript bezieht sich das Schlüsselwort „this“ auf das Objekt, dessen Methode die Funktion ist, oder auf das Objekt, für das die Funktion aufgerufen wird. Der Wert von „this“ kann sich je nach Aufruf der Funktion ändern.

Hier sind ein paar Beispiele, um zu zeigen, wie „das“ in verschiedenen Kontexten funktioniert:

Im globalen Bereich bezieht sich „this“ auf das globale Objekt (Fenster im Browser und global in 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

In JavaScript werden sowohl die doppelten Gleichheitszeichen (==) als auch die dreifachen Gleichheitszeichen (===) zum Vergleich verwendet, sie funktionieren jedoch unterschiedlich.

Das Double equal (==) vergleicht Werte auf Gleichheit, prüft jedoch nicht den Datentyp der verglichenen Werte. Dies bedeutet, dass bei Bedarf eine Typerzwingung durchgeführt wird, um den Vergleich durchzuführen.

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

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

Kurz gesagt, das Double-Equals-Verfahren (==) vergleicht Werte auf Gleichheit und führt bei Bedarf eine Typumsetzung durch, während das Triple-Equals-Verfahren (===) sowohl den Wert als auch den Datentyp der verglichenen Werte vergleicht und keine Typumsetzung durchführt.

Wenn Sie mehr über das Codieren in Javascript erfahren möchten, folgen Sie mir unbedingt für weitere Codeausschnitte und Beispiele. Ich gebe Ihnen wertvolle Informationen und Tipps, wie Sie die Sprache beherrschen und Ihre Fähigkeiten als Entwickler verbessern. Bleiben Sie also auf dem Laufenden, um weitere Updates zu erhalten, und lassen Sie uns gemeinsam weiter lernen.