Aller au contenu principal

16 articles tagués avec « ECMAScript »

Voir tous les tags

Comprendre la spécification ECMAScript, partie 4

· 8 minutes de lecture
[Marja Hölttä](https://twitter.com/marjakh), spectatrice spéculative des spécifications

Tous les épisodes

Pendant ce temps dans d'autres parties du Web

Jason Orendorff de Mozilla a publié une excellente analyse approfondie des particularités syntaxiques du JavaScript. Bien que les détails de l'implémentation diffèrent, chaque moteur JS fait face aux mêmes problèmes avec ces particularités.

Comprendre la spécification ECMAScript, partie 3

· 13 minutes de lecture
[Marja Hölttä](https://twitter.com/marjakh), observatrice spéculative de la spécification

Tous les épisodes

Dans cet épisode, nous approfondirons la définition du langage ECMAScript et sa syntaxe. Si vous n'êtes pas familier avec les grammaires libres de contexte, c'est le bon moment pour vérifier les bases, car la spécification utilise des grammaires libres de contexte pour définir le langage. Consultez le chapitre sur les grammaires libres de contexte dans "Crafting Interpreters" pour une introduction accessible ou la page Wikipédia pour une définition plus mathématique.

Comprendre la spécification ECMAScript, partie 2

· 12 minutes de lecture
[Marja Hölttä](https://twitter.com/marjakh), spectatrice spéculative des spécifications

Continuons à pratiquer nos incroyables compétences de lecture des spécifications. Si vous n’avez pas jeté un œil au premier épisode, c’est le moment de le faire !

Tous les épisodes

Prêt pour la partie 2 ?

Une manière amusante de se familiariser avec la spécification est de commencer par une fonctionnalité JavaScript que nous connaissons, et de découvrir comment elle est spécifiée.

Attention ! Cet épisode contient des algorithmes copiés-collés de la spécification ECMAScript en février 2020. Ils deviendront éventuellement obsolètes.

Nous savons que les propriétés sont recherchées dans la chaîne de prototypes : si un objet n’a pas la propriété que nous essayons de lire, nous remontons la chaîne de prototypes jusqu’à la trouver (ou jusqu’à atteindre un objet qui n’a plus de prototype).

Par exemple :

const o1 = { foo: 99 };
const o2 = {};
Object.setPrototypeOf(o2, o1);
o2.foo;
// → 99

Où est défini le parcours de la chaîne de prototypes ?

Essayons de découvrir où ce comportement est défini. Une bonne entrée en matière est la liste des Méthodes Interne d'Objet.

Il y a à la fois [[GetOwnProperty]] et [[Get]] — nous sommes intéressés par la version qui ne se limite pas aux propriétés propres, donc nous choisirons [[Get]].

Malheureusement, le type de spécification des descripteurs de propriété a également un champ appelé [[Get]], donc en parcourant la spécification pour [[Get]], nous devons soigneusement distinguer les deux usages indépendants.

Contenu supplémentaire pour "Comprendre la spécification ECMAScript, partie 2"

· 3 minutes de lecture
[Marja Hölttä](https://twitter.com/marjakh), spectatrice de spécifications spéculatives

Pourquoi o2.foo est-il une AssignmentExpression ?

o2.foo ne ressemble pas à une AssignmentExpression puisqu'il n'y a pas d'affectation. Pourquoi est-ce une AssignmentExpression ?

La spécification autorise en fait une AssignmentExpression à la fois comme argument et comme côté droit d'une affectation. Par exemple :

function simple(a) {
console.log('L'argument était ' + a);
}
simple(x = 1);
// → Affiche “L'argument était 1”.
x;
// → 1

…et…

x = y = 5;
x; // 5
y; // 5

o2.foo est une AssignmentExpression qui n'assigne rien. Cela découle des productions grammaticales suivantes, chaque une prenant le cas « le plus simple » jusqu'à la dernière :

Une AssignmentExpression n'a pas besoin d'avoir une affectation, elle peut aussi être juste une ConditionalExpression :

AssignmentExpression : ConditionalExpression

(Il existe d'autres productions également, ici nous montrons uniquement celle pertinente.)

Une ConditionalExpression n'a pas besoin d'avoir une condition (a == b ? c : d), elle peut aussi être simplement une ShortcircuitExpression :

ConditionalExpression : ShortCircuitExpression

Et ainsi de suite :

ShortCircuitExpression : LogicalORExpression

LogicalORExpression : LogicalANDExpression

LogicalANDExpression : BitwiseORExpression

BitwiseORExpression : BitwiseXORExpression

BitwiseXORExpression : BitwiseANDExpression

BitwiseANDExpression : EqualityExpression

EqualityExpression : RelationalExpression

RelationalExpression : ShiftExpression

Comprendre la spécification ECMAScript, partie 1

· 10 minutes de lecture
[Marja Hölttä](https://twitter.com/marjakh), spectateur spéculatif de la spécification

Tous les épisodes

Dans cet article, nous prenons une fonction simple de la spécification et essayons de comprendre la notation. Allons-y !

Préface

Même si vous connaissez JavaScript, lire sa spécification de langage, Spécification du langage ECMAScript, ou la spécification ECMAScript en abrégé, peut être assez intimidant. C’est au moins ce que j’ai ressenti lorsque je l’ai lue pour la première fois.

Des API d'internationalisation plus rapides et riches en fonctionnalités

· 6 minutes de lecture
[சத்யா குணசேகரன் (Sathya Gunasekaran)](https://twitter.com/_gsathya)

La spécification de l'API d'internationalisation ECMAScript (ECMA-402, ou Intl) fournit des fonctionnalités clés spécifiques à chaque langue, comme le formatage des dates, des nombres, la sélection des formes plurielles et le classement. Les équipes Chrome V8 et Google Internationalization ont collaboré pour ajouter des fonctionnalités à l'implémentation ECMA-402 de V8, tout en nettoyant les dettes techniques et en améliorant les performances ainsi que l'interopérabilité avec d'autres navigateurs.

Accélérer les éléments de propagation

· 10 minutes de lecture
Hai Dang & Georg Neis

Pendant son stage de trois mois au sein de l'équipe V8, Hai Dang a travaillé à améliorer les performances de [...array], [...string], [...set], [...map.keys()], et [...map.values()] (quand les éléments de propagation sont au début du littéral de tableau). Il a même rendu Array.from(iterable) beaucoup plus rapide. Cet article explique certains détails techniques de ses modifications, incluses dans V8 à partir de la version 7.2.

Des fonctions asynchrones et des promesses plus rapides

· 20 minutes de lecture
Maya Armyanova ([@Zmayski](https://twitter.com/Zmayski)), anticipatrice toujours en attente, et Benedikt Meurer ([@bmeurer](https://twitter.com/bmeurer)), garant professionnel de performance

Le traitement asynchrone en JavaScript avait traditionnellement la réputation de ne pas être particulièrement rapide. Pour aggraver les choses, le débogage d'applications JavaScript en direct — en particulier des serveurs Node.js — n'est pas chose aisée, surtout lorsqu'il s'agit de programmation asynchrone. Heureusement, les temps changent. Cet article explore comment nous avons optimisé les fonctions asynchrones et les promesses dans V8 (et dans une certaine mesure dans d'autres moteurs JavaScript également), et décrit comment nous avons amélioré l'expérience de débogage de code asynchrone.

Classer les choses dans V8

· 20 minutes de lecture
Simon Zünd ([@nimODota](https://twitter.com/nimODota)), comparateur cohérent

Array.prototype.sort était parmi les derniers modules intégrés mis en œuvre en JavaScript auto-hébergé dans V8. Le porter nous a offert l'opportunité d'expérimenter avec différents algorithmes et stratégies d'implémentation et finalement le rendre stable dans V8 v7.0 / Chrome 70.

Amélioration des performances de `DataView` dans V8

· 10 minutes de lecture
Théotime Grohens, <i lang="fr">le savant de Data-Vue</i>, et Benedikt Meurer ([@bmeurer](https://twitter.com/bmeurer)), professionnel de la performance

DataView est l'une des deux manières possibles de réaliser des accès mémoire à bas niveau en JavaScript, l'autre étant TypedArray. Jusqu'à présent, les DataView étaient beaucoup moins optimisés que les TypedArray dans V8, ce qui entraînait de moins bonnes performances dans des tâches comme les charges de travail intensives en graphismes ou lors du décodage/encodage de données binaires. Les raisons de cela étaient principalement des choix historiques, comme le fait que asm.js avait opté pour les TypedArray au lieu des DataView, incitant ainsi les moteurs à se concentrer sur les performances des TypedArray.