Die offizielle Version von Node.js 15 ist veröffentlicht und wird Node.js 14 als aktuelle stabile Version ersetzen.

Vor zwei Tagen hat Node.js offiziell die offizielle Version von Node.js 15 veröffentlicht. Node.js 15 wird Node.js 14 als aktuelle stabile Version ersetzen, die später in diesem Monat aktualisiert wird. Dies ist ein LTS ( Version mit Langzeitunterstützung. Wenn Sie die neuesten Funktionen von Node.js 15 erleben möchten, können Sie es von der offiziellen Website herunterladen.

Video-Tutorial-Empfehlung: nodejs-Tutorial

Welche neuen Funktionen und Features bringt Node.js 15? Dies spiegelt sich hauptsächlich in den folgenden Aspekten wider:

• AbortController
• N-API-Version 7
• npm 7
• unbehandelte Ablehnungen werden standardmäßig ausgelöst
• QUIC
• V8 8.6

AbortController

A Die bortController-Schnittstelle stellt einen Controller dar Objekt, das es Entwicklern ermöglicht, eine oder mehrere Webanfragen nach Bedarf abzubrechen, fügte Node.js 15 eine experimentelle Implementierung von AbortController hinzu. AbortController ist eine globale Dienstprogrammklasse, die ausgehende Anforderungssignale in ausgewählten Promise-basierten APIs gemäß der AbortController-Web-API abbricht, wie unten gezeigt.

const ac = new AbortController();
ac.signal.addEventListener('abort', () => console.log('Aborted!'),
{ once: true });
ac.abort();
console.log(ac.signal.aborted);    //Prints True

Im obigen Beispiel wird das Abort-Ereignis ausgegeben, wenn die Methode abortController.abort() aufgerufen wird, und der AbortController löst das Abort-Ereignis nur einmal aus. Außerdem sollten an AbortSignal angehängte Ereignis-Listener die Parameteroption { once: true} (oder gleichwertig Once() der EventEmitterAPI) verwenden, um sicherzustellen, dass der Ereignis-Listener entfernt wird, sobald das Abort-Ereignis behandelt wird.

Die Node.js-API-Dokumentation von AbortController finden Sie unter: AbortController.

N-API 7

N-API ist eine API zum Erstellen nativer Plugins unabhängig von der zugrunde liegenden JavaScript-Laufzeitumgebung (z. B. V8) und als Teil von Node.js selbst. Diese API dient als stabile Version des kompilierten Application Binary Interface (ABI) für alle Node.js-Versionen. Es wurde entwickelt, um Add-ons-Plugins von Änderungen an der zugrunde liegenden JavaScript-Engine zu isolieren und ermöglicht, dass in einer Version kompilierte Module auf einer späteren Version von Node.js ohne Neukompilierung ausgeführt werden können.

N-API ist eine C-Sprach-API, die die Stabilität der Anwendungsprogrammierschnittstelle (ABI) zwischen Node.js-Versionen und verschiedenen Compilerstufen gewährleistet. Die C++-API kann einfacher zu verwenden sein. Um die Verwendung von C++ zu unterstützen, verwendet Node.js ein C++-Wrapper-Modul namens node-addon-api, das eine inlinebare C++-API bereitstellt. Mit Node-Addon-API erstellte Binärdateien basieren auf der N-API-Schnittstelle, die auf von Node.js exportierten C-Funktionssymbolen basiert. Dies ist eine effizientere Möglichkeit, Code zum Schreiben von Aufrufen an N-API zu schreiben.

Informationen zur N-API von Node.js finden Sie unter: C/C++-Addons mit N-API

Das Folgende ist ein Beispiel für die Verwendung von Node-Addon-API.

Object obj = Object::New(env);
obj["foo"] = String::New(env, "bar");

napi_status status;
napi_value object, string;
status = napi_create_object(env, &object);
if (status != napi_ok) {
  napi_throw_error(env, ...);
  return;
}

status = napi_create_string_utf8(env, "bar", NAPI_AUTO_LENGTH, &string);
if (status != napi_ok) {
  napi_throw_error(env, ...);
  return;
}

status = napi_set_named_property(env, object, "foo", string);
if (status != napi_ok) {
  napi_throw_error(env, ...);
  return;
}

Diese aktualisierte N-API 7 ist die erste neue Version seit der vorherigen Hauptversion und bringt verwandte Inhalte zu ArrayBuffers.

npm 7

Node.js 15 wird mit der neuen Hauptversion von npm, npm 7, geliefert. npm 7 verfügt über viele neue Funktionen, darunter npm-Arbeitsbereiche und ein neues package-lock.json-Format. npm 7 bietet auch Unterstützung für die Datei „garn.lock“. Eine der großen Änderungen in npm 7 ist die Standardinstallation von Peer-Abhängigkeiten.

Unbehandelte Ablehnungen werden standardmäßig ausgelöst

Ab Node.js 15 wurde der Standardmodus von unhandledRejection in „werfen“ (früher „warn“) geändert. Wenn im Throw-Modus der unhandledRejection-Hook nicht gesetzt ist, wird unhandledRejection zu einer nicht abgefangenen Ausnahme ausgelöst. Benutzer mit einem unhandledRejection-Hook sollten keine Verhaltensänderung bemerken und können weiterhin das Prozessflag --unhandled-rejections=mode verwenden, um den Modus zu wechseln.

Viele frühere Versionen von Node.js gaben standardmäßig UnhandledPromiseRejectionWarning aus, und gemäß den Ergebnissen der Umfrage „Node.js User Insights: Unhandled Promise Rejections“ stimmte der TSC von Node.js zu, den Modus auf „Auswerfen“ umzustellen.

QUIC

QUIC ist ein von Google entwickeltes UDP-basiertes Internet-Transportschichtprotokoll mit geringer Latenz. Es ist das grundlegende Transportprotokoll von HTTP/3. Darüber hinaus hielt die International Internet Engineering Task Force (IETF) im November 2016 das erste Treffen der QUIC-Arbeitsgruppe ab, das große Aufmerksamkeit in der Branche erregte, was bedeutete, dass QUIC einen wichtigen Schritt auf dem Weg zu einem Transportschichtprotokoll der neuen Generation machte. QUIC verfügt mittlerweile über integrierte TLS 1.3-Sicherheit, Flusskontrolle, Fehlerkorrektur, Verbindungsmigration und Multiplexing.

Node.js 15 bietet experimentelle Unterstützung für QUIC, die durch Kompilieren von Node.js mit dem Konfigurationsflag --experimental-quic aktiviert werden kann. Das Core-Net-Modul stellt beispielsweise eine Node.js-QUIC-Implementierung mit dem folgenden Code bereit.

const { createQuicSocket } = require('net');

'use strict';

const key = getTLSKeySomehow();
const cert = getTLSCertSomehow();

const { createQuicSocket } = require('net');

// Create the QUIC UDP IPv4 socket bound to local IP port 1234
const socket = createQuicSocket({ endpoint: { port: 1234 } });

socket.on('session', async (session) => {
  // A new server side session has been created!

  // The peer opened a new stream!
  session.on('stream', (stream) => {
    // Let's say hello
    stream.end('Hello World');

    // Let's see what the peer has to say...
    stream.setEncoding('utf8');
    stream.on('data', console.log);
    stream.on('end', () => console.log('stream ended'));
  });

  const uni = await session.openStream({ halfOpen: true });
  uni.write('hi ');
  uni.end('from the server!');
});

// Tell the socket to operate as a server using the given
// key and certificate to secure new connections, using
// the fictional 'hello' application protocol.
(async function() {
  await socket.listen({ key, cert, alpn: 'hello' });
  console.log('The socket is listening for sessions!');
})();

Weitere Informationen zu QUIC finden Sie im folgenden Dokument: QUIC.

V8 8.6

Die V8-JavaScript-Engine wurde auf V8 8.6 aktualisiert (V8 8.4 ist die neueste Version in Node.js 14). Zusätzlich zu Leistungsoptimierungen und -verbesserungen bringt das V8-Update die folgenden Sprachfunktionen:

Promise.any()——MDN

Promise.any() 接收一个Promise可迭代对象，只要其中的一个 promise 成功，就返回那个已经成功的 promise 。如果可迭代对象中没有一个 promise 成功（即所有的 promises 都失败/拒绝），就返回一个失败的 promise 和AggregateError类型的实例，它是 Error 的一个子类，用于把单一的错误集合在一起。

Promise.any()的参考文档如下所示：Promise.any()

AggregateError——MDN

AggregateError主要用于操作报告多个错误被抛出的场景，语法格式如下：

new AggregateError(errors[, message])

捕获一个AggregateError的示例代码如下：

Promise.any([
  Promise.reject(new Error("some error")),
]).catch(e => {
  console.log(e instanceof AggregateError); // true
  console.log(e.message);                   // "All Promises rejected"
  console.log(e.name);                      // "AggregateError"
  console.log(e.errors);                    // [ Error: "some error" ]
});

创建一个AggregateError的示例代码如下：

try {
  throw new AggregateError([
    new Error("some error"),
  ], 'Hello');
} catch (e) {
  console.log(e instanceof AggregateError); // true
  console.log(e.message);                   // "Hello"
  console.log(e.name);                      // "AggregateError"
  console.log(e.errors);                    // [ Error: "some error" ]
}

详细参考文档：AggregateError

String.prototype.replaceAll()——MDN

replaceAll() 方法是返回一个新字符串，新字符串所有满足 pattern 的部分都已被replacement 替换。pattern可以是一个字符串或一个 RegExp， replacement可以是一个字符串或一个在每次匹配被调用的函数。

const p = 'The quick brown fox jumps over the lazy dog. If the dog reacted, was it really lazy?';

const regex = /dog/gi;

console.log(p.replaceAll(regex, 'ferret'));
// expected output: "The quick brown fox jumps over the lazy ferret. If the ferret reacted, was it really lazy?"

console.log(p.replaceAll('dog', 'monkey'));
// expected output: "The quick brown fox jumps over the lazy monkey. If the monkey reacted, was it really lazy?"

详细内容参考：String.prototype.replaceAll()

安利升级

另外，随着 Node.js 15 新版本的发布！官方希望开发者尽快的进行升级，并将遇到的问题反馈就给官方，。当然，开发者还可以使用 Node.js 15 测试你的应用程序和模块，以确保你的项目与最新的 Node.js 特性和更改兼容。

并且，Node.js官方也开始计划升级到 Node.js 14 ，它将在下周升级到 LTS，支持会持续到直到 2023 年 4 月。还要注意的是，Node.js 10 将于 2021 年 4 月结束生命周期。因此，如果你仍在使用 Node.js 10，我们建议你开始计划升级。

原文链接：https://medium.com/@nodejs/node-js-v15-0-0-is-here-deb00750f278

更多编程相关知识，请访问：编程入门！！

Das obige ist der detaillierte Inhalt vonDie offizielle Version von Node.js 15 ist veröffentlicht und wird Node.js 14 als aktuelle stabile Version ersetzen.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!