Unglaubliche neue Funktionen in JavaScript ES(4)

Die neueste ECMAScript-Version, ES15, führt einige neue Funktionen ein, um Javascript-Entwicklern ein großartiges Entwicklererlebnis zu bieten. Diese Verbesserungen erstrecken sich über verschiedene Bereiche, von der aktualisierten Javascript-Syntax und Datenverarbeitung bis hin zu Verbesserungen bei Sicherheit, Leistung und Tools, die auf die Entwicklerproduktivität ausgerichtet sind.

1. Array-Gruppierung

Eine der aufregendsten (auch eine meiner persönlichen Lieblingsfunktionen) in ES15 ist die Object.groupBy()-Methode.
Auf diese Weise wird die Gruppierung von Elementen in einem Array anhand bestimmter Kriterien vereinfacht. Dadurch wird die Datenmanipulation effizienter und weniger fehleranfällig.

Beispiel:

const cities = [
  { name: 'Melbourne', country: 'Australia' },  
  { name: 'Auckland', country: 'New Zealand' },
  { name: 'Sydney', country: 'Australia' },
  { name: 'Brisbane', country: 'Australia' },
  { name: 'Wellington', country: 'New Zealand' }
];

const groupedByCountry = Object.groupBy(cities, fruit => fruit.country);
console.log(groupedByCountry);

// Output:
// {
//   "Australia": [
//       { "name": "Melbourne", "country": "Australia" },
//       { "name": "Sydney", "country": "Australia" },
//       { "name": "Brisbane", "country": "Australia" }
//   ],
//   "New Zealand": [
//       { "name": "Auckland", "country": "New Zealand" },
//       { "name": "Wellington", "country": "New Zealand" }
//   ]
// }

Durch die Verwendung dieser Funktion können wir den Bedarf an benutzerdefinierten Funktionen oder Bibliotheken von Drittanbietern reduzieren, die wir traditionell für die Array-Gruppierung verwenden.

Außerdem können wir mit dieser Funktion unseren Code verständlicher und wartbarer machen, indem wir unsere Absicht direkt zum Ausdruck bringen

2. Pipeline-Betreiber (|>)

Manchmal müssen wir mehrere Funktionen als Verkettungsprozess verwenden. In einem solchen Szenario können wir den Pipeline-Operator (|>) verwenden, um den Verkettungsprozess zu vereinfachen.

Beispiel:

const double = (x) => x * 2;
const increment = (x) => x + 1;
const square = (x) => x * x;

const result = 5 |> double |> increment |> square;

// Output: 121

Die oben beschriebene traditionelle Vorgehensweise ist diese

const double = (x) => x * 2;
const increment = (x) => x + 1;
const square = (x) => x * x;

const result = square(increment(double(5)));
console.log(result);

// Output: 121

Durch die Verwendung des Pipeline-Operators können wir einen funktionaleren Programmierstil verwenden. Dadurch können wir unseren Code lesbarer machen, indem wir die Komplexität tief verschachtelter Funktionsaufrufe beseitigen.

3. Methodenverkettungsoperator (?.())

ES15 erweitert die optionale Verkettung durch die Einführung des neuen Methodenverkettungsoperators. Dieser Methodenverkettungsoperator erhöht die Sicherheit beim Methodenaufruf in tief verschachtelten Objekten.

Beispiel:

const data = {
  user: {
    getName: () => 'Tim'
  }
};

console.log(data.user?.getName?.());  // Output: 'Alice'
console.log(data.user?.getAge?.());  // Output: undefined

Mit dem Methodenverkettungsoperator (?.()) können Sie Methoden für potenziell null oder undefinierte Objekte sicher aufrufen. Dies verringert das Risiko von Laufzeitfehlern, die durch aufrufende Methoden verursacht werden.

4. Methodenerweiterungen festlegen

ES15 führt mehrere Verbesserungen am Set-Objekt ein, darunter neue Methoden wie union, intersection, difference und symmetricDifference. Diese Methoden vereinfachen gängige Mengenoperationen.

const setA = new Set([1, 2, 3]);
const setB = new Set([3, 4, 5]);

const unionSet = setA.union(setB);
const differenceSet = setA.difference(setB);
const intersectionSet = setA.intersection(setB);
const symmetricDifferenceSet = setA.symmetricDifference(setB);

console.log(unionSet); // Output: {1, 2, 3, 4, 5}
console.log(differenceSet); // Output: {1, 2}
console.log(intersectionSet); // Output: {3}
console.log(symmetricDifferenceSet); // Output: {1, 2, 4, 5}

• Gewerkschaft
  Die Methode union() von Set-Instanzen nimmt eine Menge und gibt eine neue Menge zurück, die Elemente enthält, die sich in einer oder beiden dieser Menge und der angegebenen Menge befinden.

• Unterschied
  Die Methode „different()“ von Set-Instanzen nimmt eine Menge und gibt eine neue Menge zurück, die Elemente in dieser Menge, aber nicht in der gegebenen Menge enthält.

• Kreuzung
  Die Methode „Intersection()“ von Set-Instanzen nimmt eine Menge und gibt eine neue Menge zurück, die Elemente sowohl in dieser Menge als auch in der gegebenen Menge enthält.

• symmetricDifference
  Die symmetricDifference()-Methode von Set-Instanzen nimmt eine Menge und gibt eine neue Menge zurück, die Elemente enthält, die entweder in dieser Menge oder der angegebenen Menge, aber nicht in beiden enthalten sind.

5. Erweiterte JSON-Module

In früheren ECMAScript-Versionen verließen sich Entwickler auf Bundler oder Loader, um JSON-Dateien zu importieren. ES15 unterstützt jetzt den dynamischen Import und die Schemavalidierung, was die Arbeit mit strukturierten Daten erleichtert und sicherstellt, dass importierte Daten dem erwarteten Format entsprechen.

Sie können jetzt JSON-Daten direkt importieren, genau wie beim Importieren von JavaScript-Modulen.

Beispiel:

const cities = [
  { name: 'Melbourne', country: 'Australia' },  
  { name: 'Auckland', country: 'New Zealand' },
  { name: 'Sydney', country: 'Australia' },
  { name: 'Brisbane', country: 'Australia' },
  { name: 'Wellington', country: 'New Zealand' }
];

const groupedByCountry = Object.groupBy(cities, fruit => fruit.country);
console.log(groupedByCountry);

// Output:
// {
//   "Australia": [
//       { "name": "Melbourne", "country": "Australia" },
//       { "name": "Sydney", "country": "Australia" },
//       { "name": "Brisbane", "country": "Australia" }
//   ],
//   "New Zealand": [
//       { "name": "Auckland", "country": "New Zealand" },
//       { "name": "Wellington", "country": "New Zealand" }
//   ]
// }

const double = (x) => x * 2;
const increment = (x) => x + 1;
const square = (x) => x * x;

const result = 5 |> double |> increment |> square;

// Output: 121

Diese Änderung könnte jedoch Code beschädigen, der auf älteren, nicht standardmäßigen Methoden zum Importieren von JSON basiert, oder wenn bestimmte Build-Tools mit älteren Verhaltensweisen konfiguriert sind.

Das obige ist der detaillierte Inhalt vonUnglaubliche neue Funktionen in JavaScript ES(4). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!