Sie benötigen nur ein Javascript-Cheatsheet!

Unterschiede zwischen var, let und const

1. Übersicht über var, let und const

Feature	var	let	const
Scope	Function-scoped	Block-scoped	Block-scoped
Re-declaration	Allowed within the same scope	Not allowed in the same scope	Not allowed in the same scope
Re-assignment	Allowed	Allowed	Not allowed after initialization
Initialization	Can be declared without initialization	Can be declared without initialization	Must be initialized at the time of declaration
Hoisting	Hoisted but initialized to undefined	Hoisted but not initialized	Hoisted but not initialized

Funktion

---

var

lassen const

Type	Function Scope	Block Scope
var	Variables are scoped to the enclosing function.	Does not support block scope. A var inside a block (if, for, etc.) leaks into the enclosing function or global scope.
let / const	Not function-scoped.	Variables are confined to the block they are declared in.

Geltungsbereich Funktionsbezogen Blockbezogen Blockbezogen

Neuanmeldung

Im selben Bereich zulässig Im selben Bereich nicht zulässig Im selben Bereich nicht zulässig Neuzuweisung
Zulässig Zulässig Nach der Initialisierung nicht zulässig Initialisierung

if (true) {
  var x = 10;
  let y = 20;
  const z = 30;
}
console.log(x); // 10 (accessible because of function scope)
console.log(y); // ReferenceError (block-scoped)
console.log(z); // ReferenceError (block-scoped)

Kann ohne Initialisierung deklariert werden Kann ohne Initialisierung deklariert werden Muss zum Zeitpunkt der Deklaration initialisiert werden

---

Heben

Gehoben, aber auf undefiniert initialisiert Gehemmt, aber nicht initialisiert Gehemmt, aber nicht initialisiert

2. Unterschiede im Geltungsbereich

Feature	var	let	const
Re-declaration	Allowed	Not allowed	Not allowed
Re-assignment	Allowed	Allowed	Not allowed

Typ Funktionsumfang Blockbereich var Variablen sind auf die einschließende Funktion beschränkt. Unterstützt keinen Blockbereich. Eine Variable innerhalb eines Blocks (if, for usw.) dringt in die umschließende Funktion oder den globalen Bereich ein. let / const Nicht funktionsbezogen. Variablen sind auf den Block beschränkt, in dem sie deklariert werden. Beispiel: 3. Neudeklaration und Neuzuweisung Funktion var lassen const Neuanmeldung Zulässig Nicht zulässig Nicht zulässig Neuzuweisung Zulässig Zulässig Nicht zulässig

Beispiel:

if (true) {
  var x = 10;
  let y = 20;
  const z = 30;
}
console.log(x); // 10 (accessible because of function scope)
console.log(y); // ReferenceError (block-scoped)
console.log(z); // ReferenceError (block-scoped)

---

4. Hebeverhalten

Type	Hoisting Behavior
var	Hoisted to the top of the scope but initialized as undefined.
let	Hoisted but not initialized. Accessing it before declaration causes a ReferenceError.
const	Hoisted but not initialized. Must be initialized at the time of declaration.

Typ

Hebeverhalten

var
An die Spitze des Gültigkeitsbereichs gehoben, aber als undefiniert initialisiert. lassen

// Re-declaration
var a = 10;
var a = 20; // Allowed

let b = 30;
// let b = 40; // SyntaxError: Identifier 'b' has already been declared

const c = 50;
// const c = 60; // SyntaxError: Identifier 'c' has already been declared

// Re-assignment
a = 15; // Allowed
b = 35; // Allowed
// c = 55; // TypeError: Assignment to constant variable

Gehemmt, aber nicht initialisiert. Der Zugriff darauf vor der Deklaration führt zu einem ReferenceError.

---

const

Gehemmt, aber nicht initialisiert. Muss zum Zeitpunkt der Deklaration initialisiert werden. Beispiel:

Feature	let and const
Block Scope	Both are confined to the block in which they are declared.
No Hoisting Initialization	Both are hoisted but cannot be accessed before initialization.
Better Practice	Preferred over var for predictable scoping.

---

5. Ähnlichkeiten zwischen let und const

Scenario	Recommended Keyword
Re-declare variables or use function scope	var (generally avoid unless necessary for legacy code).
Variables that may change	let (e.g., counters, flags, intermediate calculations).
Variables that should not change	const (e.g., configuration settings, fixed values).

Funktion let und const Blockbereich Beide sind auf den Block beschränkt, in dem sie deklariert sind. Keine Hebeinitialisierung Beide sind aktiviert, können aber vor der Initialisierung nicht aufgerufen werden. Bessere Vorgehensweise Für vorhersagbares Scoping gegenüber var bevorzugt. 6. Wann welche verwenden? Szenario Empfohlenes Schlüsselwort Variablen neu deklarieren oder Funktionsumfang verwenden var (im Allgemeinen vermeiden, es sei denn, dies ist für Legacy-Code erforderlich). Variablen, die sich ändern können let (z. B. Zähler, Flags, Zwischenberechnungen). Variablen, die sich nicht ändern sollten const (z. B. Konfigurationseinstellungen, feste Werte).

---

7. Erklärung zum Heben

Was ist Heben?

Hoisting ist das Standardverhalten von JavaScript, bei dem Deklarationen während der Kompilierungsphase an den Anfang ihres Gültigkeitsbereichs verschoben werden.

• var: Angehoben und auf undefiniert initialisiert.
• let / const: Angehoben, aber nicht initialisiert. Dadurch entsteht eine temporäre Totzone (TDZ) vom Start des Blocks bis zum Auftreffen auf die Deklaration.

---

Warum das Heben auf diese Weise funktioniert?

1. Zusammenstellungsphase: JavaScript scannt zunächst den Code, um einen Speicherplatz für Variablen- und Funktionsdeklarationen zu erstellen. Zu diesem Zeitpunkt:

• var-Variablen werden auf undefiniert initialisiert.
• let- und const-Variablen werden „angehoben“, aber nicht initialisiert, daher die TDZ.
• Funktionsdeklarationen sind vollständig aktiviert.

1. Ausführungsphase: JavaScript beginnt mit der zeilenweisen Ausführung des Codes. Variablen und Funktionen werden in dieser Phase Werte zugewiesen.

---

8. Zusammenfassung des Hebevorgangs

Type	Hoisting	Access Before Declaration
var	Hoisted and initialized to undefined.	Allowed but value is undefined.
let	Hoisted but not initialized.	Causes a ReferenceError.
const	Hoisted but not initialized.	Causes a ReferenceError.

Typ Heben Zugriff vor der Erklärung var Gehemmt und auf undefiniert initialisiert. Zulässig, aber der Wert ist undefiniert. lassen Gehemmt, aber nicht initialisiert. Verursacht einen ReferenceError. const Gehemmt, aber nicht initialisiert. Verursacht einen ReferenceError.

Beispiel:

if (true) {
  var x = 10;
  let y = 20;
  const z = 30;
}
console.log(x); // 10 (accessible because of function scope)
console.log(y); // ReferenceError (block-scoped)
console.log(z); // ReferenceError (block-scoped)

---

Fazit

1. Verwenden Sie const wann immer möglich für Variablen, die keiner Neuzuweisung bedürfen.
2. Verwenden Sie let für Variablen, die innerhalb desselben Bereichs neu zugewiesen werden müssen.
3. Vermeiden Sie var, es sei denn, Sie arbeiten mit Legacy-Code oder erfordern funktionsbezogenes Verhalten.

---

JavaScript-Datentypen

JavaScript verfügt über verschiedene Datentypen, die in Primitive und Nicht-Primitive (Referenz)-Typen unterteilt sind. Hier finden Sie jeweils eine Erklärung mit Beispielen und Unterschieden:

---

1. Primitive Datentypen

Primitive Typen sind unveränderlich, was bedeutet, dass ihre Werte nach ihrer Erstellung nicht geändert werden können. Sie werden direkt im Speicher gespeichert.

Data Type	Example	Description
String	"hello", 'world'	Represents a sequence of characters (text). Enclosed in single (''), double (""), or backticks ().
Number	42, 3.14, NaN	Represents both integers and floating-point numbers. Includes NaN (Not-a-Number) and Infinity.
BigInt	123n, 9007199254740991n	Used for numbers larger than Number.MAX_SAFE_INTEGER (2^53 - 1). Add n to create a BigInt.
Boolean	true, false	Represents logical values, used in conditions to represent "yes/no" or "on/off".
Undefined	undefined	Indicates a variable has been declared but not assigned a value.
Null	null	Represents an intentional absence of value. Often used to reset or clear a variable.
Symbol	Symbol('id')	Represents a unique identifier, mainly used as property keys for objects to avoid collisions.

Datentyp Beispiel Beschreibung String „Hallo“, „Welt“ Stellt eine Folge von Zeichen (Text) dar. Eingeschlossen in einfache (''), doppelte ("") oder Backticks (). Nummer 42, 3,14, NaN Stellt sowohl Ganzzahlen als auch Gleitkommazahlen dar. Beinhaltet NaN (Not-a-Number) und Infinity. BigInt 123n, 9007199254740991n Wird für Zahlen verwendet, die größer als Number.MAX_SAFE_INTEGER (2^53 - 1) sind. Fügen Sie n hinzu, um ein BigInt zu erstellen. Boolean wahr, falsch Stellt logische Werte dar, die in Bedingungen verwendet werden, um „Ja/Nein“ oder „Ein/Aus“ darzustellen. Undefiniert undefiniert Zeigt an, dass eine Variable deklariert wurde, aber kein Wert zugewiesen wurde. Null null Stellt eine absichtliche Abwesenheit von Wert dar. Wird oft zum Zurücksetzen oder Löschen einer Variablen verwendet. Symbol Symbol('id') Stellt eine eindeutige Kennung dar, die hauptsächlich als Eigenschaftsschlüssel für Objekte verwendet wird, um Kollisionen zu vermeiden.

---

2. Nicht-primitive (Referenz-)Datentypen

Nicht-primitive Typen sind veränderbar und werden per Referenz gespeichert. Sie werden zum Speichern von Datensammlungen oder komplexeren Einheiten verwendet.

Data Type	Example	Description
Object	{name: 'John', age: 30}	A collection of key-value pairs. Keys are strings (or Symbols), and values can be any type.
Array	[1, 2, 3, "apple"]	A list-like ordered collection of values. Access elements via index (e.g., array[0]).
Function	function greet() {}	A reusable block of code that can be executed. Functions are first-class citizens in JavaScript.
Date	new Date()	Represents date and time. Provides methods for manipulating dates and times.
RegExp	/pattern/	Represents regular expressions used for pattern matching and string searching.
Map	new Map()	A collection of key-value pairs where keys can be of any type, unlike plain objects.
Set	new Set([1, 2, 3])	A collection of unique values, preventing duplicates.
WeakMap	new WeakMap()	Similar to Map, but keys are weakly held, meaning they can be garbage-collected.
WeakSet	new WeakSet()	Similar to Set, but holds objects weakly to prevent memory leaks.

---

3. Hauptunterschiede zwischen primitiven und nicht-primitiven Typen

Aspect	Primitive Types	Non-Primitive Types
Mutability	Immutable: Values cannot be changed.	Mutable: Values can be modified.
Storage	Stored directly in memory.	Stored as a reference to a memory location.
Copy Behavior	Copied by value (creates a new value).	Copied by reference (points to the same object).
Examples	string, number, boolean, etc.	object, array, function, etc.

---

4. Sonderfälle

Typ des Operators

• typeof null: Gibt „Objekt“ aufgrund eines historischen Fehlers in JavaScript zurück, aber null ist kein Objekt.
• Typ von NaN: Gibt „Zahl“ zurück, auch wenn es „Keine Zahl“ bedeutet.
• Typ der Funktion: Gibt „Funktion“ zurück, die ein Untertyp des Objekts ist.

Dynamisches Tippen

JavaScript ermöglicht es Variablen, zur Laufzeit Werte unterschiedlichen Typs zu speichern:

if (true) {
  var x = 10;
  let y = 20;
  const z = 30;
}
console.log(x); // 10 (accessible because of function scope)
console.log(y); // ReferenceError (block-scoped)
console.log(z); // ReferenceError (block-scoped)

---

5. Beispiele für jeden Datentyp

Primitive Typen

// Re-declaration
var a = 10;
var a = 20; // Allowed

let b = 30;
// let b = 40; // SyntaxError: Identifier 'b' has already been declared

const c = 50;
// const c = 60; // SyntaxError: Identifier 'c' has already been declared

// Re-assignment
a = 15; // Allowed
b = 35; // Allowed
// c = 55; // TypeError: Assignment to constant variable

Nicht-primitive Typen

console.log(a); // undefined (hoisted)
var a = 10;

console.log(b); // ReferenceError (temporal dead zone)
let b = 20;

console.log(c); // ReferenceError (temporal dead zone)
const c = 30;

---

6. Zusammenfassung der Art der Ergebnisse

Expression	Result
typeof "hello"	"string"
typeof 42	"number"
typeof 123n	"bigint"
typeof true	"boolean"
typeof undefined	"undefined"
typeof null	"object"
typeof Symbol()	"symbol"
typeof {}	"object"
typeof []	"object"
typeof function(){}	"function"

Ausdruck

---

Ergebnis typeof „Hallo“ "Zeichenfolge" typeof 42 "Nummer" typeof 123n "bigint" typeof true "boolean" typeof undefiniert "undefiniert" typeof null "Objekt" typeof Symbol() "Symbol" typeof {} "Objekt" typeof [] "Objekt" typeof function(){} "Funktion"

Das obige ist der detaillierte Inhalt vonSie benötigen nur ein Javascript-Cheatsheet!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!