Was ist neu in Node.js 15?

Wir teilen die Übersetzung des Artikels, der Details zu den neuen Funktionen der 15. Version von Node.js enthält.

Node.js Version 15 wurde am 20. Oktober 2020 veröffentlicht. Wichtige Änderungen sind:

• Wurfmodus bei unbehandelten Abweichungen
• Sprachfunktionen V8 8.6
• NPM 7
• experimentelle QUIC-Unterstützung
• N-API Version 7
• Finalisierung der Async Local Storage API

Schauen wir uns genauer an, was diese Innovationen sind und wie sie eingesetzt werden können.

Verwenden von NVM für die Knotenübersicht

Im vorherigen Artikel haben wir die Anweisungen zur Verwendung von NVM (Node Version Manager) zum Verwalten von Versionen von Node.js und NPM durchgesehen. Wir haben Node.js 12.16.0 und NPM 6.14.8 in unserer Umgebung installiert. Durch Ausführen von nvm install node haben wir Node.js 15.4.0 und NPM7.0.15 installiert.



Wir haben zwei Fenster geöffnet, eines mit Node.js 12 und das andere mit Node.js 15.



Im Fenster node12 :

$ nvm use 12
Now using node v12.16.0 (npm v6.14.8)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Im Node15- Fenster :

$ nvm use 15
Now using node v15.4.0 (npm v7.0.15)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Wir können diese Version jetzt untersuchen.

Wurfmodus bei unbehandelter Ablehnung von Versprechungen

Das unhandledRejection- Ereignis wird jedes Mal ausgelöst, wenn ein Versprechen abgelehnt wird und während der Ereignisschleife kein Fehlerbehandler an das Versprechen angehängt wird. Ab Node.js 15 wurde der Standardmodus für unhandledRejection von warn in throw geändert . Wenn im Throw- Modus der Hook " unhandledRejection" nicht gesetzt ist, wird " unhandledRejection" als Ausnahme ausgelöst, die von der catch- Methode nicht abgefangen wird .



Erstellen Sie ein Programm, um das Versprechen mit einer Fehlermeldung abzulehnen:

function myPromise() {
  new Promise((_, reject) =>
    setTimeout(
      () =>
        reject({
          error: 'The call is rejected with an error',
        }),
      1000
    )
  ).then((data) => console.log(data.data));
}

myPromise();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Wenn Sie diesen Code in einem Node12- Fenster ausführen , wird eine lange Warnmeldung angezeigt:

$ node myPromise.js
(node:79104) UnhandledPromiseRejectionWarning: #<Object>
(node:79104) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag `--unhandled-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (rejection id: 1)
(node:79104) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.Users that have an unhandledRejection hook should see no change in behavior, and it’s still possible to switch modes using the --unhandled-rejections=mode process flag.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Das Ausführen dieses Codes im Fenster node15 generiert einen UnhandledPromiseRejection- Fehler :

$ node myPromise.js
node:internal/process/promises:227
          triggerUncaughtException(err, true /* fromPromise */);
          ^[UnhandledPromiseRejection: This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "#<Object>".] {
  code: 'ERR_UNHANDLED_REJECTION'
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Fügen Sie dem then- Zweig im folgenden Code einen Fehlerbehandler hinzu ( .catch (( error ) => console.log ( error .error)) funktioniert ebenfalls).

function myPromise() {
  new Promise((_, reject) =>
    setTimeout(
      () =>
        reject({
          error: 'The call is rejected with an error',
        }),
      1000
    )
  ).then(
    (data) => console.log(data.data),
    (error) => console.log(error.error)
  );
}

myPromise();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Jetzt läuft der Code in beiden Fenstern ( Knoten 12 und Knoten 15 ) korrekt :

$ node myPromise.js
The call is rejected with an error
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Es wird empfohlen, einen Fehlerbehandler für Versprechen zu schreiben. Es kann jedoch Fälle geben, in denen Fehler nicht von der catch-Methode erfasst werden. Es wird empfohlen, den unhandledRejection-Hook einzurichten, um mögliche Fehler zu erkennen.

function myPromise() {
  new Promise((_, reject) =>
    setTimeout(
      () =>
        reject({
          error: 'The call is rejected with an error',
        }),
      1000
    )
  ).then((data) => console.log(data.data));
}

myPromise();

process.on('unhandledRejection', (reason, promise) => {
  console.log('reason is', reason);
  console.log('promise is', promise);
  // Application specific logging, throwing an error, or other logic here
});
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Der unhandledRejection-Hook funktioniert sowohl in Node.js 12 als auch in Node.js 15. Nach der Installation wird die unhandledRejection nach Bedarf behandelt.

$ node myPromise.js
reason is { error: 'The call is rejected with an error' }
promise is Promise { <rejected> { error: 'The call is rejected with an error' } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

V8 8.6 Neue Sprachfunktionen

V8, JavaScript-Engine, aktualisiert von 8.4 auf 8.6. Ausführung. Neben verschiedenen Verbesserungen zur Leistungssteigerung bietet der neue V8 folgende Funktionen:

• Promise.any () und AggregateError (ab V8 8.5)
• warte auf setTimeout und AbortController (experimentell)
• String.prototype.replaceAll () (ab V8 8.5)
• Logische Zuweisungsoperatoren && = , || = und ?? = (ab V8 8.5)

Promise.any () und AggregateError

Schauen wir uns zunächst die vorhandene Promise.all () -Methode an .



Promise.all () nimmt eine Iteration von Versprechungen als Eingabe und gibt ein einzelnes Versprechen zurück, das als Array der Ergebnisse der Eingabeversprechen ausgeführt wird.



Das folgende Programm ruft Promise.all () für zwei aufgelöste Versprechen auf:

function myPromise(delay) {
  return new Promise((resolve) =>
    setTimeout(
      () =>
        resolve({
          data: The data from ${delay} ms delay,
        }),
      delay
    )
  );
}

async function getData() {
  try {
    const data = await Promise.all([myPromise(5000), myPromise(100)]);
    console.log(data);
  } catch (error) {
    console.log(error);
  }
}

getData();

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Promise.all () gibt ein Versprechen zurück, das erfüllt wird, wenn alle Eingabeversprechen aufgelöst wurden oder wenn das iterable keine Versprechen enthält:

$ node myPromise.js
[
  { data: 'The data from 5000 ms delay' },
  { data: 'The data from 100 ms delay' }
]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Das folgende Programm ruft Promise.all () für zwei abgelehnte Versprechen auf.

function myPromise(delay) {
  return new Promise((_, reject) =>
    setTimeout(
      () =>
        reject({
          error: The error from ${delay} ms delay,
        }),
      delay
    )
  );
}

async function getData() {
  try {
    const data = await Promise.all([myPromise(5000), myPromise(100)]);
    console.log(data);
  } catch (error) {
    console.log(error);
  }
}

getData();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Promise.all () lehnt jede Ablehnung des Eingabeversprechens oder jeden Fehler zum Zeitpunkt der Ausführung sofort ab und gibt eine Nachricht zu diesem Fehler zurück:

$ node myPromise.js
{ error: 'The error from 100 ms delay' }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Promise.any () ist eine neue Methode in Node.js 15. Sie ist das Gegenteil von Promise.all () . Promise.any () akzeptiert eine Iterable, die Promise-Objekte enthält. Und sobald eines der Versprechen in der Iterable erfolgreich ist, gibt die Methode ein einzelnes Versprechen mit dem Wert des erfüllten Versprechens zurück.



Das folgende Programm ruft Promise.any () für zwei gelöste Versprechen auf:

function myPromise(delay) {
  return new Promise((resolve) =>
    setTimeout(
      () =>
        resolve({
          data: The error from ${delay} ms delay,
        }),
      delay
    )
  );
}

async function getData() {
  try {
    const data = await Promise.any([myPromise(5000), myPromise(100)]);
    console.log(data);
  } catch (error) {
    console.log(error);
    console.log(error.errors);
  }
}

getData();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Promise.any () gibt das erste aufgelöste Versprechen zurück:

$ node myPromise.js
{ data: 'The error from 100 ms delay' }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Das folgende Programm ruft Promise.any () für zwei abgelehnte Versprechen auf:

function myPromise(delay) {
  return new Promise((_, reject) =>
    setTimeout(
      () =>
        reject({
          error: The error from ${delay} ms delay,
        }),
      delay
    )
  );
}

async function getData() {
  try {
    const data = await Promise.any([myPromise(5000), myPromise(100)]);
    console.log(data);
  } catch (error) {
    console.log(error);
    console.log(error.errors);
  }
}

getData();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Wenn die Versprechen in der iterierbaren fehlschlagen, d.h. Alle gegebenen Versprechen werden abgelehnt. Das zurückgegebene Versprechen wird mit AggregateError abgelehnt , einer neuen Unterklasse von Error , die einzelne Fehler zusammenfasst.

$ node myPromise.js
[AggregateError: All promises were rejected]
[
  { error: 'The error from 5000 ms delay' },
  { error: 'The error from 100 ms delay' }
]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Warten Sie auf setTimeout und AbortController

In den vorherigen Beispielen haben wir setTimeout in einem Versprechensaufruf verwendet.



SetTimeout in WindowOrWorkerGlobalScope verwendet einen Rückruf. Allerdings Timer / Versprechen bieten eine promisified Version von setTimeout , die mit Asynchron / await verwendet werden kann.

const { setTimeout } = require('timers/promises');

async function myPromise(delay) {
  await setTimeout(delay);
  return new Promise((resolve) => {
    resolve({
      data: The data from ${delay} ms delay,
    });
  });
}

async function getData() {
  try {
    const data = await Promise.any([myPromise(5000), myPromise(100)]);
    console.log(data);
  } catch (error) {
    console.log(error);
    console.log(error.errors);
  }
}

getData();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

AbortController ist ein JavaScript-Objekt, mit dem Sie eine oder mehrere Webanforderungen nach Belieben abbrechen können. In einem anderen Artikel zu useAsync haben wir Beispiele für die Verwendung des AbortControllers bereitgestellt .



Beide warten auf setTimeout und AbortController sind experimentelle Funktionen.

String.prototype.replaceAll ()

Werfen wir einen Blick auf die vorhandene String.prototype.replace () -Methode .



replace () gibt eine neue Zeichenfolge zurück, wobei einige oder alle Musterübereinstimmungen durch den Ersetzer ersetzt wurden. Das Muster kann eine Zeichenfolge oder ein regulärer Ausdruck sein. Der Platzhalter kann eine Zeichenfolge oder eine Funktion sein, die für jede Übereinstimmung aufgerufen wird.



Wenn das Muster eine Zeichenfolge ist, wird nur das erste Vorkommen ersetzt.

'20+1+2+3'.replace('+', '-');
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Wenn Sie diesen Operator verwenden, erhalten Sie „20–1 + 2 + 3“ .



Um alle "+" durch "-" zu ersetzen, müssen Sie einen regulären Ausdruck verwenden.

'20+1+2+3'.replace(/\+/g, '-');
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Wenn Sie den obigen Operator verwenden, erhalten Sie "20-1-2-3" .



Die Methode replaceAll () ist neu in Node.js 15. Wenn Sie sie verwenden, müssen Sie keinen regulären Ausdruck verwenden. Diese Methode gibt eine neue Zeichenfolge zurück, bei der alle Musterübereinstimmungen durch den Platzhalter ersetzt werden. Das Muster kann eine Zeichenfolge oder ein regulärer Ausdruck sein, und der Platzhalter kann eine Zeichenfolge oder eine Funktion sein, die für jede Übereinstimmung aufgerufen wird.



Dank der replaceAll () -Methode müssen wir keinen regulären Ausdruck verwenden, um alle "+" durch "-" zu ersetzen.

'20+1+2+3'.replaceAll('+', '-');
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Die Ausführung dieses Operators ergibt "20-1-2-3" .

Logische Zuweisungsoperatoren && =, || = und ?? =

Der logische Zuweisungsoperator AND ( x && = y ) führt eine Zuweisungsoperation nur aus, wenn x wahr ist.



x && = y entspricht x && (x = y) , aber nicht x = x && y .

let x = 0;
let y = 1;

x &&= 0; // 0
x &&= 1; // 0
y &&= 1; // 1
y &&= 0; // 0
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Der logische Zuweisungsoperator OR (x || = y) führt eine Zuweisungsoperation nur aus, wenn x falsch ist.



x || = y entspricht x || (x = y), aber nicht äquivalent zu x = x || bei .

let x = 0;
let y = 1;

x ||= 0; // 0
x ||= 1; // 1
y ||= 1; // 1
y ||= 0; // 1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Der logische Zuweisungsoperator nullish (x ?? = y) führt eine Zuweisungsoperation nur aus, wenn x NULL ist ( null oder undefiniert ).



x ?? = y entspricht x ?? (x = y) und nicht äquivalent zu x = x ?? bei .

let x = undefined;
let y = '';

x ??= null; // null
x ??= 'a value'; // "a value"
y ??= undefined; // ""
y ??= null; // ""
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Andere Änderungen

Neben dem Wurf - Modus auf unhandled Versprechen Ablehnung und neue V8 8.6 Sprachfeatures, 15 Node.js hat die folgenden Änderungen:



NPM 7 : Viele Änderungen, einschließlich der automatischen Installation von Peer - Abhängigkeiten, die Verbesserung der Pakete und yarn.lock Dateien, Arbeitsplatz Unterstützung usw. All dies wird in diesem Artikel durch Bezugnahme beschrieben .



QUIC : Experimentelle Unterstützung für die UDP-Transportschicht, die das primäre Protokoll für HTTP / 3 darstellt. QUIC umfasst eingebettete Sicherheit mit TLS 1.3, Flusskontrolle, Fehlerkorrektur, Verbindungsmigration und Multiplexing.



N-API Version 7: API zum Erstellen benutzerdefinierter Addons. Es ist unabhängig von der zugrunde liegenden JavaScript-Laufzeit und wird als Teil von Node.js unterstützt.



Async Local Storage API-Erweiterung : Bietet die Möglichkeit einer moderneren Protokollierung und Funktionsanalyse für große Anwendungen.

Fazit

Die neue Version von Node.js 15 bietet eine Vielzahl neuer Funktionen und Verbesserungen, darunter auch bedeutende.



Probieren Sie die neue Version aus und machen Sie sich bereit, Projekte zu aktualisieren.



Vielen Dank für Ihre Aufmerksamkeit! Ich hoffe, der Artikel hat Ihnen geholfen.