La seule aide-mémoire Javascript dont vous avez besoin !

Différences entre var, let et const

1. Présentation de var, let et 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

Fonctionnalité

---

var

laissons const

ête>

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.

Portée Portée fonction À portée de bloc À portée de bloc

Re-déclaration

Autorisé dans le même périmètre Non autorisé dans le même périmètre Non autorisé dans le même périmètre Réaffectation
Autorisé Autorisé Non autorisé après l'initialisation Initialisation

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)

Peut être déclaré sans initialisation Peut être déclaré sans initialisation Doit être initialisé au moment de la déclaration

---

Levage

Hissé mais initialisé à non défini Hissé mais non initialisé Hissé mais non initialisé

2. Différences de portée

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

Tapez Portée de la fonction Portée du bloc ête> var Les variables sont limitées à la fonction englobante. Ne prend pas en charge la portée du bloc. Une variable à l'intérieur d'un bloc (if, for, etc.) s'infiltre dans la fonction englobante ou dans la portée globale. let/const Ne s'applique pas aux fonctions. Les variables sont confinées au bloc dans lequel elles sont déclarées. Exemple : 3. Re-déclaration et réaffectation Fonctionnalité var laisser const ête> Re-déclaration Autorisé Non autorisé Non autorisé Réaffectation Autorisé Autorisé Non autorisé

Exemple :

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. Comportement de levage

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.

Tapez

Comportement de levage

ête> var
Hissé en haut de la portée mais initialisé comme non défini. laisser

// 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

Hissé mais non initialisé. Y accéder avant la déclaration provoque une ReferenceError.

---

const

Hissé mais non initialisé. Doit être initialisé au moment de la déclaration. Exemple :

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. Similitudes entre let et 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).

Fonctionnalité let et const ête> Portée du bloc Les deux sont confinés au bloc dans lequel ils sont déclarés. Pas d'initialisation du levage Les deux sont hissés mais ne sont pas accessibles avant l'initialisation. Meilleures pratiques Préféré à var pour une portée prévisible. 6. Quand utiliser lequel ? Scénario Mot clé recommandé ête> Re-déclarez les variables ou utilisez la portée de la fonction var (à éviter généralement sauf si cela est nécessaire pour le code existant). Variables susceptibles de changer let (par exemple, compteurs, indicateurs, calculs intermédiaires). Variables qui ne devraient pas changer const (par exemple, paramètres de configuration, valeurs fixes).

---

7. Explication du levage

Qu'est-ce que le levage ?

Le levage est le comportement par défaut de JavaScript consistant à déplacer les déclarations vers le haut de leur portée pendant la phase de compilation.

• var : Hissé et initialisé à non défini.
• let / const : Hissé mais pas initialisé. Cela crée une zone morte temporelle (TDZ) depuis le début du bloc jusqu'à ce que la déclaration soit rencontrée.

---

Pourquoi le levage fonctionne de cette façon ?

1. Phase de compilation : JavaScript analyse d'abord le code pour créer un espace mémoire pour les déclarations de variables et de fonctions. A ce stade :

• Les variables var sont initialisées à undefined.
• Les variables let et const sont "histées" mais laissées non initialisées, d'où le TDZ.
• Les déclarations de fonctions sont entièrement levées.

1. Phase d'exécution : JavaScript commence à exécuter le code ligne par ligne. Les variables et les fonctions se voient attribuer des valeurs au cours de cette phase.

---

8. Résumé du levage

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.

Tapez Levage Accès avant déclaration ête> var Hissé et initialisé à non défini. Autorisé mais la valeur n'est pas définie. laisser Hissé mais pas initialisé. Provoque une ReferenceError. const Hissé mais pas initialisé. Provoque une ReferenceError.

Exemple :

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)

---

Conclusion

1. Utilisez const autant que possible pour les variables qui n'ont pas besoin d'être réaffectées.
2. Utilisez let pour les variables qui doivent être réaffectées dans la même portée.
3. Évitez var sauf si vous travaillez avec du code existant ou si vous exigez un comportement limité à la fonction.

---

Types de données JavaScript

JavaScript a différents types de données classés en types Primitifs et Non primitifs (référence). Voici une explication de chacun avec des exemples et des différences :

---

1. Types de données primitifs

Les types primitifs sont immuables, ce qui signifie que leurs valeurs ne peuvent pas être modifiées après leur création. Ils sont stockés directement en mémoire.

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.

Type de données Exemple Description ête> Chaîne "Bonjour le monde' Représente une séquence de caractères (texte). Inclus entre simple (''), double ("") ou guillemets (). Numéro 42, 3.14, NaN Représente à la fois des nombres entiers et des nombres à virgule flottante. Comprend NaN (Not-a-Number) et Infinity. BigInt 123n, 9007199254740991n Utilisé pour les nombres supérieurs à Number.MAX_SAFE_INTEGER (2^53 - 1). Ajoutez n pour créer un BigInt. Booléen vrai, faux Représente des valeurs logiques, utilisées dans des conditions pour représenter « oui/non » ou « on/off ». Non défini non défini Indique qu'une variable a été déclarée mais qu'aucune valeur ne lui a été attribuée. Nul nul Représente une absence intentionnelle de valeur. Souvent utilisé pour réinitialiser ou effacer une variable. Symbole Symbole('id') Représente un identifiant unique, principalement utilisé comme clés de propriété pour les objets afin d'éviter les collisions.

---

2. Types de données non primitifs (référence)

Les types non primitifs sont mutables et stockés par référence. Ils sont utilisés pour stocker des collections de données ou des entités plus complexes.

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. Principales différences entre les types primitifs et non primitifs

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. Cas particuliers

type d'opérateur

• typeof null : renvoie "objet" en raison d'un bug historique dans JavaScript, mais null n'est pas un objet.
• typeof NaN : renvoie « numéro », même si cela signifie « Pas-un-numéro ».
• typeof function : renvoie "function", qui est un sous-type d'objet.

Saisie dynamique

JavaScript permet aux variables de contenir des valeurs de différents types au moment de l'exécution :

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. Exemples pour chaque type de données

Types primitifs

// 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

Types non primitifs

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. Résumé du type de résultats

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"

Expression

---

Résultat ête> type de "bonjour" "chaîne" type de 42 "numéro" type de 123n "bigint" type de vrai "booléen" type de non défini "non défini" type de null "objet" type de symbole() "symbole" type de {} "objet" type de [] "objet" type de fonction(){} "fonction"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!