Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

La version candidate d'ECMAScript 2020 est disponible avec l'ensemble des fonctionnalités finales,
Dont l'opérateur de coalescence nulle (??) et de chaînage optionnel (?.)

Le , par Bill Fassinou

48PARTAGES

14  0 
Jeudi dernier, la version candidate d'ECMAScript 2020 est sortie avec l'ensemble des fonctionnalités finales de cette version. Rappelons que JavaScript est un langage de programmation basé sur la spécification ECMAScript. Les langages tels que ActionScript, JavaScript, JScript et TypeScript utilisent tous ECMAScript comme noyau. Les fonctionnalités ECMAScript sont conçues indépendamment et passent par des étapes, commençant de 0 (« paille »), se terminant à 4 (« terminé »). Ecma TC39 est le comité responsable de l'évolution du langage de programmation ECMAScript et de la rédaction de la spécification. Voici un aperçu des fonctionnalités d'ES2020 (propositions de l'étape 4) approuvé par le TC39 le 2 avril dernier :

BigInt

BigInt est un objet intégré qui fournit un moyen de représenter des nombres entiers supérieurs à 2⁵³ — 1, qui est le plus grand nombre de JS. JavaScript peut désormais représenter de manière fiable au-delà du type primitif "Number" et pas seulement au maximum à 9007199254740992. Un BigInt est créé en ajoutant n à l'entier (ex. 5n) Ou en appelant BigInt(). BigInt est similaire à Number, mais diffère de plusieurs manières. Il ne peut pas être utilisé avec des méthodes d'objet intégré comme dans Math. BigInt ne peut pas être combiné avec une instance d'opérations de Number. Ils ne peuvent être utilisés qu'avec d'autres variables BigInt sauf si elles sont converties. La proposition consiste à ajouter un nouveau type primitif pour les gros caractères à JavaScript. Étant donné que les entiers implicites (indices de tableau, etc.) continueront d'exister séparément, ils seront appelés BigInt.

import()

Jusqu'à présent, la seule façon d'importer un module a été via une instruction "import". Cette déclaration a plusieurs limites. Vous devez l'utiliser au niveau supérieur d'un module. Autrement dit, vous ne pouvez pas, par exemple, importer quelque chose lorsque vous êtes à l'intérieur d'un bloc ; le spécificateur de module est toujours fixe. Autrement dit, vous ne pouvez pas modifier ce que vous importez en fonction d'une condition. Et vous ne pouvez pas assembler un spécificateur dynamiquement. L'opérateur import() change cela. Il renvoie une promesse pour l'objet d'espace de noms de module du module demandé. Par conséquent, les importations peuvent désormais être affectées à une variable à l'aide de async / wait.

Promise.allSettled ()

Ceci est une autre méthode pour les promesses qui vérifie si toutes les promesses qui sont créées ont été réglées. La différence entre promise.all() et promise.allSettled() est promise.all() résolu uniquement si toutes les promesses sont résolues avec succès et sans erreur. Si une promesse est rejetée, .all() elle ne sera pas résolue. D'un autre côté, promise.allSettled() sera réglé même si la promesse est résolue ou rejetée.


L'opérateur de chaînage optionnel (?.)

Lors de la recherche d'une valeur de propriété au plus profond d'une structure arborescente, il faut souvent vérifier si des nœuds intermédiaires existent. De plus, de nombreuses API renvoient un objet ou null / undefined, et on peut vouloir extraire une propriété du résultat uniquement quand il n'est pas null. L'opérateur de chaînage optionnel permet à un développeur de gérer bon nombre de ces cas sans se répéter et/ou affecter des résultats intermédiaires dans des variables temporaires. Lorsqu'une autre valeur que celle undefined souhaitée pour le cas manque, cela peut généralement être géré avec l'opérateur de coalescence nulle.

L'opérateur de coalescence nulle (??)

Lors de l'exécution des accès aux propriétés, il est souvent souhaité de fournir une valeur par défaut si le résultat de cet accès aux propriétés est null ou undefined. À l'heure actuelle, une façon typique d'exprimer cette intention en JavaScript consiste à utiliser l'opérateur ||. Cela fonctionne bien pour le cas commun des valeurs null et undefined, mais il existe un certain nombre de valeurs fausses qui pourraient produire des résultats inattendus comme dans le cas ci-dessous.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
const response = {   
    settings: {     
        nullValue: null,     
        height: 400,     
        animationDuration: 0,     
        headerText: '',     
        showSplashScreen: false
    } 
};
const headerText = response.settings.headerText || 'Hello, world!';
const animationDuration = response.settings.animationDuration || 300;
const showSplashScreen = response.settings.showSplashScreen || true;
L'opérateur de coalescence nulle est destiné à mieux gérer ces cas et sert de contrôle d'égalité par rapport aux valeurs null ou undefined.

Source : ECMAScript 2020

Et vous ?

Que pensez-vous des nouveautés d'ECMAScript 2020 ?

Voir aussi

ECMAScript 2017 : Ecma International annonce les nouvelles mises à jour de ses spécifications, pour les langages de script

Tutoriel présentant les nouveautés ECMAScript 6

Introduction à PHP 7, ECMASCRIPT 6 et VUE.JS par l'exemple, un tutoriel de Serge Tahé

ECMAScript 2016 : des mises à jour plus petites et plus fréquentes pour l'ensemble de normes des langages de script

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de Mrsky
Membre expérimenté https://www.developpez.com
Le 07/04/2020 à 15:02
Je sais pas de quelle complexité tu parles, ces opérateurs existent aujourd'hui dans pas mal de langages et ne sont pas plus compliqués à comprendre que l'opérateur ternaire.

Ça permet justement de limiter le nombre de ifs dans le code, et donc d'améliorer la lisibilité tout en passant par des constructions de langage qui, on peut espérer, sont plus efficaces (moins gourmands lors de l’exécution).
1  0 
Avatar de dfiad77pro
Membre expérimenté https://www.developpez.com
Le 07/04/2020 à 18:23
moins gourmand je suis pas sur si le dev fait ça :

Code : Sélectionner tout
1
2
3
4
const c1= pere?.fils?.petitFils[0];
const c2= pere?.fils?.petitFils[1];
const c3= pere?.fils?.petitFils[2];
dans ce cas , le test de nullité est exécuté plusieurs fois pour rien. Et sur de gros volumes ça se ressent. Et ce n'est pas que le cas en JS, en C# aussi faut faire attention.
1  0 
Avatar de Mrsky
Membre expérimenté https://www.developpez.com
Le 08/04/2020 à 8:11
Pour l'opérateur de coalescence nulle, aujourd'hui en JS pur si tu veux faire propre tu dois faire un truc comme "if (x === null || x === undefined) {}" pour vérifier l'existence d'une valeur car si tu utilises "||" tu vas avoir tous les faux positifs du JS qui posent problème. Quand je parle de gourmand on est dans de la micro optimisation, quand le parser voit "if (expr)" il doit évaluer l'expression alors que quand il verra "??" il saura déjà comment le traduire.

Clairement ca change pas grand chose, mon argument était que l'opérateur est plutôt simple à prendre en main car probablement déjà connu par des devs et de mon point de vue améliore la lisibilité du code (j'entends que ce point est subjectif), tout en ne coûtant rien en terme d’exécution voir ça améliore (très) légèrement les perfs.
1  0 
Avatar de melka one
Membre éprouvé https://www.developpez.com
Le 07/04/2020 à 11:57
je trouve tout de même étrange de voir ce que j'arrive a faire avec une simple boucle for et de simple if et que je voit des code faisant la même chose utilisant l'artillerie lourde pour plus complexe plus technique plus classsss et au finale le rendu est pareil voir moins bien.
0  0 
Avatar de Zefling
Expert confirmé https://www.developpez.com
Le 07/04/2020 à 19:10
Citation Envoyé par dfiad77pro

dans ce cas , le test de nullité est exécuté plusieurs fois pour rien. Et sur de gros volumes ça se ressent. Et ce n'est pas que le cas en JS, en C# aussi faut faire attention.
Je voyais des trucs du genre avec jQuery :
Code : Sélectionner tout
1
2
3
4
$('#element').css( "background-color", "red" );
$('#element').css( "color", "blue" );
$('#element').addClass("myClass" );
Si tu sais pas ce que tu fais, quelque soit le langage, l'API, le framework, ça risque d'être assez horrible niveau perf.
0  0 
Avatar de pipitt05000
Membre à l'essai https://www.developpez.com
Le 07/04/2020 à 11:19
les langages on cherche a tous maitriser par des mots afin de balayer toutes les possibilite meme si elles sont rares quitte a augmenter l'apprentissage et par effet de ricochet a complexifier ce même apprentissage faisant de plus en plus appel a la mémoire, sans oublier les symboles qui peuvent tout faire et complexifie la lecture du code.
Je dirai même plus:
Quoi qu'on dise concernant l'inertie contextuelle, il ne faut pas négliger d'anticiper l'ensemble des options que nous connaissons, parce que nous ne faisons plus le même métier.
0  2 
Avatar de melka one
Membre éprouvé https://www.developpez.com
Le 07/04/2020 à 10:40
les langages on cherche a tous maitriser par des mots afin de balayer toutes les possibilite meme si elles sont rares quitte a augmenter l'apprentissage et par effet de ricochet a complexifier ce même apprentissage faisant de plus en plus appel a la mémoire, sans oublier les symboles qui peuvent tout faire et complexifie la lecture du code.
0  5