1. La différence entre let, const et var
Il existe une promotion de variable pour les variables déclarées avec var, mais il n'y a pas de promotion de variable pour let et const.
let et const sont toutes deux des variables locales au niveau du bloc et ont des zones mortes temporaires.
Les caractéristiques de const sont exactement les mêmes que celles de let. La seule différence est que const doit se voir attribuer une valeur lors de sa déclaration. Lors de l'attribution d'un type de base, il ne peut être attribué qu'une seule fois, c'est-à-dire qu'il ne peut pas être modifié après la déclaration. Lors de l'attribution d'un type de référence, l'adresse mémoire ne peut pas être modifiée.
Let et const ne peuvent pas déclarer des variables portant le même nom dans la même portée, mais var peut
2. La différence entre les fonctions fléchées et les fonctions ordinaires
2.1. Le this d'une fonction flèche est déterminé lors de sa définition, alors que pour les fonctions ordinaires, il dépend de la méthode appelante.
2.2. Les fonctions fléchées ne peuvent pas devenir des constructeurs.
2.3. Les fonctions fléchées ne peuvent pas utiliser async/await
2.4. La fonction flèche ne peut pas utiliser la fonction Générateur et le mot-clé rendement ne peut pas être utilisé.
2.5. Les fonctions fléchées ne peuvent pas utiliser call, apply ou bind pour modifier ce pointeur.
2.6. Les fonctions fléchées ne lient pas les arguments.
2.7. Les fonctions fléchées n'ont pas d'objets prototypes et n'ont pas de super.
3. Principe de mise en œuvre et encapsulation de la promesse
Il existe trois états de promesse, à savoir l’état initial en attente, l’état réussi résolu et l’état échoué rejeté. Passez deux paramètres, l'un est solve, la méthode à exécuter puis, et l'autre est rejet, la méthode pour exécuter catch ou le rappel du deuxième paramètre de then. Une fois que l’état d’une promesse change, elle ne peut plus être modifiée. Les appels de chaîne de promesse renvoient en fait une nouvelle promesse au lieu de la renvoyer.
//Version simple de
la fonction de promesse Promise(executor){ //exécuteur exécuteur
let self = this;
self.status = 'en attente'; //état d'attente
self.value = non défini; //valeur indiquant le succès actuel
self.reason = non défini ; // Indique une
fonction de valeur échouée solve(value){ // Méthode réussie
if(self.status === 'ending'){
self.status = 'resolved';
self.value = value;
}
}
function rejeter(raison ){ //Échec de la méthode
if(self.status === 'ending'){
self.status = 'rejected';
self.reason = Reason;
}
}
executor(resolve,reject);
}
Promise.prototype.then = function(onFufiled,onRejected){
let self = this ;
if(self.status === 'résolu'){
onFufiled(self.value);
}
if(self.status === 'rejected'){
onRejected(self.reason);
}
}
4. La différence entre forEach, for in et for of
forEach est plus utilisé pour parcourir des tableaux. for in est généralement utilisé pour parcourir des objets ou du json. Vous pouvez parcourir le prototype de l'objet. for of est utilisé pour parcourir des objets de tableau et des objets énumérables. Il ne peut pas traverser le prototype. for in boucle vers l'extérieur la clé, car ce qui est bouclé est la valeur
5. Que sont respectivement l'ensemble et la carte ?
set object : permet de stocker une valeur unique de n'importe quel type, qu'il s'agisse d'une valeur primitive ou d'une référence d'objet. Set est une collection de valeurs et la valeur ne peut pas être obtenue via la méthode get, car set n'a que des valeurs. Vous pouvez effectuer une traversée à travers les itérateurs. La valeur de Set est la seule qui peut être utilisée pour la déduplication de la baie.
var set = new Set(['1',undéfini,{},2,[3,4]]);
set.size; // 5
set.add(5);
set.delete('1'); // vrai
set.has('2'); // faux
set.keys(); // SetIterator
set.values(); // SetIterator
set.entries(); // SetIterator
// set对象可遍历
set.forEach();
Objet cartographique : l'objet cartographique stocke les paires clé-valeur. N'importe quelle valeur (objet ou primitive) peut être utilisée comme clé ou valeur.
var myMap = new Map();
var keyObj = {};
myMap.set(keyObj, "La valeur associée à la clé keyObj");
myMap.get(keyObj); // "La valeur associée à la clé keyObj"
myMap .size // 1
myMap.has(keyObj); // true
myMap.delete(keyObj); // true
myMap.clear();
myMap.keys(); // Objet composé de clés MapIterator
myMap.values(); // MapIterator est un objet composé de valeurs
myMap.entries(); // MapIterator est un objet composé de paires clé-valeur
// L'objet map peut être parcouru
myMap.forEach((value, key) => {
console .log(value, key)
})
for( var [key, value] of myMap){
console.log(key, value); // {}, "La valeur associée à la clé keyObj"
}
6. Compréhension des symboles
ES6 introduit un nouveau type de données primitif Symbol, qui représente une valeur unique. Sa plus grande utilisation est de définir le nom d'attribut unique d'un objet.
let sy = Symbol("KK");
console.log(sy); // Symbol(KK)
typeof(sy); // "symbol"
// Les valeurs renvoyées par les mêmes paramètres Symbol() ne sont pas égales
let sy1 = Symbol( "kk");
sy === sy1; // false
//
Méthode d'écriture 1
let syObject = {};
syObject[sy] = "kk";
console.log(syObject); // { Symbol(key1): " kk"}
// Méthode d'écriture 2
let syObject = {
[sy]: "kk"
};
console.log(syObject); // {Symbol(key1): "kk"}
// Méthode d'écriture 3
soit syObject = {} ;
Objet .defineProperty(syObject, sy, {value : "kk"});
console.log(syObject); // {Symbol(key1) : "kk"}
Lorsqu'une valeur Symbol est utilisée comme nom de propriété, la propriété est une propriété publique, et non une propriété privée, et est accessible en dehors de la classe. Mais il n'apparaîtra pas dans les boucles for...in, for...of, et il ne sera pas non plus renvoyé par Object.keys() et Object.getOwnPropertyNames(). Si vous souhaitez lire la propriété Symbol d'un objet, vous pouvez l'obtenir via Object.getOwnPropertySymbols() et Reflect.ownKeys().
for (laissez i dans syObject) {
console.log(i);
} //
FonctionneObject.keys(syObject); // []
Object.getOwnPropertySymbols(syObject); // [Symbole (clé1)]
Reflect.ownKeys (syObject); // [Symbole (clé1)]
7. Quelles nouvelles méthodes de tableau sont ajoutées ?
forEach : forEach() traversera le tableau, il n'y a pas de valeur de retour dans le corps de la boucle, la boucle forEach() ne changera pas le contenu du tableau d'origine, forEach() a trois paramètres, le premier paramètre est l'élément actuel, le deuxième paramètre est l'index de l'élément actuel, le troisième paramètre est le tableau auquel appartient l'élément actuel
map : La fonction principale de map() est en fait de créer un nouveau tableau
filter : filter() est principalement utilisé pour filtrer les éléments du tableau qui ne remplissent pas les conditions, et placer les éléments qui remplissent les conditions dans le nouveau tableau sans modifier le tableau d'origine.
each : Il parcourra le tableau et écrira les conditions dans le corps de la boucle. Si chaque élément est vrai, il retournera vrai. Tant qu'un élément est faux, il retournera faux.
some : Parcourez chaque élément du tableau, puis jugez en fonction des conditions du corps de la boucle.Tant que l'un d'entre eux est vrai, la boucle s'arrêtera.
réduire : reçoit une fonction comme accumulateur, chaque valeur du tableau (de gauche à droite) commence à être réduite, et devient finalement une valeur
Array.from() : utilisé pour transformer deux types d'objets en tableaux. Un type est un objet de type tableau et l’autre type est un objet traversable.
Array.of() : utilisé pour convertir un ensemble de valeurs en tableau
find() et findIndex() : utilisés pour rechercher le premier membre et indice éligible du tableau.
fill() : la méthode remplit un tableau avec les valeurs données
include() : Vérifiez si une certaine valeur est incluse
8. Quelles nouvelles méthodes de chaînes sont ajoutées ?
startWith() : Renvoie une valeur booléenne indiquant si la chaîne de paramètre est en tête de la chaîne d'origine
endWith() : Renvoie une valeur booléenne indiquant si la chaîne de paramètre est à la fin de la chaîne d'origine
include() : Renvoie une valeur booléenne indiquant si la chaîne de paramètre est trouvée
repeat() : Renvoie une nouvelle chaîne, ce qui signifie répéter la chaîne d'origine n fois
padStart() : remplissage de la position de départ
padEnd() : Remplissage de la position finale
trimStart() : supprime les espaces en tête de la chaîne
trimEnd() : supprime les espaces à la fin de la chaîne
matchAll() : Renvoie toutes les correspondances d'une expression régulière dans la chaîne actuelle
9. Quelles nouvelles méthodes objet sont ajoutées ?
Object.is() : Déterminer si deux valeurs sont égales
Object.assign() : Utilisé pour copier les valeurs de toutes les propriétés énumérables d'un ou plusieurs objets source vers l'objet cible. Il renverra l'objet cible.
Object.getOwnPropertyDescriptors() : Renvoie l'objet de description de toutes ses propres propriétés (propriétés non héritées) de l'objet spécifié
Object.setPrototypeOf(), Object.getPrototypeOf() : utilisé pour lire ou définir l'objet prototype de l'objet actuel
Object.keys() : utilisé pour renvoyer un tableau. Les paramètres des membres sont les noms de clés de toutes les propriétés traversables de l'objet lui-même.
Object.values() : La valeur de retour est un tableau dont les membres sont les valeurs de toutes les propriétés traversables de l'objet lui-même (à l'exclusion des propriétés héritées).
Object.entries() : Renvoie un tableau dont les membres sont des paires clé-valeur de toutes les propriétés traversables de l'objet lui-même (à l'exclusion des propriétés héritées). La valeur de la propriété Symbol sera filtrée.
Object.fromEntries() : C'est l'opération inverse de Object.entries, convertissant un tableau de paires clé-valeur en un objet.
10、async...attendez
async...await est le sucre syntaxique de la fonction Generator. Remplacez * par async et rendement pour wait. Il s'agit d'une amélioration de la fonction Générateur et renvoie une promesse. La méthode d'écriture asynchrone est synchronisée. Lorsqu'elle rencontre wait, elle revient en premier, puis exécute la suivante après une exécution asynchrone. Exécuteur intégré, pas besoin de next()