diff options
Diffstat (limited to 'files/fr/web/javascript')
7 files changed, 495 insertions, 407 deletions
diff --git a/files/fr/web/javascript/guide/modules/index.md b/files/fr/web/javascript/guide/modules/index.md index 96cdf51b3d..4c2db796ba 100644 --- a/files/fr/web/javascript/guide/modules/index.md +++ b/files/fr/web/javascript/guide/modules/index.md @@ -182,7 +182,7 @@ Les instructions `import` et `export` ne peuvent être utilisées qu'à l'intér - Attention aux tests sur un environnement local : si vous chargez le fichier HTML directement depuis le système de fichier dans le navigateur (en double-cliquant dessus par exemple, ce qui donnera une URL `file://`), vous rencontrerez des erreurs CORS pour des raisons de sécurité. Il faut donc un serveur local afin de pouvoir tester. - On pourra avoir un comportement différent entre un même script utilisé comme un module et un script utilisé de façon « classique ». En effet, les modules utilisent automatiquement [le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). -- Il n'est pas nécessaire d'utiliser l'attribut `defer` (voir [les attributs de `<script>`](/fr/docs/Web/HTML/Element/script#attributs)) lors du chargement d'un module, ceux-ci sont automatiquement chargés à la demande. +- Il n'est pas nécessaire d'utiliser l'attribut `defer` (voir [les attributs de `<script>`](/fr/docs/Web/HTML/Element/script#attributs)) lors du chargement d'un module, celui-ci étant automatiquement différé. - Les modules sont exécutés une seule fois, même s'ils sont référencés dans plusieurs balises `<script>`. - Enfin, les fonctionnalités importées ne sont disponibles qu'au sein de la portée du script qui les utilise ! Les valeurs importées ne sont manipulables que depuis le script, elles ne sont pas rattachées à la portée globale. On ne pourra par exemple pas y accéder depuis la console JavaScript. Bien que les erreurs soient toujours indiquées dans les outils de développement, certaines techniques de débogage ne seront pas disponibles. diff --git a/files/fr/web/javascript/guide/working_with_objects/index.md b/files/fr/web/javascript/guide/working_with_objects/index.md index 214902c6dd..9dbfe909e4 100644 --- a/files/fr/web/javascript/guide/working_with_objects/index.md +++ b/files/fr/web/javascript/guide/working_with_objects/index.md @@ -348,7 +348,7 @@ On peut définir des méthodes pour un type d'objet en incluant la définition d ```js function afficheVoiture() { let resultat = `Une belle ${this.modele}, fabriquée en ${this.annee} par ${this.fabricant}`; - console.log(résultat); + console.log(resultat); } ``` diff --git a/files/fr/web/javascript/reference/global_objects/uint8array/index.md b/files/fr/web/javascript/reference/global_objects/uint8array/index.md index e4cb8de79c..5f30ffb406 100644 --- a/files/fr/web/javascript/reference/global_objects/uint8array/index.md +++ b/files/fr/web/javascript/reference/global_objects/uint8array/index.md @@ -1,181 +1,141 @@ --- title: Uint8Array slug: Web/JavaScript/Reference/Global_Objects/Uint8Array -tags: - - Constructor - - JavaScript - - Reference - - TypedArray - - TypedArrays - - Uint8Array translation_of: Web/JavaScript/Reference/Global_Objects/Uint8Array original_slug: Web/JavaScript/Reference/Objets_globaux/Uint8Array +browser-compat: javascript.builtins.Uint8Array --- {{JSRef}} Le tableau typé **`Uint8Array`** représente un tableau d'entiers non signés, représentés sur 8 bits. Les éléments du tableau sont initialisés à `0`. Une fois que le tableau est construit, on peut manipuler ses différents éléments grâce aux méthodes de l'objet ou grâce à la notation usuelle (avec les crochets). -## Syntaxe +## Constructeur - new Uint8Array(); // apparu avec ES2017 - new Uint8Array(longueur); - new Uint8Array(tableauTypé); - new Uint8Array(objet); - new Uint8Array(tampon [, décalage [, longueur]]); +- [`Uint8Array()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/Uint8Array) + - : Crée un nouvel objet `Uint8Array`. -Pour plus d'informations sur la syntaxe du constructeur et le rôle des différents paramètres, voir la page _[TypedArray](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe)_. +## Propriétés statiques -## Propriétés +- [`Uint8Array.BYTES_PER_ELEMENT`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/BYTES_PER_ELEMENT) + - : Cette propriété renvoie la taille d'un élément du tableau, en octets. En l'occurrence, pour `Uint8Array` ce sera `1`. +- [`Uint8Array.name`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/name) + - : Cette propriété renvoie la chaîne de caractères correspondant au nom du constructeur. Pour `Uint8Array` ce sera : "`Uint8Array`". -- {{jsxref("TypedArray.BYTES_PER_ELEMENT", "Uint8Array.BYTES_PER_ELEMENT")}} - - : Cette propriété renvoie la taille d'un élément du tableau, en octets. En l'occurence, pour `Uint8Array` ce sera `1`. -- Uint8Array.length - - : La propriété de longueur statique qui vaut 3. Pour connaître le nombre d'élément, voir {{jsxref("TypedArray.prototype.length", "Uint8Array.prototype.length")}}. -- {{jsxref("TypedArray.name", "Uint8Array.name")}} - - : Cette propriété renvoie la chaîne de caractères correspondant au nom du constructeur. Pour `Uint8Array` ce sera : "Uint8Array". -- {{jsxref("TypedArray.prototype", "Uint8Array.prototype")}} - - : Le prototype des objets _TypedArray_. +## Méthodes statiques -## Méthodes +- [`Uint8Array.from()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from) + - : Cette méthode permet de créer un nouvel objet `Uint8Array` à partir d'un itérable ou d'un objet semblable à un tableau. Voir aussi [`Array.from()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/from). +- [`Uint8Array.of()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of) + - : Cette méthode permet de créer un nouvel objet `Uint8Array` à partir d'un nombre variable d'arguments. Voir aussi [`Array.of()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/of). -- {{jsxref("TypedArray.from", "Uint8Array.from()")}} - - : Cette méthode permet de créer un nouvel objet `Uint8Array` à partir d'un itérable ou d'un objet semblable à un tableau. Voir aussi {{jsxref("Array.from()")}}. -- {{jsxref("TypedArray.of", "Uint8Array.of()")}} - - : Cette méthode permet de créer un nouvel objet `Uint8Array` à partir d'un nombre variables d'arguments. Voir aussi {{jsxref("Array.of()")}}. +## Propriétés des instances -## Prototype `Uint8Array` - -Tous les objets `Uint8Array` héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}. - -### Propriétés - -- `Uint8Array.prototype.constructor` - - : Cette propriété renvoie la fonction qui a créé l'instance du prototype. Par défaut, ce sera le constructeur `Uint8Array`. -- {{jsxref("TypedArray.prototype.buffer", "Uint8Array.prototype.buffer")}} {{readonlyInline}} - - : Cette propriété renvoie l'objet {{jsxref("ArrayBuffer")}} référencé par l'objet `Uint8Array` Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. -- {{jsxref("TypedArray.prototype.byteLength", "Uint8Array.prototype.byteLength")}} {{readonlyInline}} - - : Cette propriété renvoie la longueur, exprimée en octets, de l'objet `Uint8Array` à partir du début de l'objet {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. -- {{jsxref("TypedArray.prototype.byteOffset", "Uint8Array.prototype.byteOffset")}} {{readonlyInline}} - - : Cette propriété renvoie le décalage, en nombre d'octets, entre le début du tableau typé courant et du début du {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. -- {{jsxref("TypedArray.prototype.length", "Uint8Array.prototype.length")}} {{readonlyInline}} +- [`Uint8Array.prototype.buffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) + - : Cette propriété renvoie l'objet [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) référencé par l'objet `Uint8Array`. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. +- [`Uint8Array.prototype.byteLength`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) + - : Cette propriété renvoie la longueur, exprimée en octets, de l'objet `Uint8Array` à partir du début de l'objet [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. +- [`Uint8Array.prototype.byteOffset`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) + - : Cette propriété renvoie le décalage, en nombre d'octets, entre le début du tableau typé courant et du début du [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. +- [`Uint8Array.prototype.length`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) - : Cette propriété renvoie le nombre d'éléments contenus dans le tableau `Uint8Array`. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. -### Méthodes - -- {{jsxref("TypedArray.copyWithin", "Uint8Array.prototype.copyWithin()")}} - - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}. -- {{jsxref("TypedArray.entries", "Uint8Array.prototype.entries()")}} - - : Renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}. -- {{jsxref("TypedArray.every", "Uint8Array.prototype.every()")}} - - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}. -- {{jsxref("TypedArray.fill", "Uint8Array.prototype.fill()")}} - - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}. -- {{jsxref("TypedArray.filter", "Uint8Array.prototype.filter()")}} - - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}. -- {{jsxref("TypedArray.find", "Uint8Array.prototype.find()")}} - - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}. -- {{jsxref("TypedArray.findIndex", "Uint8Array.prototype.findIndex()")}} - - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}. -- {{jsxref("TypedArray.forEach", "Uint8Array.prototype.forEach()")}} - - : Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}. -- {{jsxref("TypedArray.includes", "Uint8Array.prototype.includes()")}} - - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}. -- {{jsxref("TypedArray.indexOf", "Uint8Array.prototype.indexOf()")}} - - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}. -- {{jsxref("TypedArray.join", "Uint8Array.prototype.join()")}} - - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}. -- {{jsxref("TypedArray.keys", "Uint8Array.prototype.keys()")}} - - : Renvoie un nouvel objet `Array Iterator` qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}. -- {{jsxref("TypedArray.lastIndexOf", "Uint8Array.prototype.lastIndexOf()")}} - - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}. -- {{jsxref("TypedArray.map", "Uint8Array.prototype.map()")}} - - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}. -- {{jsxref("TypedArray.move", "Uint8Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}} - - : Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Uint8Array.prototype.copyWithin()")}}. -- {{jsxref("TypedArray.reduce", "Uint8Array.prototype.reduce()")}} - - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}. -- {{jsxref("TypedArray.reduceRight", "Uint8Array.prototype.reduceRight()")}} - - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}. -- {{jsxref("TypedArray.reverse", "Uint8Array.prototype.reverse()")}} - - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}. -- {{jsxref("TypedArray.set", "Uint8Array.prototype.set()")}} - - : Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau. -- {{jsxref("TypedArray.slice", "Uint8Array.prototype.slice()")}} - - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}. -- {{jsxref("TypedArray.some", "Uint8Array.prototype.some()")}} - - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}. -- {{jsxref("TypedArray.sort", "Uint8Array.prototype.sort()")}} - - : Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}. -- {{jsxref("TypedArray.subarray", "Uint8Array.prototype.subarray()")}} +## Méthodes des instances + +- [`Uint8Array.prototype.copyWithin()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) + - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également [`Array.prototype.copyWithin()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin). +- [`Uint8Array.prototype.entries()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries) + - : Renvoie un nouvel *itérateur de tableau* qui contient les paires clé/valeur pour chaque indice du tableau. Voir également [`Array.prototype.entries()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/entries). +- [`Uint8Array.prototype.every()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) + - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également [`Array.prototype.every()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/every). +- [`Uint8Array.prototype.fill()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) + - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également [`Array.prototype.fill()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/fill). +- [`Uint8Array.prototype.filter()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) + - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également [`Array.prototype.filter()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/filter). +- [`Uint8Array.prototype.find()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) + - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également [`Array.prototype.find()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/find). +- [`Uint8Array.prototype.findIndex()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) + - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition `-1` sera renvoyé. Voir également [`Array.prototype.findIndex()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex). +- [`Uint8Array.prototype.forEach()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) + - : Appelle une fonction pour chacun des éléments du tableau. Voir également [`Array.prototype.forEach()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach). +- [`Uint8Array.prototype.includes()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) + - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également [`Array.prototype.includes()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/includes). +- [`Uint8Array.prototype.indexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) + - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur `-1` sera renvoyée. Voir également [`Array.prototype.indexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf). +- [`Uint8Array.prototype.join()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) + - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également [`Array.prototype.join()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/join). +- [`Uint8Array.prototype.keys()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys) + - : Renvoie un nouvel *itérateur de tableau* qui contient les clés de chaque indice du tableau. Voir également [`Array.prototype.keys()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/keys). +- [`Uint8Array.prototype.lastIndexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) + - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur `-1` sera renvoyée. Voir également [`Array.prototype.lastIndexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf). +- [`Uint8Array.prototype.map()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) + - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également [`Array.prototype.map()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/map). +- [`Uint8Array.prototype.reduce()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) + - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également [`Array.prototype.reduce()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce). +- [`Uint8Array.prototype.reduceRight()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) + - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également [`Array.prototype.reduceRight()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight). +- [`Uint8Array.prototype.reverse()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) + - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également [`Array.prototype.reverse()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse). +- [`Uint8Array.prototype.set()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) + - : Enregistre plusieurs valeurs dans le tableau typé à partir des valeurs d'un autre tableau. +- [`Uint8Array.prototype.slice()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) + - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également [`Array.prototype.slice()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). +- [`Uint8Array.prototype.some()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) + - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également [`Array.prototype.some()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/some). +- [`Uint8Array.prototype.sort()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) + - : Trie les éléments du tableau et renvoie ce tableau. Voir également [`Array.prototype.sort()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/sort). +- [`Uint8Array.prototype.subarray()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) - : Renvoie un nouvel objet `Uint8Array` qui est le fragment du tableau courant, entre les indices de début et de fin donnés. -- {{jsxref("TypedArray.values", "Uint8Array.prototype.values()")}} - - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}. -- {{jsxref("TypedArray.toLocaleString", "Uint8Array.prototype.toLocaleString()")}} - - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}. -- {{jsxref("TypedArray.toString", "Uint8Array.prototype.toString()")}} - - : Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}. -- {{jsxref("TypedArray.@@iterator", "Uint8Array.prototype[@@iterator]()")}} - - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. +- [`Uint8Array.prototype.values()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values) + - : Renvoie un nouvel *itérateur de tableau* qui contient les valeurs correspondantes à chaque indice du tableau. Voir également [`Array.prototype.values()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/values). +- [`Uint8Array.prototype.toLocaleString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) + - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également [`Array.prototype.toLocaleString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString). +- [`Uint8Array.prototype.toString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) + - : Renvoie une chaîne de caractères qui représente le tableau et ses éléments. Voir également [`Array.prototype.toString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/toString). +- [`Uint8Array.prototype[@@iterator]()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/@@iterator) + - : Renvoie un nouvel *itérateur de tableau* qui contient les valeurs correspondantes à chaque indice du tableau. ## Exemples -Différentes façons de construire un objet `Uint8Array` : +### Différentes façons de construire un objet `Uint8Array` ```js // Construction à partir d'une longueur -var uint8 = new Uint8Array(2); +let uint8 = new Uint8Array(2); uint8[0] = 42; console.log(uint8[0]); // 42 console.log(uint8.length); // 2 console.log(uint8.BYTES_PER_ELEMENT); // 1 // Construction à partir d'un tableau -var arr = new Uint8Array([21,31]); +let arr = new Uint8Array([21,31]); console.log(arr[1]); // 31 // Construction à partir d'un tableau typé -var x = new Uint8Array([21, 31]); -var y = new Uint8Array(x); +let x = new Uint8Array([21, 31]); +let y = new Uint8Array(x); console.log(y[0]); // 21 // Construction à partir d'un ArrayBuffer -var buffer = new ArrayBuffer(8); -var z = new Uint8Array(buffer, 1, 4); +let buffer = new ArrayBuffer(8); +let z = new Uint8Array(buffer, 1, 4); // Construction à partir d'un itérable -var iterable = function*(){ yield* [1,2,3]; }(); -var uint8 = new Uint8Array(iterable); +let iterable = function*(){ yield* [1,2,3]; }(); +let uint8 = new Uint8Array(iterable); // Uint8Array[1, 2, 3] ``` ## Spécifications -| Spécification | État | Commentaires | -| ------------------------------------------------------------------------------------ | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | -| {{SpecName('Typed Array')}} | {{Spec2('Typed Array')}} | Englobée par ECMAScript 2015. | -| {{SpecName('ES6', '#table-49', 'TypedArray constructors')}} | {{Spec2('ES6')}} | Définition initiale au sein d'un standard ECMA. `new` est obligatoire. | -| {{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}} | {{Spec2('ESDraft')}} | ECMAScript 2017 a modifié le constructeur `Uint8Array` afin qu'il utilise l'opération `ToIndex` et qu'il puisse être utilisé sans argument. | +{{Specifications}} ## Compatibilité des navigateurs -{{Compat("javascript.builtins.Uint8Array")}} - -## Notes de compatibilité - -À partir d'ECMAScript 2015 (ES6), `Uint8Array` doit être utilisé avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler un constructeur `Uint8Array` comme une fonction, sans `new`, provoquera une exception {{jsxref("TypeError")}}. - -```js example-bad -var dv = Uint8Array([1, 2, 3]); -// TypeError: calling a builtin Uint8Array constructor -// without new is forbidden -``` - -```js example-good -var dv = new Uint8Array([1, 2, 3]); -``` +{{Compat}} ## Voir aussi -- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés) -- {{jsxref("ArrayBuffer")}} -- {{jsxref("DataView")}} +- [Une prothèse d'émulation (<i lang="en">polyfill</i>) pour `Uint8ClampedArray` avec `core-js`](https://github.com/zloirock/core-js#ecmascript-typed-arrays) +- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Typed_arrays) +- [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) +- [`DataView`](/fr/docs/Web/JavaScript/Reference/Global_Objects/DataView) diff --git a/files/fr/web/javascript/reference/global_objects/uint8array/uint8array/index.md b/files/fr/web/javascript/reference/global_objects/uint8array/uint8array/index.md new file mode 100644 index 0000000000..5248fb1261 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/uint8array/uint8array/index.md @@ -0,0 +1,93 @@ +--- +title: Constructeur Uint8Array() +slug: Web/JavaScript/Reference/Global_Objects/Uint8Array/Uint8Array +translation_of: Web/JavaScript/Reference/Global_Objects/Uint8Array/Uint8Array +browser-compat: javascript.builtins.Uint8Array.Uint8Array +--- +{{JSRef}} + +Le constructeur **`Uint8Array()`** crée un tableau typé contenant des entiers non-signés sur 8 bits. Le contenu de ces éléments est initialisé à `0`. Une fois le tableau construit, on peut faire référence aux éléments du tableau à l'aide des méthodes de l'objet ou en utilisant la notation usuelle pour les tableaux avec les crochets. + +## Syntaxe + +```js +new Uint8Array(); // apparu avec ES2017 +new Uint8Array(longueur); +new Uint8Array(tableauType); +new Uint8Array(objet); + +new Uint8Array(buffer); +new Uint8Array(buffer, decalageOctets); +new Uint8Array(buffer, decalageOctets, longueur); +``` + +### Paramètres + +- `longueur` + - : Lorsque le constructeur est invoqué avec un argument indiquant une longueur, un tampon de mémoire interne tabulé est créé, dont la taille en octets est `longueur` _multipliée par `BYTES_PER_ELEMENT`_, et qui contient des zéros. +- `tableauType` + - : Lorsque le constructeur est invoqué avec un tableau typé comme argument (tout tableau typé en dehors des tableaux typés [`bigint`](/fr/docs/Glossary/BigInt) tel que `Int32Array`), ce tableau typé est copié dans un nouveau tableau typé. Chaque valeur de `tableauType` est convertie dans le type correspondant au constructeur avant d'être copiée dans le nouveau tableau. La longueur du nouveau tableau typé sera la même que celle de `tableauType`. +- `objet` + - : Lorsque le constructeur est appelé avec un objet comme argument, le nouveau tableau typé est créé avec la méthode `TypedArray.from()`. +- `buffer`, `decalageOctets`, `longueur` + - : Lorsque le constructeur est invoqué avec un tampon, éventuellement un décalage en octets et une longueur, une nouvelle vue en tableau typé est créée qui reflète l'objet [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) correspondant. Les paramètres `decalageOctets` et `longueur` indique l'intervalle de mémoire exposé à la vue. Si ces deux paramètres sont absents, c'est l'intégralité du tampon qui est vue. Si la longueur est absente, c'est la portion du tampon, après le décalage indiqué, qui est vue. + +## Exemples + +### Différentes façons de construire un objet `Uint8Array` + +```js +// Construction à partir d'une longueur +let uint8 = new Uint8Array(2); +uint8[0] = 42; +console.log(uint8[0]); // 42 +console.log(uint8.length); // 2 +console.log(uint8.BYTES_PER_ELEMENT); // 1 + +// Construction à partir d'un tableau +let arr = new Uint8Array([21,31]); +console.log(arr[1]); // 31 + +// Construction à partir d'un tableau typé +let x = new Uint8Array([21, 31]); +let y = new Uint8Array(x); +console.log(y[0]); // 21 + +// Construction à partir d'un ArrayBuffer +let buffer = new ArrayBuffer(8); +let z = new Uint8Array(buffer, 1, 4); + +// Construction à partir d'un itérable +let iterable = function*(){ yield* [1,2,3]; }(); +let uint8 = new Uint8Array(iterable); +// Uint8Array[1, 2, 3] +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Notes de compatibilité + +À partir d'ECMAScript 2015 (ES6), `Uint8Array` doit être utilisé avec l'opérateur [`new`](/fr/docs/Web/JavaScript/Reference/Operators/new). Appeler un constructeur `Uint8Array` comme une fonction, sans `new`, provoquera une exception [`TypeError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypeError). + +```js example-bad +let dv = Uint8Array([1, 2, 3]); +// TypeError: calling a builtin Uint8Array constructor +// without new is forbidden +``` + +```js example-good +let dv = new Uint8Array([1, 2, 3]); +``` + +## Voir aussi + +- [Une prothèse d'émulation (<i lang="en">polyfill</i>) pour `Uint8ClampedArray` avec `core-js`](https://github.com/zloirock/core-js#ecmascript-typed-arrays) +- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Typed_arrays) +- [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) +- [`DataView`](/fr/docs/Web/JavaScript/Reference/Global_Objects/DataView)
\ No newline at end of file diff --git a/files/fr/web/javascript/reference/global_objects/uint8clampedarray/index.md b/files/fr/web/javascript/reference/global_objects/uint8clampedarray/index.md index d8c0d29dcf..b9fad4500d 100644 --- a/files/fr/web/javascript/reference/global_objects/uint8clampedarray/index.md +++ b/files/fr/web/javascript/reference/global_objects/uint8clampedarray/index.md @@ -1,129 +1,106 @@ --- title: Uint8ClampedArray slug: Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray -tags: - - Constructor - - JavaScript - - Reference - - TypedArray - - TypedArrays - - Uint8ClampedArray translation_of: Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray original_slug: Web/JavaScript/Reference/Objets_globaux/Uint8ClampedArray +browser-compat: javascript.builtins.Uint8ClampedArray --- {{JSRef}} Le tableau typé **`Uint8ClampedArray`** permet de représenter un tableau d'entiers non signés représentés sur 8 bits, dont les valeurs sont ramenées entre 0 et 255. Si une valeur non-entière est fournie, elle sera arrondie à l'entier le plus proche. Les éléments du tableau sont initialisés à `0`. Une fois que le tableau est construit, on peut manipuler ses différents éléments grâce aux méthodes de l'objet ou grâce à la notation usuelle (avec les crochets). -## Syntaxe +## Constructeur - new Uint8ClampedArray(); // apparu avec ES2017 - new Uint8ClampedArray(longueur); - new Uint8ClampedArray(tableauTypé); - new Uint8ClampedArray(objet); - new Uint8ClampedArray(tampon [, décalage [, longueur]]); +- [`Uint8ClampedArray()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray/Uint8ClampedArray) + - : Crée un nouvel objet `Uint8ClampedArray`. -Pour plus d'informations sur la syntaxe du constructeur et le rôle des différents paramètres, voir la page _[TypedArray](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Syntaxe)_. +## Propriétés statiques -## Propriétés +- [`Uint8ClampedArray.BYTES_PER_ELEMENT`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/BYTES_PER_ELEMENT) + - : Cette propriété renvoie la taille d'un élément du tableau, en octets. En l'occurrence, pour `Uint8ClampedArray` ce sera `1`. +- [`Uint8ClampedArray.name`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/name) + - : Cette propriété renvoie la chaîne de caractères correspondant au nom du constructeur. Pour `Uint8ClampedArray` ce sera : "`Uint8ClampedArray`". -- {{jsxref("TypedArray.BYTES_PER_ELEMENT", "Uint8ClampedArray.BYTES_PER_ELEMENT")}} - - : Cette propriété renvoie la taille d'un élément du tableau, en octets. En l'occurence, pour `Uint8ClampedArray` ce sera `1`. -- Uint8ClampedArray.length - - : La propriété de longueur statique qui vaut 3. Pour connaître le nombre d'éléments, voir {{jsxref("TypedArray.prototype.length", "Uint8ClampedArray.prototype.length")}}. -- {{jsxref("TypedArray.name", "Uint8ClampedArray.name")}} - - : Cette propriété renvoie la chaîne de caractères correspondant au nom du constructeur. Pour `Uint8ClampedArray` ce sera : "Uint8ClampedArray". -- {{jsxref("TypedArray.prototype", "Uint8ClampedArray.prototype")}} - - : Le prototype des objets _TypedArray_. +## Méthodes statiques -## Méthodes +- [`Uint8ClampedArray.from()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from) + - : Cette méthode permet de créer un nouvel objet `Uint8ClampedArray` à partir d'un itérable ou d'un objet semblable à un tableau. Voir aussi [`Array.from()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/from). +- [`Uint8ClampedArray.of()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of) + - : Cette méthode permet de créer un nouvel objet `Uint8ClampedArray` à partir d'un nombre variable d'arguments. Voir aussi [`Array.of()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/of). -- {{jsxref("TypedArray.from", "Uint8ClampedArray.from()")}} - - : Cette méthode permet de créer un nouvel objet `Uint8ClampedArray` à partir d'un itérable ou d'un objet semblable à un tableau. Voir aussi {{jsxref("Array.from()")}}. -- {{jsxref("TypedArray.of", "Uint8ClampedArray.of()")}} - - : Cette méthode permet de créer un nouvel objet `Uint8ClampedArray` à partir d'un nombre variable d'arguments. Voir aussi {{jsxref("Array.of()")}}. +## Propriétés des instances -## Prototype `Uint8ClampedArray` - -Tous les objets `Uint8ClampedArray` héritent de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}. - -### Propriétés - -- `Uint8ClampedArray.prototype.constructor` - - : Cette propriété renvoie la fonction qui a créé l'instance du prototype. Par défaut, ce sera le constructeur `Uint8ClampedArray`. -- {{jsxref("TypedArray.prototype.buffer", "Uint8ClampedArray.prototype.buffer")}} {{readonlyInline}} - - : Cette propriété renvoie l'objet {{jsxref("ArrayBuffer")}} référencé par l'objet `Uint8ClampedArray` Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. -- {{jsxref("TypedArray.prototype.byteLength", "Uint8ClampedArray.prototype.byteLength")}} {{readonlyInline}} - - : Cette propriété renvoie la longueur, exprimée en octets, de l'objet `Uint8ClampedArray` à partir du début de l'objet {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. -- {{jsxref("TypedArray.prototype.byteOffset", "Uint8ClampedArray.prototype.byteOffset")}} {{readonlyInline}} - - : Cette propriété renvoie le décalage, en nombre d'octets, entre le début du tableau typé courant et du début du {{jsxref("ArrayBuffer")}} correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. -- {{jsxref("TypedArray.prototype.length", "Uint8ClampedArray.prototype.length")}} {{readonlyInline}} +- [`Uint8ClampedArray.prototype.buffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer) + - : Cette propriété renvoie l'objet [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) référencé par l'objet `Uint8ClampedArray`. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. +- [`Uint8ClampedArray.prototype.byteLength`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength) + - : Cette propriété renvoie la longueur, exprimée en octets, de l'objet `Uint8ClampedArray` à partir du début de l'objet [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. +- [`Uint8ClampedArray.prototype.byteOffset`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset) + - : Cette propriété renvoie le décalage, en nombre d'octets, entre le début du tableau typé courant et du début du [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. +- [`Uint8ClampedArray.prototype.length`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length) - : Cette propriété renvoie le nombre d'éléments contenus dans le tableau `Uint8ClampedArray`. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**. -### Méthodes - -- {{jsxref("TypedArray.copyWithin", "Uint8ClampedArray.prototype.copyWithin()")}} - - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également {{jsxref("Array.prototype.copyWithin()")}}. -- {{jsxref("TypedArray.entries", "Uint8ClampedArray.prototype.entries()")}} - - : Renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau. Voir également {{jsxref("Array.prototype.entries()")}}. -- {{jsxref("TypedArray.every", "Uint8ClampedArray.prototype.every()")}} - - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.every()")}}. -- {{jsxref("TypedArray.fill", "Uint8ClampedArray.prototype.fill()")}} - - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également {{jsxref("Array.prototype.fill()")}}. -- {{jsxref("TypedArray.filter", "Uint8ClampedArray.prototype.filter()")}} - - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également {{jsxref("Array.prototype.filter()")}}. -- {{jsxref("TypedArray.find", "Uint8ClampedArray.prototype.find()")}} - - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également {{jsxref("Array.prototype.find()")}}. -- {{jsxref("TypedArray.findIndex", "Uint8ClampedArray.prototype.findIndex()")}} - - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également {{jsxref("Array.prototype.findIndex()")}}. -- {{jsxref("TypedArray.forEach", "Uint8ClampedArray.prototype.forEach()")}} - - : Appelle une fonction pour chacun des élément du tableau. Voir également {{jsxref("Array.prototype.forEach()")}}. -- {{jsxref("TypedArray.includes", "Uint8ClampedArray.prototype.includes()")}} - - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également {{jsxref("Array.prototype.includes()")}}. -- {{jsxref("TypedArray.indexOf", "Uint8ClampedArray.prototype.indexOf()")}} - - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.indexOf()")}}. -- {{jsxref("TypedArray.join", "Uint8ClampedArray.prototype.join()")}} - - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également {{jsxref("Array.prototype.join()")}}. -- {{jsxref("TypedArray.keys", "Uint8ClampedArray.prototype.keys()")}} - - : Renvoie un nouvel objet `Array Iterator` qui contient les clés de chaque indice du tableau. Voir également {{jsxref("Array.prototype.keys()")}}. -- {{jsxref("TypedArray.lastIndexOf", "Uint8ClampedArray.prototype.lastIndexOf()")}} - - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également {{jsxref("Array.prototype.lastIndexOf()")}}. -- {{jsxref("TypedArray.map", "Uint8ClampedArray.prototype.map()")}} - - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également {{jsxref("Array.prototype.map()")}}. -- {{jsxref("TypedArray.move", "Uint8ClampedArray.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}} - - : Ancienne version, non-standard, de {{jsxref("TypedArray.copyWithin", "Uint8ClampedArray.prototype.copyWithin()")}}. -- {{jsxref("TypedArray.reduce", "Uint8ClampedArray.prototype.reduce()")}} - - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduce()")}}. -- {{jsxref("TypedArray.reduceRight", "Uint8ClampedArray.prototype.reduceRight()")}} - - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également {{jsxref("Array.prototype.reduceRight()")}}. -- {{jsxref("TypedArray.reverse", "Uint8ClampedArray.prototype.reverse()")}} - - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également {{jsxref("Array.prototype.reverse()")}}. -- {{jsxref("TypedArray.set", "Uint8ClampedArray.prototype.set()")}} +## Méthodes des instances + +- [`Uint8ClampedArray.prototype.copyWithin()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin) + - : Copie une suite d'éléments d'un tableau dans le tableau. Voir également [`Array.prototype.copyWithin()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin). +- [`Uint8ClampedArray.prototype.entries()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries) + - : Renvoie un nouvel *itérateur de tableau* qui contient les paires clé/valeur pour chaque indice du tableau. Voir également [`Array.prototype.entries()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/entries). +- [`Uint8ClampedArray.prototype.every()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every) + - : Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également [`Array.prototype.every()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/every). +- [`Uint8ClampedArray.prototype.fill()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill) + - : Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également [`Array.prototype.fill()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/fill). +- [`Uint8ClampedArray.prototype.filter()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter) + - : Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également [`Array.prototype.filter()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/filter). +- [`Uint8ClampedArray.prototype.find()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find) + - : Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également [`Array.prototype.find()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/find). +- [`Uint8ClampedArray.prototype.findIndex()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex) + - : Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition `-1` sera renvoyé. Voir également [`Array.prototype.findIndex()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex). +- [`Uint8ClampedArray.prototype.forEach()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach) + - : Appelle une fonction pour chacun des éléments du tableau. Voir également [`Array.prototype.forEach()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach). +- [`Uint8ClampedArray.prototype.includes()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes) + - : Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également [`Array.prototype.includes()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/includes). +- [`Uint8ClampedArray.prototype.indexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf) + - : Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur `-1` sera renvoyée. Voir également [`Array.prototype.indexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf). +- [`Uint8ClampedArray.prototype.join()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join) + - : Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également [`Array.prototype.join()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/join). +- [`Uint8ClampedArray.prototype.keys()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys) + - : Renvoie un nouvel *itérateur de tableau* qui contient les clés de chaque indice du tableau. Voir également [`Array.prototype.keys()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/keys). +- [`Uint8ClampedArray.prototype.lastIndexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf) + - : Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur `-1` sera renvoyée. Voir également [`Array.prototype.lastIndexOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf). +- [`Uint8ClampedArray.prototype.map()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map) + - : Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également [`Array.prototype.map()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/map). +- [`Uint8ClampedArray.prototype.reduce()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce) + - : Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également [`Array.prototype.reduce()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce). +- [`Uint8ClampedArray.prototype.reduceRight()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight) + - : Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également [`Array.prototype.reduceRight()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight). +- [`Uint8ClampedArray.prototype.reverse()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse) + - : Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également [`Array.prototype.reverse()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse). +- [`Uint8ClampedArray.prototype.set()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set) - : Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau. -- {{jsxref("TypedArray.slice", "Uint8ClampedArray.prototype.slice()")}} - - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également {{jsxref("Array.prototype.slice()")}}. -- {{jsxref("TypedArray.some", "Uint8ClampedArray.prototype.some()")}} - - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également {{jsxref("Array.prototype.some()")}}. -- {{jsxref("TypedArray.sort", "Uint8ClampedArray.prototype.sort()")}} - - : Trie les éléments du tableau et renvoie ce tableau. Voir également {{jsxref("Array.prototype.sort()")}}. -- {{jsxref("TypedArray.subarray", "Uint8ClampedArray.prototype.subarray()")}} +- [`Uint8ClampedArray.prototype.slice()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) + - : Extrait un fragment d'un tableau et renvoie ce fragment. Voir également [`Array.prototype.slice()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). +- [`Uint8ClampedArray.prototype.some()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some) + - : Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également [`Array.prototype.some()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/some). +- [`Uint8ClampedArray.prototype.sort()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort) + - : Trie les éléments du tableau et renvoie ce tableau. Voir également [`Array.prototype.sort()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/sort). +- [`Uint8ClampedArray.prototype.subarray()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) - : Renvoie un nouvel objet `Uint8ClampedArray` qui est le fragment du tableau courant, entre les indices de début et de fin donnés. -- {{jsxref("TypedArray.values", "Uint8ClampedArray.prototype.values()")}} - - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. Voir également {{jsxref("Array.prototype.values()")}}. -- {{jsxref("TypedArray.toLocaleString", "Uint8ClampedArray.prototype.toLocaleString()")}} - - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toLocaleString()")}}. -- {{jsxref("TypedArray.toString", "Uint8ClampedArray.prototype.toString()")}} - - : Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également {{jsxref("Array.prototype.toString()")}}. -- {{jsxref("TypedArray.@@iterator", "Uint8ClampedArray.prototype[@@iterator]()")}} - - : Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. +- [`Uint8ClampedArray.prototype.values()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values) + - : Renvoie un nouvel *itérateur de tableau* qui contient les valeurs correspondantes à chaque indice du tableau. Voir également [`Array.prototype.values()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/values). +- [`Uint8ClampedArray.prototype.toLocaleString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString) + - : Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également [`Array.prototype.toLocaleString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString). +- [`Uint8ClampedArray.prototype.toString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString) + - : Renvoie une chaîne de caractères qui représente le tableau et ses éléments. Voir également [`Array.prototype.toString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/toString). +- [`Uint8ClampedArray.prototype[@@iterator]()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/@@iterator) + - : Renvoie un nouvel *itérateur de tableau* qui contient les valeurs correspondantes à chaque indice du tableau. ## Exemples -Différentes façon de créer un objet `Uint8ClampedArray` : +### Différentes façons de créer un objet `Uint8ClampedArray` ```js // Construction à partir d'une longueur -var uintc8 = new Uint8ClampedArray(2); +let uintc8 = new Uint8ClampedArray(2); uintc8[0] = 42; uintc8[1] = 1337; console.log(uintc8[0]); // 42 @@ -132,52 +109,35 @@ console.log(uintc8.length); // 2 console.log(uintc8.BYTES_PER_ELEMENT); // 1 // Construction à partir d'un tableau -var arr = new Uint8ClampedArray([21,31]); +let arr = new Uint8ClampedArray([21,31]); console.log(arr[1]); // 31 // Construction à partir d'un autre TypedArray -var x = new Uint8ClampedArray([21, 31]); -var y = new Uint8ClampedArray(x); +let x = new Uint8ClampedArray([21, 31]); +let y = new Uint8ClampedArray(x); console.log(y[0]); // 21 // Construction à partir d'un ArrayBuffer -var buffer = new ArrayBuffer(8); -var z = new Uint8ClampedArray(buffer, 1, 4); +let buffer = new ArrayBuffer(8); +let z = new Uint8ClampedArray(buffer, 1, 4); // Construction à partir d'un itérable -var iterable = function*(){ yield* [1,2,3]; }(); -var uintc8 = new Uint8ClampedArray(iterable); +let iterable = function*(){ yield* [1,2,3]; }(); +let uintc8 = new Uint8ClampedArray(iterable); // Uint8ClampedArray[1, 2, 3] ``` ## Spécifications -| Spécification | Statut | Commentaires | -| ------------------------------------------------------------------------------------ | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | -| {{SpecName('Typed Array')}} | {{Spec2('Typed Array')}} | Englobée par ECMAScript 2015 | -| {{SpecName('ES6', '#table-49', 'TypedArray constructors')}} | {{Spec2('ES6')}} | Définition initiale au sein d'un standard ECMA. `new` est obligatoire. | -| {{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}} | {{Spec2('ESDraft')}} | ECMAScript 2017 a modifié le constructeur `Uint8ClampedArray` afin qu'il utilise l'opération `ToIndex` et qu'il puisse être utilisé sans argument. | +{{Specifications}} ## Compatibilité des navigateurs -{{Compat("javascript.builtins.Uint8ClampedArray")}} - -## Notes de compatibilité - -À partir d'ECMAScript 2015 (ES6), `Uint8ClampedArray` doit être utilisé avec {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Appeler `Uint8ClampedArray` comme une fonction, sans `new`, provoquera une exception {{jsxref("TypeError")}}. - -```js example-bad -var dv = Uint8ClampedArray([1, 2, 3]); -// TypeError: calling a builtin Uint8ClampedArray constructor -// without new is forbidden -``` - -```js example-good -var dv = new Uint8ClampedArray([1, 2, 3]); -``` +{{Compat}} ## Voir aussi -- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés) -- {{jsxref("ArrayBuffer")}} -- {{jsxref("DataView")}} +- [Une prothèse d'émulation (<i lang="en">polyfill</i>) pour `Uint8ClampedArray` avec `core-js`](https://github.com/zloirock/core-js#ecmascript-typed-arrays) +- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Typed_arrays) +- [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) +- [`DataView`](/fr/docs/Web/JavaScript/Reference/Global_Objects/DataView) diff --git a/files/fr/web/javascript/reference/global_objects/uint8clampedarray/uint8clampedarray/index.md b/files/fr/web/javascript/reference/global_objects/uint8clampedarray/uint8clampedarray/index.md new file mode 100644 index 0000000000..9974741dca --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/uint8clampedarray/uint8clampedarray/index.md @@ -0,0 +1,95 @@ +--- +title: Constructeur Uint8ClampedArray() +slug: Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray/Uint8ClampedArray +translation_of: Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray/Uint8ClampedArray +browser-compat: javascript.builtins.Uint8ClampedArray.Uint8ClampedArray +--- +{{JSRef}} + +Le constructeur **`Uint8ClampedArray()`** permet de créer un tableau typé contenant des entiers non-signés sur 8 bits, dont la valeur est ramenée entre 0 et 255. Une valeur indiquée, en dehors de cet intervalle, sera écrêtée. Une valeur non entière sera arrondie à l'entier le plus proche. Le contenu d'un tel tableau est initialisé avec des `0`. Une fois le tableau construit, on peut faire référence aux éléments du tableau à l'aide des méthodes de l'objet ou en utilisant la notation usuelle pour les tableaux avec les crochets. + +## Syntaxe + +```js +new Uint8ClampedArray(); // apparu avec ES2017 +new Uint8ClampedArray(longueur); +new Uint8ClampedArray(tableauType); +new Uint8ClampedArray(objet); + +new Uint8ClampedArray(buffer); +new Uint8ClampedArray(buffer, decalageOctets); +new Uint8ClampedArray(buffer, decalageOctets, longueur); +``` + +### Paramètres + +- `longueur` + - : Lorsque le constructeur est invoqué avec un argument indiquant une longueur, un tampon de mémoire interne tabulé est créé, dont la taille en octets est `longueur` _multipliée par `BYTES_PER_ELEMENT`_, et qui contient des zéros. +- `tableauType` + - : Lorsque le constructeur est invoqué avec un tableau typé comme argument (tout tableau typé en dehors des tableaux typés [`bigint`](/fr/docs/Glossary/BigInt) tel que [`Int32Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Int32Array)), ce tableau typé est copié dans un nouveau tableau typé. Chaque valeur de `tableauType` est convertie dans le type correspondant au constructeur avant d'être copiée dans le nouveau tableau. La longueur du nouveau tableau typé sera la même que celle de `tableauType`. +- `objet` + - : Lorsque le constructeur est appelé avec un objet comme argument, le nouveau tableau typé est créé avec la méthode `TypedArray.from()`. +- `buffer`, `decalageOctets`, `longueur` + - : Lorsque le constructeur est invoqué avec un tampon, éventuellement un décalage en octets et une longueur, une nouvelle vue en tableau typé est créée qui reflète l'objet [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) correspondant. Les paramètres `decalageOctets` et `longueur` indique l'intervalle de mémoire exposé à la vue. Si ces deux paramètres sont absents, c'est l'intégralité du tampon qui est vue. Si la longueur est absente, c'est la portion du tampon, après le décalage indiqué, qui est vue. + +## Exemples + +### Différentes façons de créer un objet `Uint8ClampedArray` + +```js +// À partir d'une longueur +let uintc8 = new Uint8ClampedArray(2); +uintc8[0] = 42; +uintc8[1] = 1337; +console.log(uintc8[0]); // 42 +console.log(uintc8[1]); // 255 (écrétée) +console.log(uintc8.length); // 2 +console.log(uintc8.BYTES_PER_ELEMENT); // 1 + +// À partir d'un tableau +let arr = new Uint8ClampedArray([21,31]); +console.log(arr[1]); // 31 + +// À partir d'un autre tableau typé +let x = new Uint8ClampedArray([21, 31]); +let y = new Uint8ClampedArray(x); +console.log(y[0]); // 21 + +// À partir d'un ArrayBuffer +let buffer = new ArrayBuffer(8); +let z = new Uint8ClampedArray(buffer, 1, 4); + +// À partir d'un itérable +let iterable = function*(){ yield* [1,2,3]; }(); +let uintc8 = new Uint8ClampedArray(iterable); +// Uint8ClampedArray[1, 2, 3] +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +### Notes de compatibilité + +À partir d'ECMAScript 2015, le constructeur `Uint8ClampedArray` doit être appelé avec l'opérateur [`new`](/fr/docs/Web/JavaScript/Reference/Operators/new). Invoquer le constructeur `Uint8ClampedArray` comme une fonction, sans `new`, déclenchera une exception [`TypeError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypeError). + +```js example-bad +let dv = Uint8ClampedArray([1, 2, 3]); +// TypeError: calling a builtin Uint8ClampedArray +// constructor without new is forbidden +``` + +```js example-good +let dv = new Uint8ClampedArray([1, 2, 3]); +``` + +## Voir aussi + +- [Une prothèse d'émulation (<i lang="en">polyfill</i>) pour `Uint8ClampedArray` avec `core-js`](https://github.com/zloirock/core-js#ecmascript-typed-arrays) +- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Typed_arrays) +- [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) +- [`DataView`](/fr/docs/Web/JavaScript/Reference/Global_Objects/DataView) diff --git a/files/fr/web/javascript/reference/operators/operator_precedence/index.md b/files/fr/web/javascript/reference/operators/operator_precedence/index.md index 367e9624fb..dabf2bb2a5 100644 --- a/files/fr/web/javascript/reference/operators/operator_precedence/index.md +++ b/files/fr/web/javascript/reference/operators/operator_precedence/index.md @@ -44,7 +44,7 @@ avec le résultat attendu que `a` et `b` obtiennent la même valeur de 5. C'est ## Tableau -Le tableau suivant est classé de la plus haute (0) à la plus basse (19) précédence. +Le tableau suivant est classé de la plus haute (19) à la plus basse (1) précédence. <table class="fullwidth-table"> <tbody> @@ -55,9 +55,9 @@ Le tableau suivant est classé de la plus haute (0) à la plus basse (19) précà <th>Opérateurs individuels</th> </tr> <tr> - <td>0</td> + <td>19</td> <td> - <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Groupement" + <a href="/fr/docs/Web/JavaScript/Reference/Operators/Grouping" >Groupement</a > </td> @@ -65,31 +65,30 @@ Le tableau suivant est classé de la plus haute (0) à la plus basse (19) précà <td><code>( … )</code></td> </tr> <tr> - <td colspan="1" rowspan="5">1</td> + <td colspan="1" rowspan="5">18</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres#Notation_avec_point" + href="/fr/docs/Web/JavaScript/Reference/Operators/Property_Accessors#notation_avec_point" >Accès à un membre</a > </td> - <td>Gauche à droite</td> + <td rowspan="2">Gauche à droite</td> <td><code>… . …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres#Notation_avec_crochets" + href="/fr/docs/Web/JavaScript/Reference/Operators/Property_Accessors#notation_avec_crochets" >Accès à un membre calculé</a > </td> - <td>Gauche à droite</td> <td><code>… [ … ]</code></td> </tr> <tr> <td> <code ><a - href="/fr/docs/JavaScript/Reference/R%C3%A9f%C3%A9rence_JavaScript/Op%C3%A9rateurs/Op%C3%A9rateurs_sp%C3%A9ciaux/L'op%C3%A9rateur_new" + href="/fr/docs/Web/JavaScript/Reference/Operators/new" >new</a ></code > @@ -100,9 +99,9 @@ Le tableau suivant est classé de la plus haute (0) à la plus basse (19) précà </tr> <tr> <td> - <a href="/fr/docs/Web/JavaScript/Guide/Fonctions">Appel de fonction</a> + <a href="/fr/docs/Web/JavaScript/Guide/Functions">Appel de fonction</a> </td> - <td>Gauche à droite</td> + <td rowspan="2">Gauche à droite</td> <td> <code>… ( <var>… </var>)</code> </td> @@ -113,15 +112,14 @@ Le tableau suivant est classé de la plus haute (0) à la plus basse (19) précà >Chaînage optionnel</a > </td> - <td>Gauche à droite</td> <td><code>?.</code></td> </tr> <tr> - <td>2</td> + <td>17</td> <td> <code ><a - href="/fr/docs/JavaScript/Reference/R%C3%A9f%C3%A9rence_JavaScript/Op%C3%A9rateurs/Op%C3%A9rateurs_sp%C3%A9ciaux/L'op%C3%A9rateur_new" + href="/fr/docs/Web/JavaScript/Reference/Operators/new" >new</a ></code > @@ -131,393 +129,379 @@ Le tableau suivant est classé de la plus haute (0) à la plus basse (19) précà <td><code>new …</code></td> </tr> <tr> - <td rowspan="2">3</td> + <td rowspan="2">16</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Incr.C3.A9ment_(.2B.2B)" + href="/fr/docs/Web/JavaScript/Reference/Operators#incrémentation_et_décrémentation" >Incrémentation suffixe</a > </td> - <td>Non applicable</td> + <td rowspan="2">Non applicable</td> <td><code>… ++</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#D.C3.A9cr.C3.A9ment_(--)" + href="/fr/docs/Web/JavaScript/Reference/Operators#incrémentation_et_décrémentation" >Décrémentation suffixe</a > </td> - <td>Non applicable</td> <td><code>… --</code></td> </tr> <tr> - <td colspan="1" rowspan="10">4</td> + <td colspan="1" rowspan="10">15</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques#Logical_NOT_.28.21.29" - >NON logique</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_NOT" + >NON logique (!)</a > </td> - <td>Droite à gauche</td> + <td rowspan="10">Droite à gauche</td> <td><code>! …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.7E_.28NON_binaire.29" - >NON binaire</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_NOT" + >NON binaire (~)</a > </td> - <td>Droite à gauche</td> <td><code>~ …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Plus_unaire_(.2B)" - >Plus unaire</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_plus" + >Plus unaire (+)</a > </td> - <td>Droite à gauche</td> <td><code>+ …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#N.C3.A9gation_unaire_(-)" - >Négation unaire</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Unary_negation" + >Négation unaire (-)</a > </td> - <td>Droite à gauche</td> <td><code>- …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Incr.C3.A9ment_(.2B.2B)" + href="/fr/docs/Web/JavaScript/Reference/Operators#incrémentation_et_décrémentation" >Incrémentation préfixe</a > </td> - <td>Droite à gauche</td> <td><code>++ …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#D.C3.A9cr.C3.A9ment_(--)" + href="/fr/docs/Web/JavaScript/Reference/Operators#incrémentation_et_décrémentation" >Décrémentation préfixe</a > </td> - <td>Droite à gauche</td> <td><code>-- …</code></td> </tr> <tr> <td> <code ><a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof" + href="/fr/docs/Web/JavaScript/Reference/Operators/typeof" >typeof</a ></code > </td> - <td>Droite à gauche</td> <td><code>typeof …</code></td> </tr> <tr> <td> <code ><a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_void" + href="/fr/docs/Web/JavaScript/Reference/Operators/void" >void</a ></code > </td> - <td>Droite à gauche</td> <td><code>void …</code></td> </tr> <tr> <td> <code ><a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete" + href="/fr/docs/Web/JavaScript/Reference/Operators/delete" >delete</a ></code > </td> - <td>Droite à gauche</td> <td><code>delete …</code></td> </tr> <tr> <td> <code - ><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/await" + ><a href="/fr/docs/Web/JavaScript/Reference/Operators/await" >await</a ></code > </td> - <td>Droite à gauche</td> <td><code>await …</code></td> </tr> <tr> - <td rowspan="4">5</td> + <td>14</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Exponentiation_(**)" - >Exponentiation</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Exponentiation" + >Exponentiation (**)</a > </td> <td>Droite à gauche</td> <td><code>… ** …</code></td> </tr> <tr> + <td rowspan="3">13</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Multiplication_(*)" - >Multiplication</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Multiplication" + >Multiplication (*)</a > </td> - <td>Gauche à droite</td> + <td rowspan="3">Gauche à droite</td> <td><code>… * …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Division_(.2F)" - >Division</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Division" + >Division (/)</a > </td> - <td>Gauche à droite</td> <td><code>… / …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Reste_(.25)" - >Reste</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Remainder" + >Reste (%)</a > </td> - <td>Gauche à droite</td> <td><code>… % …</code></td> </tr> <tr> - <td rowspan="2">6</td> + <td rowspan="2">12</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Addition_(.2B)" - >Addition</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Addition" + >Addition (+)</a > </td> - <td>Gauche à droite</td> + <td rowspan="2">Gauche à droite</td> <td><code>… + …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Soustraction_(-)" - >Soustraction</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Subtraction" + >Soustraction (-)</a > </td> - <td>Gauche à droite</td> <td><code>… - …</code></td> </tr> <tr> - <td rowspan="3">7</td> + <td rowspan="3">11</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.3C.3C_.28d.C3.A9calage_.C3.A0_gauche.29" - >Décalage binaire à gauche</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Left_shift" + >Décalage binaire à gauche (<<)</a > </td> - <td>Gauche à droite</td> + <td rowspan="3">Gauche à droite</td> <td><code>… << …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_propagation_du_signe.29" - >Décalage binaire à droite</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Right_shift" + >Décalage binaire à droite (>>)</a > </td> - <td>Gauche à droite</td> <td><code>… >> …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.3E.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_insertion_de_z.C3.A9ros.29" - >Décalage binaire à droite non-signé</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift" + >Décalage binaire à droite non-signé (>>>)</a > </td> - <td>Gauche à droite</td> <td><code>… >>> …</code></td> </tr> <tr> - <td rowspan="6">8</td> + <td rowspan="6">10</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#Inf.C3.A9rieur_strict_(<)" - >Inférieur strict</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than" + >Inférieur strict (<)</a > </td> - <td>Gauche à droite</td> + <td rowspan="6">Gauche à droite</td> <td><code>… < …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#Inf.C3.A9rieur_ou_.C3.A9gal_(<.3D)" - >Inférieur ou égal</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal" + >Inférieur ou égal (<=)</a > </td> - <td>Gauche à droite</td> <td><code>… <= …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#Sup.C3.A9rieur_strict_(>)" - >Supérieur strict</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than" + >Supérieur strict (>)</a > </td> - <td>Gauche à droite</td> <td><code>… > …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#Sup.C3.A9rieur_ou_.C3.A9gal_(>.3D)" - >Supérieur ou égal</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal" + >Supérieur ou égal (>=)</a > </td> - <td>Gauche à droite</td> <td><code>… >= …</code></td> </tr> <tr> <td> <code - ><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in" + ><a href="/fr/docs/Web/JavaScript/Reference/Operators/in" >in</a ></code > </td> - <td>Gauche à droite</td> <td><code>… in …</code></td> </tr> <tr> <td> <code ><a - href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/instanceof" + href="/fr/docs/Web/JavaScript/Reference/Operators/instanceof" >instanceof</a ></code > </td> - <td>Gauche à droite</td> <td><code>… instanceof …</code></td> </tr> <tr> <td rowspan="4">9</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_simple_(.3D.3D)" - >Égalité faible</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Equality" + >Égalité faible (==)</a > </td> - <td>Gauche à droite</td> + <td rowspan="4">Gauche à droite</td> <td><code>… == …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#In.C3.A9galit.C3.A9_simple_(!.3D)" - >Inégalité faible</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Inequality" + >Inégalité faible (!=)</a > </td> - <td>Gauche à droite</td> <td><code>… != …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)" - >Égalité stricte</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality" + >Égalité stricte (===)</a > </td> - <td>Gauche à droite</td> <td><code>… === …</code></td> </tr> <tr> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#In.C3.A9galit.C3.A9_stricte_(!.3D.3D)" - >Inégalité stricte</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality" + >Inégalité stricte (!==)</a > </td> - <td>Gauche à droite</td> <td><code>… !== …</code></td> </tr> <tr> - <td>10</td> + <td>8</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#&_.28ET_binaire.29" - >ET binaire</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_AND" + >ET binaire (&)</a > </td> <td>Gauche à droite</td> <td><code>… & …</code></td> </tr> <tr> - <td>11</td> + <td>7</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#.5E_.28XOR_binaire.29" - >OU exclusif (<em>XOR</em>) binaire</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_XOR" + >OU exclusif / XOR binaire (^)</a > </td> <td>Gauche à droite</td> <td><code>… ^ …</code></td> </tr> <tr> - <td>12</td> + <td>6</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(OU_binaire)" - title="JavaScript/Reference/Operators/Bitwise_Operators" - >OU binaire</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Bitwise_OR" + >OU binaire (|)</a > </td> <td>Gauche à droite</td> <td><code>… | …</code></td> </tr> <tr> - <td>13</td> + <td>5</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques#Logical_AND_.28&&.29" - >ET logique</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_AND" + >ET logique (&&)</a > </td> <td>Gauche à droite</td> <td><code>… && …</code></td> </tr> <tr> - <td>14</td> + <td rowspan="2">4</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques#OU_logique_(.7C.7C)" - >OU logique</a + href="/fr/docs/Web/JavaScript/Reference/Operators/Logical_OR" + >OU logique (||)</a > </td> - <td>Gauche à droite</td> + <td rowspan="2">Gauche à droite</td> <td><code>… || …</code></td> </tr> <tr> - <td>15</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_conditionnel" + href="/fr/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator" + >Coalescence des nuls (??)</a + > + </td> + <td><code>… ?? …</code></td> + </tr> + <tr> + <td>3</td> + <td> + <a + href="/fr/docs/Web/JavaScript/Reference/Operators/Conditional_Operator" >Opérateur conditionnel ternaire</a > </td> @@ -525,14 +509,14 @@ Le tableau suivant est classé de la plus haute (0) à la plus basse (19) précà <td><code>… ? … : …</code></td> </tr> <tr> - <td rowspan="13">16</td> - <td rowspan="13"> + <td rowspan="18">2</td> + <td rowspan="16"> <a - href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_d_affectation" + href="/fr/docs/Web/JavaScript/Reference/Operators#opérateurs_daffectation" >Affectation</a > </td> - <td rowspan="13">Droite à gauche</td> + <td rowspan="16">Droite à gauche</td> <td><code>… = …</code></td> </tr> <tr> @@ -542,13 +526,13 @@ Le tableau suivant est classé de la plus haute (0) à la plus basse (19) précà <td><code>… -= …</code></td> </tr> <tr> - <td><code>… *= …</code></td> + <td><code>… **= …</code></td> </tr> <tr> - <td><code>… /= …</code></td> + <td><code>… *= …</code></td> </tr> <tr> - <td><code>… **= …</code></td> + <td><code>… /= …</code></td> </tr> <tr> <td><code>… %= …</code></td> @@ -572,44 +556,40 @@ Le tableau suivant est classé de la plus haute (0) à la plus basse (19) précà <td><code>… |= …</code></td> </tr> <tr> - <td colspan="1" rowspan="2">17</td> + <td><code>… &&= …</code></td> + </tr> + <tr> + <td><code>… ||= …</code></td> + </tr> + <tr> + <td><code>… ??= …</code></td> + </tr> + <tr> <td> <code - ><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/yield" + ><a href="/fr/docs/Web/JavaScript/Reference/Operators/yield" >yield</a ></code > </td> - <td>Droite à gauche</td> + <td rowspan="2">Droite à gauche</td> <td><code>yield …</code></td> </tr> <tr> <td> <code - ><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/yield*" + ><a href="/fr/docs/Web/JavaScript/Reference/Operators/yield*" >yield*</a ></code > </td> - <td>Droite à gauche</td> <td><code>yield* …</code></td> </tr> <tr> - <td>18</td> - <td> - <a - href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition" - >Décomposition</a - > - </td> - <td>Non applicable</td> - <td><code>...</code> …</td> - </tr> - <tr> - <td>19</td> + <td>1</td> <td> <a - href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_virgule" + href="/fr/docs/Web/JavaScript/Reference/Operators/Comma_Operator" >Virgule</a > </td> |