Quoi de neuf dans Node.js 15?

Nous partageons la traduction de l'article, qui contient des détails sur les nouvelles fonctionnalités de la 15e version de Node.js.

La version 15 de Node.js est sortie le 20 octobre 2020. Les principaux changements comprennent:

• mode lancer sur les écarts non gérés
• fonctionnalités linguistiques V8 8.6
• NPM 7
• support QUIC expérimental
• N-API version 7
• finalisation de l'API de stockage local Async

Examinons de plus près ce que sont ces innovations et comment elles peuvent être utilisées.

Utilisation de NVM pour la présentation des nœuds

Dans l' article précédent, nous avons passé en revue les instructions d'utilisation de NVM (Node Version Manager) pour gérer les versions de Node.js et NPM. Nous avons Node.js 12.16.0 et NPM 6.14.8 installés dans notre environnement. En exécutant le nœud d'installation nvm , nous avons installé Node.js 15.4.0 et NPM7.0.15.



Nous avons deux fenêtres ouvertes, l'une avec Node.js 12 et l'autre avec Node.js 15.



Dans la fenêtre node12 :

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Dans la fenêtre node15 :

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Nous pouvons maintenant étudier cette version.

Mode lancer en cas de rejet de promesse non géré

L'événement unhandledRejection est déclenché chaque fois qu'une promesse est rejetée et qu'un gestionnaire d'erreurs n'est pas attaché à la promesse pendant la boucle d'événements. À partir de Node.js 15, le mode par défaut pour unhandledRejection a été changé de warn à throw . En mode throw , si le hook unhandledRejection n'est pas défini, le unhandledRejection est levé comme une exception non interceptée par la méthode catch .



Créez un programme pour rejeter la promesse avec un message d'erreur:

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

myPromise();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Lorsque vous exécutez ce code dans une fenêtre node12 , un long message d'avertissement apparaît:

$ 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.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

L'exécution de ce code dans la fenêtre node15 génère une erreur UnhandledPromiseRejection :

$ 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'
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Ajoutez un gestionnaire d'erreurs à la branche then dans le code ci-dessous ( .catch (( error ) => console.log ( error .error)) fonctionne également).

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();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Maintenant, le code fonctionne correctement dans les deux fenêtres ( node12 et node15 ):

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Il est recommandé d'écrire un gestionnaire d'erreurs pour les promesses. Cependant, il peut y avoir des cas où les erreurs ne sont pas détectées par la méthode catch. Il est recommandé de configurer le hook unhandledRejection pour détecter les erreurs potentielles.

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
});
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Le hook unhandledRejection fonctionne à la fois dans Node.js 12 et Node.js 15. Une fois installé, le unhandledRejection est géré selon les besoins.

$ 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 Nouvelles fonctionnalités linguistiques

V8, moteur JavaScript, mis à jour de 8.4 à 8.6. version. En plus de divers ajustements pour améliorer les performances, le nouveau V8 présente les caractéristiques suivantes:

• Promise.any () et AggregateError (à partir de V8 8.5)
• attendre setTimeout et AbortController (expérimental)
• String.prototype.replaceAll () (à partir de V8 8.5)
• Opérateurs d'assignation logique && = , || = et ?? = (à partir de V8 8.5)

Promise.any () et AggregateError

Tout d'abord, jetons un œil à la méthode Promise.all () existante .



Promise.all () prend un itérable des promesses comme entrée et retourne une seule promesse, qui est exécutée comme un tableau des résultats des promesses d'entrée.



Le programme suivant appelle Promise.all () sur deux promesses résolues:

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 () renvoie une promesse qui sera remplie lorsque toutes les promesses d'entrée sont résolues, ou si l'itérable ne contient aucune promesse:

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Le programme suivant appelle Promise.all () sur deux promesses rejetées.

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 () rejette immédiatement tout rejet de la promesse d'entrée ou toute erreur au moment de l'exécution, renvoyant un message sur cette erreur:

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Promise.any () est une nouvelle méthode dans Node.js 15. C'est l'opposé de Promise.all () . Promise.any () accepte un itérable contenant des objets Promise. Et, dès que l'une des promesses de l'itérable réussit, la méthode renverra une seule promesse avec la valeur de la promesse tenue.



Le programme suivant appelle Promise.any () sur deux promesses résolues:

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 () renvoie la première promesse résolue:

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Le programme suivant appelle Promise.any () sur deux promesses rejetées:

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();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Si les promesses de l'itérable échouent, c'est-à-dire toutes les promesses données sont rejetées, la promesse retournée est rejetée avec AggregateError , une nouvelle sous-classe d' erreur qui regroupe les erreurs individuelles.

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Attendre setTimeout et AbortController

Dans les exemples précédents, nous avons utilisé setTimeout dans un appel de promesse.



SetTimeout sur WindowOrWorkerGlobalScope utilise un rappel. Cependant, les minuteries / promesses fournissent une version promis de setTimeout qui peut être utilisée avec async / await.

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 est un objet JavaScript qui vous permet d'abandonner une ou plusieurs requêtes Web à volonté. Nous avons fourni des exemples d'utilisation d' AbortController dans un autre article sur useAsync .



Les deux await setTimeout et AbortController sont des fonctionnalités expérimentales.

String.prototype.replaceAll ()

Jetons un coup d'œil à la méthode String.prototype.replace () existante .



replace () renvoie une nouvelle chaîne avec tout ou partie des correspondances de modèle remplacées par le remplaçant. Le modèle peut être une chaîne ou une expression régulière. L'espace réservé peut être une chaîne ou une fonction appelée pour chaque correspondance.



Si le modèle est une chaîne, seule la première occurrence sera remplacée.

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

L'utilisation de cet opérateur donnera «20–1 + 2 + 3» .



Pour remplacer tous les "+" par "-", vous devez utiliser une expression régulière.

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

L'utilisation de l'opérateur ci-dessus donnera «20-1-2-3» .



La méthode replaceAll () est nouvelle dans Node.js 15. En l'utilisant, nous n'avons pas besoin d'utiliser une expression régulière. Cette méthode retourne une nouvelle chaîne avec toutes les correspondances de modèle remplacées par l'espace réservé. Le modèle peut être une chaîne ou une expression régulière, et l'espace réservé peut être une chaîne ou une fonction appelée pour chaque correspondance.



Grâce à la méthode replaceAll () , nous n'avons pas besoin d'utiliser une expression régulière pour remplacer tous les "+" par "-".

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

L'exécution de cet opérateur donne «20-1-2-3» .

Opérateurs d'affectation logique && =, || = et ?? =

L'opérateur d'affectation logique AND ( x && = y ) effectue une opération d'affectation uniquement si x est vrai.



x && = y est équivalent à x && (x = y) , mais pas équivalent à x = x && y .

let x = 0;
let y = 1;

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

L'opérateur d'affectation logique OR (x || = y) effectue une opération d'affectation uniquement si x est faux.



x || = y équivaut à x || (x = y) mais pas équivalent à x = x || à .

let x = 0;
let y = 1;

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

L'opérateur d'assignation logique nullish (x ?? = y) effectue une opération d'affectation uniquement si x est NULL ( nul ou non défini ).



x ?? = y équivaut à x ?? (x = y) , et pas équivalent à x = x ?? à .

let x = undefined;
let y = '';

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Autres changements

En plus du mode throw sur le rejet de promesse non géré et des nouvelles fonctionnalités du langage V8 8.6, Node.js 15 a les changements suivants:



NPM 7 : De nombreux changements, y compris l'installation automatique des dépendances homologues, des améliorations des packages et des fichiers yarn.lock, prise en charge de l'espace de travail , etc. Tout cela est décrit dans cet article par référence .



QUIC : Prise en charge expérimentale de la couche de transport UDP, qui est le protocole principal pour HTTP / 3. QUIC inclut la sécurité intégrée avec TLS 1.3, le contrôle de flux, la correction d'erreurs, la migration de connexion et le multiplexage.



N-API version 7: API pour créer des addons personnalisés. Il est indépendant du runtime JavaScript sous-jacent et est pris en charge dans le cadre de Node.js.



Amélioration de l'API de stockage local Async : offre la possibilité d'une journalisation et d'une analyse des fonctionnalités plus modernes pour les applications à grande échelle.

Conclusion

La nouvelle version de Node.js 15 a un grand nombre de nouvelles fonctionnalités et améliorations, y compris des améliorations assez importantes.



Essayez la nouvelle version et préparez-vous à mettre à jour les projets.



Merci pour l'attention! J'espère que l'article vous a été utile.