Neuer Inhalt: 1. Die Schlüsselwörter let und const werden verwendet, um Variablen zu deklarieren, den Gültigkeitsbereich auf Blockebene zu unterstützen und temporäre Totzonen zu haben. 2. Die Destrukturierungszuweisung besteht darin, einen Mustervergleich für Arrays oder Objekte durchzuführen und dann die darin enthaltenen Variablen abzugleichen Die Bedeutung der Zuweisung; 3. Expand-Operator, der zum Erweitern von Elementen in Mengen und Arrays in einzelne Elemente verwendet werden kann. 4. Set-Objekt, eine neue Datenstruktur, ähnlich einem Array, aber die Werte der Mitglieder sind eindeutig , es gibt keine doppelten Werte; 5. Konstruktormethoden Array.from(), Array.of().
Die Betriebsumgebung dieses Tutorials: Windows 7-System, ECMAScript Version 6, Dell G3-Computer.
let und const unterstützen den Bereich auf Blockebene und haben eine temporäre Totzone (muss zuerst deklariert und dann verwendet werden, Variablenförderung wird nicht unterstützt) ;
const ist eine Konstante, der bei der Deklaration ein Wert zugewiesen werden muss. Wenn es sich bei der Zuweisung um einen Referenztyp handelt, kann der Wert nicht geändert werden B. Push auf das Array, Hinzufügen, Löschen und Ändern von Objektattributen
es6 ermöglicht das Extrahieren von Werten aus Arrays oder Objekten nach einem bestimmten Muster und das Zuweisen von Werten in Variablen, was als destrukturierende Zuweisung bezeichnet wird.
Die Destrukturierungszuweisung ist beim Schreiben von Code einfach und leicht zu verstehen und verfügt über eine klare Semantik, sodass Datenfelder in komplexen Objekten bequem abgerufen werden können.
Zuweisung zur Objektdestrukturierung:
let obj = {
a: 1,
b: 2
};
let {a, b, c} = obj; // 大括号中的变量名必须和obj的属性名一致
console.log(a, b, c);
// 输出:
// a: 1
// b: 2
// c: undefinedArray-Destrukturierungszuweisung: (wie String)
let arr = ['a', 'b', 'c']; let [e, f] = arr; // 中括号中的变量按数组中元素的顺序被赋值 console.log(e, f); // 输出： // e: 'a' // f: 'b' // 快速交换两个变量值 let a = 1, b = 2; [a, b] = [b, a];
Dargestellt durch drei Punkte (...), JavaScript-Erweiterungsoperatoren wurden in eingeführt ES6. Es kann verwendet werden, um Elemente in Sammlungen und Arrays in einzelne Einzelelemente zu erweitern.
Der Spread-Operator kann zum Erstellen und Klonen von Arrays und Objekten, zum Übergeben von Arrays als Funktionsargumente, zum Entfernen von Duplikaten aus Arrays und mehr verwendet werden.
Der Spread-Operator kann nur für iterierbare Objekte verwendet werden. Es muss ohne Trennung vor dem iterierbaren Objekt verwendet werden. Zum Beispiel:
console.log(...arr);
Array:
let arr1 = [1, 2, 3, 4]; let arr2 = ['a', 'b', ...arr1, 'c']; console.log(arr2); // 输出： // ['a', 'b', 1, 2, 3, 4, 'c']
Objekt:
let obj1 = {
a: 1,
b: 2
};
let obj2 = {
...obj1,
c: 3,
d: 4
};
console.log(obj2);
// 输出：
// {a: 1, b: 2, c: 3, d: 4}Verbleibende Parameterbehandlung:
Array:
let arr = [1, 2, 3, 4, 5]; let [a, b, ...c] = arr; // 将arr后面所有的剩余参数放入c中 console.log(a, b, c); // 输出： // a: 1 // b: 2 // c: [3, 4, 5]
Objekt:
let obj = {
a: 1,
b: 2,
c: 3,
d: 4
};
let {a, b, ...c} = obj;
console.log(a, b, c);
// 输出：
// a: 1
// b: 2
// c: {c: 3, d: 4}
// 对象的复制（不是传地址）
let obj2 = {...obj};Set wird bereitgestellt von ES6 Eine neue Datenstruktur, ähnlich einem Array, aber die Werte der Mitglieder sind eindeutig und es gibt keine doppelten Werte.
Set selbst ist ein Konstruktor, der zum Generieren einer Set-Datenstruktur verwendet wird.
Mit Set-Objekten können Sie eindeutige Werte jeglicher Art speichern, unabhängig davon, ob es sich um Grundwerte oder Objektreferenzen handelt.
Die Elemente im Set erscheinen nur einmal, das heißt, die Elemente im Set sind einzigartig.
Darüber hinaus können sowohl NaN als auch undefiniert in Set gespeichert werden, und NaN wird als der gleiche Wert behandelt (auch wenn NaN !== NaN).
Set-Funktion kann ein Array (oder eine andere Datenstruktur mit iterierbarer Schnittstelle) als Parameter für die Initialisierung akzeptieren.
Array-Deduplizierung:
let arr = [2, 1, 2, 1, 3, 4, 4, 5]; let s = new Set(arr); arr = [...s]; // arr: [2, 1, 3, 4, 5]
Set-Methode:
let s = new Set([1, 1, 2, 3, 'a']); // 得到Set元素个数： s.size; // 清空集合 s.clear(); // 删除集合中的某个值，返回操作是否成功 s.delete('a'); // 查看集合是否包含某个值 s.has('a'); // 添加一项，返回集合本身的引用 s.add('b');
ES6 stellt die Kartendatenstruktur bereit. Es ähnelt einem Objekt und ist ebenfalls eine Sammlung von Schlüssel-Wert-Paaren, der Umfang von „Schlüssel“ ist jedoch nicht auf Zeichenfolgen beschränkt. Als Schlüssel können verschiedene Arten von Werten (einschließlich Objekten) verwendet werden. Mit anderen Worten: Die Objektstruktur bietet eine „String-Wert“-Korrespondenz und die Map-Struktur eine „Wert-Wert“-Korrespondenz, was eine vollständigere Implementierung der Hash-Struktur darstellt. Wenn Sie eine „Schlüssel-Wert“-Datenstruktur benötigen, ist Map besser geeignet als Object.
Map-Funktionen:
Map-Objekte speichern Schlüssel-Wert-Paare und können sich die ursprüngliche Einfügereihenfolge von Schlüsseln merken.
Jeder Wert (Objekt oder Grundelement) kann als Schlüssel oder Wert verwendet werden.
let arr = [
['a', 1],
['b', 2],
['c', 3]
];
let m = new Map(arr);
// m: {'a' => 1, 'b' => 2, 'c' => 3}Kartenmethode:
// 清空Map m.clear(); // 删除某一项，返回操作是否成功 m.delete(key); // 获取某一项的值，返回对应的val m.get(key); // 是否包含某一项 m.has(key); // 添加一项，返回Map本身的引用 m.set(key, val);
Pfeilfunktion: keine this und argumentsthis和arguments
参数默认值
把一个类数组转换成真正的数组：Array.from(arrLike [, mapFunc, mapThis]);
参数：
arrLike:类数组mapFunc:对类数组每一项的操作函数mapThis:替换mapFunc的this指向另一种方法：let arr = [...arrLike];
将参数列表转换为数组：
Array.of(...items);
Array.from(arrLike [, mapFunc, mapThis]);🎜🎜Parameter: 🎜arrLike:< /code>Array- wie 🎜🎜<code>mapFunc:Die Operationsfunktion für jedes Element des Array-ähnlichen 🎜🎜mapThis:Ersetzt mapFuncs this < /code>Zeigen Sie auf 🎜🎜🎜Eine andere Möglichkeit: <code>let arr = [...arrLike];🎜🎜🎜🎜Konvertieren Sie die Argumentliste in ein Array: 🎜🎜Array.of( . ..items);🎜检测一个对象是否是一个数组：
Array.isArray(obj);
arr.find(callback [, thisArg])：查找数组中满足条件的第一个元素的值
let arr = [1, 2, 3, 4]; let val = arr.find((item, index) => item >= 3); // val: 3 let val = arr.find((item, index) => item >= 5); // val: undefined
arr.findIndex(callback [, thisArg])：查找数组中满足条件的第一个元素的索引
数组扁平化：
arr.flat([depth])
参数：depth：指定要提取嵌套数组的结构深度，默认为1，当depth = infinity时，无论数组多少层，都提取为一维数组。
arr.flatMap(callback[, thisArg])
参数：callback：对原数组的每个元素进行操作，返回新数组的元素；
该函数值支持深度为1的扁平化
数组元素填充：arr.fill(value[, start[, end]]);
用一个固定的值填充一个数组中从起始索引到终止索引内到全部元素。不包括终止索引；不会改变数组长度
参数：
arr.includes(valueToFind[, fromIndex])：判断数组中是否包含一个指定的值
参数：
str.startsWith(searchString[, position])：判断当前字符串是否以另一个给定的子字符串开头
参数：
str.endsWith(searchString[, position])：判断当前字符串是否以另一个给定的子字符串结束
参数：
str.repeat(times)：返回重复str字符串times次的字符串
反引号：``，可以换行
插值表达式：${}
简洁表示法：
let a = 1, b = 2;
// 原来的表示方法：
let obj = {
a: a,
b: b,
c: function() {}
};
// 简洁表示法：
let obj = {
a,
b,
c() {}
};属性名表达式：
let name = "小明";
let obj = {
[name]: 111
};
console.log(obj);
// 输出：
// obj: {'小明': 111}
// 等价于：
let obj = {};
obj[name] = 111;Object.assign(obj1, obj2, ...)：将第二个参数即之后的参数对象合并到第一个参数对象中
let obj1 = {a: 1, b: 2};
let obj2 = {c: 3, d: 4};
Object.assign(obj2, obj1);
// 等价于
obj2 = {
...obj1,
...obj2
}
// 等价于
obj2 = Object.assign({}, obj1, obj2);Object.is(value1, value2)：判断两个值是否相等（强类型）
和===的区别：
+0 === -0; // true Object.is(+0, -0); // false NaN === NaN; // false Object.is(NaN, NaN); // true
将es6语法编译为es5语法
【相关推荐：javascript视频教程、编程视频】
Das obige ist der detaillierte Inhalt vonWas ist neu in es6 im Vergleich zu es5?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
