From 714b5ba2345f4938891fc6d3f5a2fee2f7f41d54 Mon Sep 17 00:00:00 2001 From: KoukiFactori <30896120+DieuKoukiFactori@users.noreply.github.com> Date: Mon, 30 Mar 2020 22:04:58 +0200 Subject: [PATCH 1/9] ArrayBuffer --- .../01-arraybuffer-binary-arrays/article.md | 65 ++++++++++--------- 1 file changed, 33 insertions(+), 32 deletions(-) diff --git a/4-binary/01-arraybuffer-binary-arrays/article.md b/4-binary/01-arraybuffer-binary-arrays/article.md index b1d0bbb0d..86c1cd62c 100644 --- a/4-binary/01-arraybuffer-binary-arrays/article.md +++ b/4-binary/01-arraybuffer-binary-arrays/article.md @@ -1,70 +1,71 @@ # ArrayBuffer, binary arrays -In web-development we meet binary data mostly while dealing with files (create, upload, download). Another typical use case is image processing. +Dans le développement web, nous rencontrons des données binaires principalement lorsque l'on travaille avec des fichiers (création, envoi, téléchargement). Un autre cas d'utilisation est le traitement d'image. -That's all possible in JavaScript, and binary operations are high-performant. +Tout ceci est possible en JavaScript, et les opérations binaires sont très performantes. -Although, there's a bit of confusion, because there are many classes. To name a few: +Cependant, il y a de la confusion, car il y a beaucoup de "classes". +Pour en nommer quelques unes: - `ArrayBuffer`, `Uint8Array`, `DataView`, `Blob`, `File`, etc. -Binary data in JavaScript is implemented in a non-standard way, compared to other languages. But when we sort things out, everything becomes fairly simple. +En javascript, les données binaires sont implémentées de façon non standard, comparé à d'autres langages. Mais quand nous trions les choses, tout devient beaucoup plus simple. -**The basic binary object is `ArrayBuffer` -- a reference to a fixed-length contiguous memory area.** +**L'objet binaire de base est un `ArrayBuffer` -- une référence à une zone contigu de taille fixe de la mémoire.** -We create it like this: +Nous le créons comme ceci: ```js run -let buffer = new ArrayBuffer(16); // create a buffer of length 16 +let buffer = new ArrayBuffer(16); // crée un Buffer de taille 16 alert(buffer.byteLength); // 16 ``` -This allocates a contiguous memory area of 16 bytes and pre-fills it with zeroes. +Cela alloue une zone contigue de 16 octets dans la mémoire et la pré-remplie avec des zéros. -```warn header="`ArrayBuffer` is not an array of something" -Let's eliminate a possible source of confusion. `ArrayBuffer` has nothing in common with `Array`: -- It has a fixed length, we can't increase or decrease it. -- It takes exactly that much space in the memory. -- To access individual bytes, another "view" object is needed, not `buffer[index]`. +```warn header="L'`ArrayBuffer` n'est pas un tableau de quelque chose." +Commençons par éliminer une possible source de confusion. `ArrayBuffer` n'a rien en commun avec `Array`: +- Il possède une taille fixe, on ne peut pas l'agrandir ou le reduire. +- Il prend exactement autant d'espace en mémoire. +- Pour accéder à des octets individuels, un autre objet de "vue" est nécessaire, on n'utilise pas `buffer[index]`. ``` -`ArrayBuffer` is a memory area. What's stored in it? It has no clue. Just a raw sequence of bytes. +`ArrayBuffer` est une zone de la mémoire. Qui y'a t'il à l'intérieur ? Juste une séquence d'octets. -**To manipulate an `ArrayBuffer`, we need to use a "view" object.** +**Pour manipuler un `ArrayBuffer`, nous avons besoin d'utiliser un objet de "vue".** -A view object does not store anything on it's own. It's the "eyeglasses" that give an interpretation of the bytes stored in the `ArrayBuffer`. +Un objet de "vue" de stocke rien tout seul. Ce sont les yeux qui donnent une interprétation des octets stockés dans l'`ArrayBuffer`. -For instance: +Par exemple: -- **`Uint8Array`** -- treats each byte in `ArrayBuffer` as a separate number, with possible values are from 0 to 255 (a byte is 8-bit, so it can hold only that much). Such value is called a "8-bit unsigned integer". -- **`Uint16Array`** -- treats every 2 bytes as an integer, with possible values from 0 to 65535. That's called a "16-bit unsigned integer". -- **`Uint32Array`** -- treats every 4 bytes as an integer, with possible values from 0 to 4294967295. That's called a "32-bit unsigned integer". -- **`Float64Array`** -- treats every 8 bytes as a floating point number with possible values from 5.0x10-324 to 1.8x10308. +- **`Uint8Array`** -- Traite chaque octet dans l'`ArrayBuffer` comme un nombre unique, avec des valeurs possibles entre 0 jusqu'à 255 (Un octet est sur 8 bits). On appelle ces valeurs des "entiers non signés sur 8 bits". +- **`Uint16Array`** -- Traite par paquet de 2 octets en tant qu'entier, avec des valeurs possibles entre 0 jusqu'à 65535. On appelle ces valeurs des "entiers non signés sur 16 bits". +- **`Uint32Array`** -- Traite par paquet de 4 octets en tant qu'entier, avec des valeurs possibles entre 0 jusqu'à 4294967295. On appelle ces valeurs des "entiers non signés sur 32bits". +- **`Float64Array`** -- Traite par paquet de 8 octets en tant que nombre flottant avec des valeurs possibles entre 5.0x10-324 et 1.8x10308. -So, the binary data in an `ArrayBuffer` of 16 bytes can be interpreted as 16 "tiny numbers", or 8 bigger numbers (2 bytes each), or 4 even bigger (4 bytes each), or 2 floating-point values with high precision (8 bytes each). +Donc, les données binaires dans un `ArrayBuffer` de 16 octets peuvent être interprétées comme 16 "petits nombres" , ou 8 grands nombres (2 octets chacun), ou 4 encore plus grands (4 octets chacun), ou 2 valeurs flottantes avec une haute précision (8 octets chacun). ![](arraybuffer-views.svg) -`ArrayBuffer` is the core object, the root of everything, the raw binary data. +`ArrayBuffer` est l'objet central, le centre de tout, les données binaires brutes. -But if we're going to write into it, or iterate over it, basically for almost any operation – we must use a view, e.g: +Mais si nous voulons écrire dessus, ou intérer dessus, pour n'importe quelle opération – nous devons utiliser une "vue", e.g: ```js run -let buffer = new ArrayBuffer(16); // create a buffer of length 16 +let buffer = new ArrayBuffer(16); // crée un buffer de taille 16 *!* -let view = new Uint32Array(buffer); // treat buffer as a sequence of 32-bit integers +let view = new Uint32Array(buffer); // Traite le buffer en une séquence d'entiers de 32 bits. -alert(Uint32Array.BYTES_PER_ELEMENT); // 4 bytes per integer +alert(Uint32Array.BYTES_PER_ELEMENT); // 4 octets par entier. */!* -alert(view.length); // 4, it stores that many integers -alert(view.byteLength); // 16, the size in bytes +alert(view.length); // 4, il stocke cette quantité d'entiers. +alert(view.byteLength); // 16, la taille en octets. -// let's write a value +// Ecrivons une valeur view[0] = 123456; -// iterate over values +// Itérons sur les valeurs for(let num of view) { - alert(num); // 123456, then 0, 0, 0 (4 values total) + alert(num); // 123456, then 0, 0, 0 (4 valeurs au total) } ``` From 5c1be0293bfc003c29b95610ea2409beef9a54d6 Mon Sep 17 00:00:00 2001 From: KoukiFactori <30896120+DieuKoukiFactori@users.noreply.github.com> Date: Thu, 30 Apr 2020 02:14:51 +0200 Subject: [PATCH 2/9] Starting TypedArray --- 4-binary/01-arraybuffer-binary-arrays/article.md | 15 +++++++-------- 4-binary/index.md | 4 ++-- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/4-binary/01-arraybuffer-binary-arrays/article.md b/4-binary/01-arraybuffer-binary-arrays/article.md index 86c1cd62c..605b86cb2 100644 --- a/4-binary/01-arraybuffer-binary-arrays/article.md +++ b/4-binary/01-arraybuffer-binary-arrays/article.md @@ -10,7 +10,7 @@ Pour en nommer quelques unes: En javascript, les données binaires sont implémentées de façon non standard, comparé à d'autres langages. Mais quand nous trions les choses, tout devient beaucoup plus simple. -**L'objet binaire de base est un `ArrayBuffer` -- une référence à une zone contigu de taille fixe de la mémoire.** +**L'objet binaire de base est un `ArrayBuffer` -- une référence à une zone contigüe de taille fixe de la mémoire.** Nous le créons comme ceci: ```js run @@ -20,9 +20,9 @@ alert(buffer.byteLength); // 16 Cela alloue une zone contigue de 16 octets dans la mémoire et la pré-remplie avec des zéros. -```warn header="L'`ArrayBuffer` n'est pas un tableau de quelque chose." +```warn header="L'`ArrayBuffer` n'est pas un tableau de 'quelque chose'." Commençons par éliminer une possible source de confusion. `ArrayBuffer` n'a rien en commun avec `Array`: -- Il possède une taille fixe, on ne peut pas l'agrandir ou le reduire. +- Il possède une taille fixe, on ne peut pas l'agrandir ou la reduire. - Il prend exactement autant d'espace en mémoire. - Pour accéder à des octets individuels, un autre objet de "vue" est nécessaire, on n'utilise pas `buffer[index]`. ``` @@ -31,7 +31,7 @@ Commençons par éliminer une possible source de confusion. `ArrayBuffer` n'a ri **Pour manipuler un `ArrayBuffer`, nous avons besoin d'utiliser un objet de "vue".** -Un objet de "vue" de stocke rien tout seul. Ce sont les yeux qui donnent une interprétation des octets stockés dans l'`ArrayBuffer`. +Un objet de "vue" ne stocke rien tout seul. Ce sont les lunettes qui donnent une interprétation des octets stockés dans l'`ArrayBuffer`. Par exemple: @@ -46,7 +46,7 @@ Donc, les données binaires dans un `ArrayBuffer` de 16 octets peuvent être int `ArrayBuffer` est l'objet central, le centre de tout, les données binaires brutes. -Mais si nous voulons écrire dessus, ou intérer dessus, pour n'importe quelle opération – nous devons utiliser une "vue", e.g: +Mais si nous voulons écrire à l'intérieur, ou itérer dessus, pour n'importe quelle opération – nous devons utiliser une "vue", e.g: ```js run let buffer = new ArrayBuffer(16); // crée un buffer de taille 16 @@ -65,18 +65,17 @@ view[0] = 123456; // Itérons sur les valeurs for(let num of view) { - alert(num); // 123456, then 0, 0, 0 (4 valeurs au total) + alert(num); // 123456, puis 0, 0, 0 (4 valeurs au total) } ``` ## TypedArray -The common term for all these views (`Uint8Array`, `Uint32Array`, etc) is [TypedArray](https://tc39.github.io/ecma262/#sec-typedarray-objects). They share the same set of methods and properities. +Le terme commun pour toutes ces vues (`Uint8Array`, `Uint32Array`, etc) est [TypedArray](https://tc39.github.io/ecma262/#sec-typedarray-objects). Ils partagent le même ensemble de méthodes et de propriétés. They are much more like regular arrays: have indexes and iterable. - A typed array constructor (be it `Int8Array` or `Float64Array`, doesn't matter) behaves differently depending on argument types. There are 5 variants of arguments: diff --git a/4-binary/index.md b/4-binary/index.md index 2b0c5dc82..9d75a2ae9 100644 --- a/4-binary/index.md +++ b/4-binary/index.md @@ -1,3 +1,3 @@ -# Binary data, files +# Les données binaires et les fichiers -Working with binary data and files in JavaScript. +Travail avec les données binaires et les fichiers en JavaScript. From ae754a230f070ed7d906a01861b56823b36d6477 Mon Sep 17 00:00:00 2001 From: KoukiFactori <30896120+DieuKoukiFactori@users.noreply.github.com> Date: Thu, 30 Apr 2020 05:35:01 +0200 Subject: [PATCH 3/9] Traduction... --- 4-binary/01-arraybuffer-binary-arrays/article.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/4-binary/01-arraybuffer-binary-arrays/article.md b/4-binary/01-arraybuffer-binary-arrays/article.md index 44873a863..3783cbcce 100644 --- a/4-binary/01-arraybuffer-binary-arrays/article.md +++ b/4-binary/01-arraybuffer-binary-arrays/article.md @@ -1,4 +1,4 @@ -# ArrayBuffer, binary arrays +# ArrayBuffer, tableaux binaires Dans le développement web, nous rencontrons des données binaires principalement lorsque l'on travaille avec des fichiers (création, envoi, téléchargement). Un autre cas d'utilisation est le traitement d'image. @@ -74,15 +74,15 @@ for(let num of view) { Le terme commun pour toutes ces vues (`Uint8Array`, `Uint32Array`, etc) est [TypedArray](https://tc39.github.io/ecma262/#sec-typedarray-objects). Ils partagent le même ensemble de méthodes et de propriétés. -Please note, there's no constructor called `TypedArray`, it's just a common "umbrella" term to represent one of views over `ArrayBuffer`: `Int8Array`, `Uint8Array` and so on, the full list will soon follow. +Il faut noter qu'il n'y a pas de construteur appelé `TypedArray`, Il s'agit d'un terme commun pour représenter une de ces vues : `ArrayBuffer`: `Int8Array`, `Uint8Array` etc., la liste entière va bientôt suivre. -When you see something like `new TypedArray`, it means any of `new Int8Array`, `new Uint8Array`, etc. +Lorsque vous voyez quelque chose comme `new TypedArray`, Il s'agit de n'importe quoi parmi `new Int8Array`, `new Uint8Array`, etc. -Typed array behave like regular arrays: have indexes and iterable. +Les `TypedArray` ressemblent à des tableaux classiques: ils ont des indexs et sont itérables. -A typed array constructor (be it `Int8Array` or `Float64Array`, doesn't matter) behaves differently depending on argument types. +A typed array constructor (soit `Int8Array` ou `Float64Array`, peut importe) behaves differently depending on argument types. -There are 5 variants of arguments: +Il y a 5 variantes d'arguments: ```js new TypedArray(buffer, [byteOffset], [length]); @@ -92,7 +92,7 @@ new TypedArray(length); new TypedArray(); ``` -1. If an `ArrayBuffer` argument is supplied, the view is created over it. We used that syntax already. +1. Si un `ArrayBuffer` est fourni, la vue est créée dessus. Nous avons déjà utilisé cette syntaxe. Optionally we can provide `byteOffset` to start from (0 by default) and the `length` (till the end of the buffer by default), then the view will cover only a part of the `buffer`. From 5467eca1d0eff3c990f428da2e723ea5d88fbb74 Mon Sep 17 00:00:00 2001 From: = <30896120+DieuKoukiFactori@users.noreply.github.com> Date: Fri, 15 May 2020 05:18:59 +0200 Subject: [PATCH 4/9] WIP - Translate ArrayBuffer --- .../01-arraybuffer-binary-arrays/article.md | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/4-binary/01-arraybuffer-binary-arrays/article.md b/4-binary/01-arraybuffer-binary-arrays/article.md index 3783cbcce..93f3880a1 100644 --- a/4-binary/01-arraybuffer-binary-arrays/article.md +++ b/4-binary/01-arraybuffer-binary-arrays/article.md @@ -4,11 +4,11 @@ Dans le développement web, nous rencontrons des données binaires principalemen Tout ceci est possible en JavaScript, et les opérations binaires sont très performantes. -Cependant, il y a de la confusion, car il y a beaucoup de "classes". +Cependant, il y a de la confusion, car il y a beaucoup de classes disponibles. Pour en nommer quelques unes: - `ArrayBuffer`, `Uint8Array`, `DataView`, `Blob`, `File`, etc. -En javascript, les données binaires sont implémentées de façon non standard, comparé à d'autres langages. Mais quand nous trions les choses, tout devient beaucoup plus simple. +En javascript, les données binaires sont implémentées de façon non standard, comparé à d'autres langages. Mais quand nous mettons de l'ordre dans tout ça, tout devient beaucoup plus simple. **L'objet binaire de base est un `ArrayBuffer` -- une référence à une zone contigüe de taille fixe de la mémoire.** @@ -22,8 +22,8 @@ Cela alloue une zone contigue de 16 octets dans la mémoire et la pré-remplie a ```warn header="L'`ArrayBuffer` n'est pas un tableau de 'quelque chose'." Commençons par éliminer une possible source de confusion. `ArrayBuffer` n'a rien en commun avec `Array`: -- Il possède une taille fixe, on ne peut pas l'agrandir ou la reduire. -- Il prend exactement autant d'espace en mémoire. +- Il possède une taille fixe, nous ne pouvons ni l'aggrandir, ni le réduire. +- Il prend une taille spécifique en mémoire. - Pour accéder à des octets individuels, un autre objet de "vue" est nécessaire, on n'utilise pas `buffer[index]`. ``` @@ -72,15 +72,15 @@ for(let num of view) { ## TypedArray -Le terme commun pour toutes ces vues (`Uint8Array`, `Uint32Array`, etc) est [TypedArray](https://tc39.github.io/ecma262/#sec-typedarray-objects). Ils partagent le même ensemble de méthodes et de propriétés. +Le terme commun pour toutes ces vues (`Uint8Array`, `Uint32Array`, etc) est [TypedArray](https://tc39.github.io/ecma262/#sec-typedarray-objects). Elles partagent le même ensemble de méthodes et de propriétés. -Il faut noter qu'il n'y a pas de construteur appelé `TypedArray`, Il s'agit d'un terme commun pour représenter une de ces vues : `ArrayBuffer`: `Int8Array`, `Uint8Array` etc., la liste entière va bientôt suivre. +Il faut noter qu'il n'y a pas de construteur appelé `TypedArray`, Il s'agit d'un terme pour représenter une de ces vues : `ArrayBuffer`: `Int8Array`, `Uint8Array` etc., la liste entière va bientôt suivre. Lorsque vous voyez quelque chose comme `new TypedArray`, Il s'agit de n'importe quoi parmi `new Int8Array`, `new Uint8Array`, etc. Les `TypedArray` ressemblent à des tableaux classiques: ils ont des indexs et sont itérables. -A typed array constructor (soit `Int8Array` ou `Float64Array`, peut importe) behaves differently depending on argument types. +Un constructeur `TypedArray` (soit `Int8Array` ou `Float64Array`, peut importe) se comporte différement en fonction du type des arguments. Il y a 5 variantes d'arguments: @@ -94,19 +94,19 @@ new TypedArray(); 1. Si un `ArrayBuffer` est fourni, la vue est créée dessus. Nous avons déjà utilisé cette syntaxe. - Optionally we can provide `byteOffset` to start from (0 by default) and the `length` (till the end of the buffer by default), then the view will cover only a part of the `buffer`. + Nous pouvons éventuellement fournir un décalage (`byteOffset`) pour commencer à partir de là (0 par défaut) et la longueur (`length`) (jusqu'à la fin du buffer par défaut), alors la vue ne va couvrir qu'une partie du `buffer`. -2. If an `Array`, or any array-like object is given, it creates a typed array of the same length and copies the content. +2. Si c'est un `Array`, ou quelque chose ressemblant à un tableau qui est fourni, il crée un `TypedArray` de la même longueur et copie le contenu. - We can use it to pre-fill the array with the data: + Nous pouvons l'utiliser pour pré-remplir le tableau avec les données: ```js run *!* let arr = new Uint8Array([0, 1, 2, 3]); */!* - alert( arr.length ); // 4, created binary array of the same length - alert( arr[1] ); // 1, filled with 4 bytes (unsigned 8-bit integers) with given values + alert( arr.length ); // 4, a créé une liste binaire de la même taille + alert( arr[1] ); // 1, remplit avec 4 octets (entiers non signés sur 8 bits) avec des valeurs données ``` -3. If another `TypedArray` is supplied, it does the same: creates a typed array of the same length and copies values. Values are converted to the new type in the process, if needed. +3. Si un autre `TypedArray` est fourni, il fait la même chose: il crée un `TypedArray` de la même taille et copie le contenu. Les valeurs sont converties vers le nouveau type dans le processus si besoin. ```js run let arr16 = new Uint16Array([1, 1000]); *!* @@ -116,14 +116,14 @@ new TypedArray(); alert( arr8[1] ); // 232, tried to copy 1000, but can't fit 1000 into 8 bits (explanations below) ``` -4. For a numeric argument `length` -- creates the typed array to contain that many elements. Its byte length will be `length` multiplied by the number of bytes in a single item `TypedArray.BYTES_PER_ELEMENT`: +4. Pour un argument numérique `length` -- Il crée un `TypedArray` qui contient autant d'éléments. Sa taille en octet va être `length` multiplié par la taille en octets d'un seul élément `TypedArray.BYTES_PER_ELEMENT`: ```js run - let arr = new Uint16Array(4); // create typed array for 4 integers - alert( Uint16Array.BYTES_PER_ELEMENT ); // 2 bytes per integer - alert( arr.byteLength ); // 8 (size in bytes) + let arr = new Uint16Array(4); // Création d'un TypedArray de 4 entiers + alert( Uint16Array.BYTES_PER_ELEMENT ); // 2 octets par entier + alert( arr.byteLength ); // 8 (taille en octets) ``` -5. Without arguments, creates an zero-length typed array. +5. Sans arguments, il crée un `TypedArray` de taille nulle. We can create a `TypedArray` directly, without mentioning `ArrayBuffer`. But a view cannot exist without an underlying `ArrayBuffer`, so gets created automatically in all these cases except the first one (when provided). From 391f3505f7b10838786675985eb6dbae11e6708e Mon Sep 17 00:00:00 2001 From: DieuKoukiFactori <30896120+DieuKoukiFactori@users.noreply.github.com> Date: Fri, 15 May 2020 09:35:06 +0200 Subject: [PATCH 5/9] Almost finished - DataView part not translated --- .../01-arraybuffer-binary-arrays/article.md | 100 +++++++++--------- 1 file changed, 49 insertions(+), 51 deletions(-) diff --git a/4-binary/01-arraybuffer-binary-arrays/article.md b/4-binary/01-arraybuffer-binary-arrays/article.md index 93f3880a1..33677202e 100644 --- a/4-binary/01-arraybuffer-binary-arrays/article.md +++ b/4-binary/01-arraybuffer-binary-arrays/article.md @@ -1,4 +1,4 @@ -# ArrayBuffer, tableaux binaires +# ArrayBuffer, tableaux binaires*a Dans le développement web, nous rencontrons des données binaires principalement lorsque l'on travaille avec des fichiers (création, envoi, téléchargement). Un autre cas d'utilisation est le traitement d'image. @@ -125,59 +125,59 @@ new TypedArray(); 5. Sans arguments, il crée un `TypedArray` de taille nulle. -We can create a `TypedArray` directly, without mentioning `ArrayBuffer`. But a view cannot exist without an underlying `ArrayBuffer`, so gets created automatically in all these cases except the first one (when provided). +Nous pouvons créer un `TypedArray` directement, sans mentionner un `ArrayBuffer`. Mais une vue ne peut pas exister sans un `ArrayBuffer`, donc il sera créé automatiquement dans tous les cas, sauf le premier (quand il est passé en argument). -To access the `ArrayBuffer`, there are properties: -- `arr.buffer` -- references the `ArrayBuffer`. -- `arr.byteLength` -- the length of the `ArrayBuffer`. +Pour accéder à l'`ArrayBuffer`, ils y a plusieurs propriétés: +- `arr.buffer` -- qui fait référence à l'`ArrayBuffer`. +- `arr.byteLength` -- qui correspond à la taille de l'`ArrayBuffer`. -So, we can always move from one view to another: +Donc nous pouvons toujours passer d'une vue à l'autre: ```js let arr8 = new Uint8Array([0, 1, 2, 3]); -// another view on the same data +// Une autre vue avec les mêmes données let arr16 = new Uint16Array(arr8.buffer); ``` -Here's the list of typed arrays: +Voici une liste de `TypedArray`: -- `Uint8Array`, `Uint16Array`, `Uint32Array` -- for integer numbers of 8, 16 and 32 bits. - - `Uint8ClampedArray` -- for 8-bit integers, "clamps" them on assignment (see below). -- `Int8Array`, `Int16Array`, `Int32Array` -- for signed integer numbers (can be negative). -- `Float32Array`, `Float64Array` -- for signed floating-point numbers of 32 and 64 bits. +- `Uint8Array`, `Uint16Array`, `Uint32Array` -- Pour les entiers de 8, 16 et 32 bits. + - `Uint8ClampedArray` -- Pour les entiers de 8 bits, avec un "resserage" à l'assignement (voir plus loin). +- `Int8Array`, `Int16Array`, `Int32Array` -- Pour les nombres entiers signés (peuvent être négatifs). +- `Float32Array`, `Float64Array` -- Pour les nombres flottants signés de 32 et 64 bits. -```warn header="No `int8` or similar single-valued types" -Please note, despite of the names like `Int8Array`, there's no single-value type like `int`, or `int8` in JavaScript. +```warn header="Pas de `int8` ou de types similaires" +Malgré la présence de noms tels que `Int8Array`, il n'y a pas de type comme `int` ou `int8` dans JavaScript. -That's logical, as `Int8Array` is not an array of these individual values, but rather a view on `ArrayBuffer`. +C'est logique car `Int8Array` n'est pas un tableau de ces valeurs individuelles, mais plutôt une vue sur `ArrayBuffer`. ``` -### Out-of-bounds behavior +### Comportement hors limite -What if we attempt to write an out-of-bounds value into a typed array? There will be no error. But extra bits are cut-off. +Que se passe t'il lorsque nous essayons d'écrire des valeurs en dehors des limites dans un `TypedArray` ? Il n'y aura pas d'erreurs, mais les bits en trop seront supprimés. -For instance, let's try to put 256 into `Uint8Array`. In binary form, 256 is `100000000` (9 bits), but `Uint8Array` only provides 8 bits per value, that makes the available range from 0 to 255. +Par exemple, essayons d'ajouter 256 dans un `Uint8Array`. En binaire, 256 s'écrit `100000000` (9 bits), mais un `Uint8Array` ne permet que 8 bits par valeur, ce qui donne des valeurs possibles entre 0 et 255. -For bigger numbers, only the rightmost (less significant) 8 bits are stored, and the rest is cut off: +Pour les grands nombres, seuls les 8 bits les plus à droite (moins significatif) sont sauvegardés, et le reste est supprimé: ![](8bit-integer-256.svg) -So we'll get zero. +Donc nous allons obtenir 0. -For 257, the binary form is `100000001` (9 bits), the rightmost 8 get stored, so we'll have `1` in the array: +Pour 257, l'écriture binaire est `100000001` (9 bits), les 8 bits les plus à droite sont gardés, donc on aura un `1` dans notre tableau: ![](8bit-integer-257.svg) -In other words, the number modulo 28 is saved. +En d'autres termes, Le nombre modulo 28 est sauvegardé. -Here's the demo: +Démonstration: ```js run let uint8array = new Uint8Array(16); let num = 256; -alert(num.toString(2)); // 100000000 (binary representation) +alert(num.toString(2)); // 100000000 (représentation binaire) uint8array[0] = 256; uint8array[1] = 257; @@ -186,27 +186,25 @@ alert(uint8array[0]); // 0 alert(uint8array[1]); // 1 ``` -`Uint8ClampedArray` is special in this aspect, its behavior is different. It saves 255 for any number that is greater than 255, and 0 for any negative number. That behavior is useful for image processing. +`Uint8ClampedArray` est différent car il possède un comportement spécial. Il sauvegarde 255 pour n'importe quel nombre qui est plus grand que 255, et 0 pour n'importe quel nombre négatif. Ce comportement est utile pour le traitement d'images. ## TypedArray methods -`TypedArray` has regular `Array` methods, with notable exceptions. +`TypedArray` possède les méthodes de `Array`, avec quelques exceptions notables. -We can iterate, `map`, `slice`, `find`, `reduce` etc. +Nous pouvons itérer, `map`, `slice`, `find`, `reduce` etc. -There are few things we can't do though: +Mais certaines choses ne sont pas possibles: -- No `splice` -- we can't "delete" a value, because typed arrays are views on a buffer, and these are fixed, contiguous areas of memory. All we can do is to assign a zero. -- No `concat` method. +- Pas de `splice` -- On ne peut pas supprimer une valeur, car les `TypedArray` sont des vues sur un `buffer`, qui sont des zones fixes dans la mémoire. Tout ce que nous pouvons faire est de mettre un 0. +- Pas de méthode `concat`. -There are two additional methods: - -- `arr.set(fromArr, [offset])` copies all elements from `fromArr` to the `arr`, starting at position `offset` (0 by default). -- `arr.subarray([begin, end])` creates a new view of the same type from `begin` to `end` (exclusive). That's similar to `slice` method (that's also supported), but doesn't copy anything -- just creates a new view, to operate on the given piece of data. - -These methods allow us to copy typed arrays, mix them, create new arrays from existing ones, and so on. +Il y a deux méthodes supplémentaires: +- `arr.set(fromArr, [offset])` copie tous les éléments de `fromArr` vers `arr`, en commençant à partir de la position `offset` (0 par défaut). +- `arr.subarray([begin, end])` crée une nouvelle vue du même type de `begin` jusqu'à `end` (non-inclus). C'est similaire à la méthode `slice` (qui est également disponible), mais elle ne copie rien -- il s'agit juste d'une création d'une nouvelle vue, pour travailler sur un certain morceau de données. +Les méthodes nous permettent de copier des `TypedArray`, de les mélanger, de créer des nouveaux tableaux depuis ceux existants, et bien d'autres choses. ## DataView @@ -247,27 +245,27 @@ dataView.setUint32(0, 0); // set 4-byte number to zero, thus setting all bytes t `DataView` is great when we store mixed-format data in the same buffer. E.g we store a sequence of pairs (16-bit integer, 32-bit float). Then `DataView` allows to access them easily. -## Summary +## Résumé -`ArrayBuffer` is the core object, a reference to the fixed-length contiguous memory area. +`ArrayBuffer` est l'objet au coeur de tout, c'est une référence à une zone de taille fixe dans la mémoire. -To do almost any operation on `ArrayBuffer`, we need a view. +Pour faire presque n'importe quelle opération sur un `ArrayBuffer`, nous avons besoin d'une vue. -- It can be a `TypedArray`: - - `Uint8Array`, `Uint16Array`, `Uint32Array` -- for unsigned integers of 8, 16, and 32 bits. - - `Uint8ClampedArray` -- for 8-bit integers, "clamps" them on assignment. - - `Int8Array`, `Int16Array`, `Int32Array` -- for signed integer numbers (can be negative). - - `Float32Array`, `Float64Array` -- for signed floating-point numbers of 32 and 64 bits. -- Or a `DataView` -- the view that uses methods to specify a format, e.g. `getUint8(offset)`. +- Il peut s'agir d'un `TypedArray`: + - `Uint8Array`, `Uint16Array`, `Uint32Array` -- pour les entiers non-signés de 8, 16, et 32 bits. + - `Uint8ClampedArray` -- pour les entiers de 8 bits, "clamps" them on assignment. + - `Int8Array`, `Int16Array`, `Int32Array` -- pour les entiers signés (peuvent être négatifs). + - `Float32Array`, `Float64Array` -- pour les nombres flottants signés de 32 et 64 bits. +- Ou d'une `DataView` -- la vue qui utilise des méthodes pour spécifier un format, e.g. `getUint8(offset)`. -In most cases we create and operate directly on typed arrays, leaving `ArrayBuffer` under cover, as a "common discriminator". We can access it as `.buffer` and make another view if needed. +Dans la majorité des cas, on crée et on opère directement sur les `TypedArray`, laissant `ArrayBuffer` en arrière. On peut toujours y accéder avec `.buffer` et faire une nouvelle vie si besoin. -There are also two additional terms, that are used in descriptions of methods that operate on binary data: -- `ArrayBufferView` is an umbrella term for all these kinds of views. -- `BufferSource` is an umbrella term for `ArrayBuffer` or `ArrayBufferView`. +Il y a également 2 termes supplémentaires, qui sont utilisés dans les descriptions des méthodes pour travailler sur les données binaires: +- `ArrayBufferView` qui est le terme pour tous les types de vues. +- `BufferSource` qui est un terme désignant soit un `ArrayBuffer` ou un `ArrayBufferView`. -We'll see these terms in the next chapters. `BufferSource` is one of the most common terms, as it means "any kind of binary data" -- an `ArrayBuffer` or a view over it. +Nous verrons ces termes dans les prochains chapitres. `BufferSource` est l'un des termes les plus communs, qui veut dire "n'importe quel type de données binaires" -- un `ArrayBuffer` ou une vue par dessus. -Here's a cheatsheet: +Voici un résumé: ![](arraybuffer-view-buffersource.svg) From a7b51c0ad4f96e669b2d5644f76873981f6a43fc Mon Sep 17 00:00:00 2001 From: DieuKoukiFactori <30896120+DieuKoukiFactori@users.noreply.github.com> Date: Sat, 16 May 2020 04:07:12 +0200 Subject: [PATCH 6/9] Translate ArrayBuffer page in french language --- .../01-concat/task.md | 4 +- .../01-arraybuffer-binary-arrays/article.md | 70 +++++++++---------- 2 files changed, 37 insertions(+), 37 deletions(-) diff --git a/4-binary/01-arraybuffer-binary-arrays/01-concat/task.md b/4-binary/01-arraybuffer-binary-arrays/01-concat/task.md index 6710104b2..0efa613f8 100644 --- a/4-binary/01-arraybuffer-binary-arrays/01-concat/task.md +++ b/4-binary/01-arraybuffer-binary-arrays/01-concat/task.md @@ -1,4 +1,4 @@ -# Concatenate typed arrays +# Concaténation de tableaux typés -Given an array of `Uint8Array`, write a function `concat(arrays)` that returns a concatenation of them into a single array. +En passant un tableau de `Uint8Array`, écrivez une fonction `concat(arrays)` qui retourne une concaténation dans un seul tableau. diff --git a/4-binary/01-arraybuffer-binary-arrays/article.md b/4-binary/01-arraybuffer-binary-arrays/article.md index 33677202e..4b7a6cb2a 100644 --- a/4-binary/01-arraybuffer-binary-arrays/article.md +++ b/4-binary/01-arraybuffer-binary-arrays/article.md @@ -70,7 +70,7 @@ for(let num of view) { ``` -## TypedArray +## TypedArray - tableau typé Le terme commun pour toutes ces vues (`Uint8Array`, `Uint32Array`, etc) est [TypedArray](https://tc39.github.io/ecma262/#sec-typedarray-objects). Elles partagent le même ensemble de méthodes et de propriétés. @@ -78,7 +78,7 @@ Il faut noter qu'il n'y a pas de construteur appelé `TypedArray`, Il s'agit d'u Lorsque vous voyez quelque chose comme `new TypedArray`, Il s'agit de n'importe quoi parmi `new Int8Array`, `new Uint8Array`, etc. -Les `TypedArray` ressemblent à des tableaux classiques: ils ont des indexs et sont itérables. +Les tableaux typés ressemblent à des tableaux classiques: ils ont des indexs et sont itérables. Un constructeur `TypedArray` (soit `Int8Array` ou `Float64Array`, peut importe) se comporte différement en fonction du type des arguments. @@ -96,7 +96,7 @@ new TypedArray(); Nous pouvons éventuellement fournir un décalage (`byteOffset`) pour commencer à partir de là (0 par défaut) et la longueur (`length`) (jusqu'à la fin du buffer par défaut), alors la vue ne va couvrir qu'une partie du `buffer`. -2. Si c'est un `Array`, ou quelque chose ressemblant à un tableau qui est fourni, il crée un `TypedArray` de la même longueur et copie le contenu. +2. Si c'est un `Array`, ou quelque chose ressemblant à un tableau qui est fourni, il crée un tableau typé de la même longueur et copie le contenu. Nous pouvons l'utiliser pour pré-remplir le tableau avec les données: ```js run @@ -106,26 +106,26 @@ new TypedArray(); alert( arr.length ); // 4, a créé une liste binaire de la même taille alert( arr[1] ); // 1, remplit avec 4 octets (entiers non signés sur 8 bits) avec des valeurs données ``` -3. Si un autre `TypedArray` est fourni, il fait la même chose: il crée un `TypedArray` de la même taille et copie le contenu. Les valeurs sont converties vers le nouveau type dans le processus si besoin. +3. Si un autre tableau typé est fourni, il fait la même chose: il crée un tableau typé de la même taille et copie le contenu. Les valeurs sont converties vers le nouveau type dans le processus si besoin. ```js run let arr16 = new Uint16Array([1, 1000]); *!* let arr8 = new Uint8Array(arr16); */!* alert( arr8[0] ); // 1 - alert( arr8[1] ); // 232, tried to copy 1000, but can't fit 1000 into 8 bits (explanations below) + alert( arr8[1] ); // 232, 1000 ne rentre pas dans 8 bits (explications plus loin) ``` -4. Pour un argument numérique `length` -- Il crée un `TypedArray` qui contient autant d'éléments. Sa taille en octet va être `length` multiplié par la taille en octets d'un seul élément `TypedArray.BYTES_PER_ELEMENT`: +4. Pour un argument numérique `length` -- Il crée un tableau typé qui contient autant d'éléments. Sa taille en octet va être `length` multiplié par la taille en octets d'un seul élément `TypedArray.BYTES_PER_ELEMENT`: ```js run - let arr = new Uint16Array(4); // Création d'un TypedArray de 4 entiers + let arr = new Uint16Array(4); // Création d'un tableau typé de 4 entiers alert( Uint16Array.BYTES_PER_ELEMENT ); // 2 octets par entier alert( arr.byteLength ); // 8 (taille en octets) ``` -5. Sans arguments, il crée un `TypedArray` de taille nulle. +5. Sans arguments, il crée un tableau typé de taille nulle. -Nous pouvons créer un `TypedArray` directement, sans mentionner un `ArrayBuffer`. Mais une vue ne peut pas exister sans un `ArrayBuffer`, donc il sera créé automatiquement dans tous les cas, sauf le premier (quand il est passé en argument). +Nous pouvons créer un tableau typé directement, sans mentionner un `ArrayBuffer`. Mais une vue ne peut pas exister sans un `ArrayBuffer`, donc il sera créé automatiquement dans tous les cas, sauf le premier (quand il est passé en argument). Pour accéder à l'`ArrayBuffer`, ils y a plusieurs propriétés: - `arr.buffer` -- qui fait référence à l'`ArrayBuffer`. @@ -140,22 +140,22 @@ let arr16 = new Uint16Array(arr8.buffer); ``` -Voici une liste de `TypedArray`: +Voici une liste de tableaux typés: - `Uint8Array`, `Uint16Array`, `Uint32Array` -- Pour les entiers de 8, 16 et 32 bits. - - `Uint8ClampedArray` -- Pour les entiers de 8 bits, avec un "resserage" à l'assignement (voir plus loin). + - `Uint8ClampedArray` -- Pour les entiers de 8 bits, avec une "restriction" à l'affectation (voir plus loin). - `Int8Array`, `Int16Array`, `Int32Array` -- Pour les nombres entiers signés (peuvent être négatifs). - `Float32Array`, `Float64Array` -- Pour les nombres flottants signés de 32 et 64 bits. ```warn header="Pas de `int8` ou de types similaires" Malgré la présence de noms tels que `Int8Array`, il n'y a pas de type comme `int` ou `int8` dans JavaScript. -C'est logique car `Int8Array` n'est pas un tableau de ces valeurs individuelles, mais plutôt une vue sur `ArrayBuffer`. +Car en effet `Int8Array` n'est pas un tableau de ces valeurs individuelles, mais plutôt une vue sur `ArrayBuffer`. ``` ### Comportement hors limite -Que se passe t'il lorsque nous essayons d'écrire des valeurs en dehors des limites dans un `TypedArray` ? Il n'y aura pas d'erreurs, mais les bits en trop seront supprimés. +Que se passe t'il lorsque nous essayons d'écrire des valeurs en dehors des limites dans un tableau typé ? Il n'y aura pas d'erreurs, mais les bits en trop seront supprimés. Par exemple, essayons d'ajouter 256 dans un `Uint8Array`. En binaire, 256 s'écrit `100000000` (9 bits), mais un `Uint8Array` ne permet que 8 bits par valeur, ce qui donne des valeurs possibles entre 0 et 255. @@ -186,7 +186,7 @@ alert(uint8array[0]); // 0 alert(uint8array[1]); // 1 ``` -`Uint8ClampedArray` est différent car il possède un comportement spécial. Il sauvegarde 255 pour n'importe quel nombre qui est plus grand que 255, et 0 pour n'importe quel nombre négatif. Ce comportement est utile pour le traitement d'images. +`Uint8ClampedArray` possède un comportement différent. Il garde 255 pour n'importe quel nombre qui est plus grand que 255, et 0 pour n'importe quel nombre négatif. Ce comportement est utile dans le traitement d'images. ## TypedArray methods @@ -196,7 +196,7 @@ Nous pouvons itérer, `map`, `slice`, `find`, `reduce` etc. Mais certaines choses ne sont pas possibles: -- Pas de `splice` -- On ne peut pas supprimer une valeur, car les `TypedArray` sont des vues sur un `buffer`, qui sont des zones fixes dans la mémoire. Tout ce que nous pouvons faire est de mettre un 0. +- Pas de `splice` -- On ne peut pas supprimer une valeur, car les tableaux typés sont des vues sur un `buffer`, qui sont des zones fixes dans la mémoire. Tout ce que nous pouvons faire est de mettre un 0. - Pas de méthode `concat`. Il y a deux méthodes supplémentaires: @@ -204,46 +204,46 @@ Il y a deux méthodes supplémentaires: - `arr.set(fromArr, [offset])` copie tous les éléments de `fromArr` vers `arr`, en commençant à partir de la position `offset` (0 par défaut). - `arr.subarray([begin, end])` crée une nouvelle vue du même type de `begin` jusqu'à `end` (non-inclus). C'est similaire à la méthode `slice` (qui est également disponible), mais elle ne copie rien -- il s'agit juste d'une création d'une nouvelle vue, pour travailler sur un certain morceau de données. -Les méthodes nous permettent de copier des `TypedArray`, de les mélanger, de créer des nouveaux tableaux depuis ceux existants, et bien d'autres choses. +Les méthodes nous permettent de copier des tableaux typés, de les mélanger, de créer des nouveaux tableaux depuis ceux existants, et bien d'autres choses. ## DataView -[DataView](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView) is a special super-flexible "untyped" view over `ArrayBuffer`. It allows to access the data on any offset in any format. +[DataView](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView) est une vue spéciale non typée par dessus `ArrayBuffer`. Il permet d'accéder aux données avec n'importe quel décalage et avec n'importe quel format. -- For typed arrays, the constructor dictates what the format is. The whole array is supposed to be uniform. The i-th number is `arr[i]`. -- With `DataView` we access the data with methods like `.getUint8(i)` or `.getUint16(i)`. We choose the format at method call time instead of the construction time. +- Pour les tableaux typés, le constructeur détermine le format. Le tableau entier est supposé être uniforme. Le i-ème nombre est noté `arr[i]`. +- Avec `DataView` nous accédons aux données avec des méthodes comme `.getUint8(i)` ou `.getUint16(i)`. Nous choisissons le format au moment de l'utilisation de la méthode au lieu du moment de la création. -The syntax: +Voici la syntaxe: ```js new DataView(buffer, [byteOffset], [byteLength]) ``` -- **`buffer`** -- the underlying `ArrayBuffer`. Unlike typed arrays, `DataView` doesn't create a buffer on its own. We need to have it ready. -- **`byteOffset`** -- the starting byte position of the view (by default 0). -- **`byteLength`** -- the byte length of the view (by default till the end of `buffer`). +- **`buffer`** -- `ArrayBuffer`. Contrairement aux tableaux typés, `DataView` ne crée pas un buffer lui même. Nous avons besoin de le lui fournir directement. +- **`byteOffset`** -- L'octet de départ de la vue (par défaut à 0). +- **`byteLength`** -- La taille totale de la vue en octets (par défaut jusqu'à la fin de `buffer`). -For instance, here we extract numbers in different formats from the same buffer: +Pour l'exemple, nous allons récupérer des nombres dans plusieurs formats avec le même buffer: ```js run -// binary array of 4 bytes, all have the maximal value 255 +// Tableau binaire de 4 octets, tous ayant la valeur maximale - 255 let buffer = new Uint8Array([255, 255, 255, 255]).buffer; let dataView = new DataView(buffer); -// get 8-bit number at offset 0 +// récupération d'un nombre en 8 bits avec un décalage de 0 alert( dataView.getUint8(0) ); // 255 -// now get 16-bit number at offset 0, it consists of 2 bytes, together iterpreted as 65535 -alert( dataView.getUint16(0) ); // 65535 (biggest 16-bit unsigned int) +// récupération d'un nombre en 16 bits avec un décalage de 0, soit 2 octets, qui sont interprétés ensemble en 65535 +alert( dataView.getUint16(0) ); // 65535 (Plus grand entier non signé en 16 bits) -// get 32-bit number at offset 0 -alert( dataView.getUint32(0) ); // 4294967295 (biggest 32-bit unsigned int) +// récupération d'un nombre en 32 bits avec un décalage de 0 +alert( dataView.getUint32(0) ); // 4294967295 (Plus grand entier non signé en 32 bits) -dataView.setUint32(0, 0); // set 4-byte number to zero, thus setting all bytes to 0 +dataView.setUint32(0, 0); // Fixe le nombre sous 4 octets à 0, fixant ainsi tous les octets à 0 ``` -`DataView` is great when we store mixed-format data in the same buffer. E.g we store a sequence of pairs (16-bit integer, 32-bit float). Then `DataView` allows to access them easily. +`DataView` est utile lorsque l'on met des données sous plusieurs formats dans le même buffer. Par exemple, on stocke une séquence de paires (16-bit integer, 32-bit float). Le `DataView` nous permettra d'y accéder facilement. ## Résumé @@ -251,20 +251,20 @@ dataView.setUint32(0, 0); // set 4-byte number to zero, thus setting all bytes t Pour faire presque n'importe quelle opération sur un `ArrayBuffer`, nous avons besoin d'une vue. -- Il peut s'agir d'un `TypedArray`: +- Il peut s'agir d'un tableau typé: - `Uint8Array`, `Uint16Array`, `Uint32Array` -- pour les entiers non-signés de 8, 16, et 32 bits. - `Uint8ClampedArray` -- pour les entiers de 8 bits, "clamps" them on assignment. - `Int8Array`, `Int16Array`, `Int32Array` -- pour les entiers signés (peuvent être négatifs). - `Float32Array`, `Float64Array` -- pour les nombres flottants signés de 32 et 64 bits. - Ou d'une `DataView` -- la vue qui utilise des méthodes pour spécifier un format, e.g. `getUint8(offset)`. -Dans la majorité des cas, on crée et on opère directement sur les `TypedArray`, laissant `ArrayBuffer` en arrière. On peut toujours y accéder avec `.buffer` et faire une nouvelle vie si besoin. +Dans la majorité des cas, on crée et on opère directement sur les tableaux typés, laissant `ArrayBuffer` en arrière. On peut toujours y accéder avec `.buffer` et faire une nouvelle vie si besoin. Il y a également 2 termes supplémentaires, qui sont utilisés dans les descriptions des méthodes pour travailler sur les données binaires: - `ArrayBufferView` qui est le terme pour tous les types de vues. - `BufferSource` qui est un terme désignant soit un `ArrayBuffer` ou un `ArrayBufferView`. -Nous verrons ces termes dans les prochains chapitres. `BufferSource` est l'un des termes les plus communs, qui veut dire "n'importe quel type de données binaires" -- un `ArrayBuffer` ou une vue par dessus. +Nous verrons ces termes dans les prochains chapitres. `BufferSource` est l'un des termes les plus communs, qui veut dire "toutes sortes de données binaires" -- un `ArrayBuffer` ou une vue par dessus. Voici un résumé: From 0a715d7fb27e67b8fbdc859580453fa2e1d074c0 Mon Sep 17 00:00:00 2001 From: DieuKoukiFactori <30896120+DieuKoukiFactori@users.noreply.github.com> Date: Sat, 16 May 2020 04:10:42 +0200 Subject: [PATCH 7/9] Travail -> Manipulation --- 4-binary/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/4-binary/index.md b/4-binary/index.md index 9d75a2ae9..e500f2edc 100644 --- a/4-binary/index.md +++ b/4-binary/index.md @@ -1,3 +1,3 @@ # Les données binaires et les fichiers -Travail avec les données binaires et les fichiers en JavaScript. +Manipulation des données binaires et les fichiers en JavaScript. From 9edfb1139c7ed6e1029c54bfed747a8e971f633b Mon Sep 17 00:00:00 2001 From: DieuKoukiFactori <30896120+DieuKoukiFactori@users.noreply.github.com> Date: Sat, 16 May 2020 04:11:48 +0200 Subject: [PATCH 8/9] fix typo --- 4-binary/01-arraybuffer-binary-arrays/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/4-binary/01-arraybuffer-binary-arrays/article.md b/4-binary/01-arraybuffer-binary-arrays/article.md index 4b7a6cb2a..d7c84310f 100644 --- a/4-binary/01-arraybuffer-binary-arrays/article.md +++ b/4-binary/01-arraybuffer-binary-arrays/article.md @@ -1,4 +1,4 @@ -# ArrayBuffer, tableaux binaires*a +# ArrayBuffer, tableaux binaires Dans le développement web, nous rencontrons des données binaires principalement lorsque l'on travaille avec des fichiers (création, envoi, téléchargement). Un autre cas d'utilisation est le traitement d'image. From c6fec7d223dc1f07c6fec4aabcdc8db2fde9e928 Mon Sep 17 00:00:00 2001 From: Piixell <30896120+DieuKoukiFactori@users.noreply.github.com> Date: Sat, 16 May 2020 05:10:06 +0200 Subject: [PATCH 9/9] Fix typos --- .../01-arraybuffer-binary-arrays/article.md | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/4-binary/01-arraybuffer-binary-arrays/article.md b/4-binary/01-arraybuffer-binary-arrays/article.md index d7c84310f..0b172060e 100644 --- a/4-binary/01-arraybuffer-binary-arrays/article.md +++ b/4-binary/01-arraybuffer-binary-arrays/article.md @@ -74,7 +74,7 @@ for(let num of view) { Le terme commun pour toutes ces vues (`Uint8Array`, `Uint32Array`, etc) est [TypedArray](https://tc39.github.io/ecma262/#sec-typedarray-objects). Elles partagent le même ensemble de méthodes et de propriétés. -Il faut noter qu'il n'y a pas de construteur appelé `TypedArray`, Il s'agit d'un terme pour représenter une de ces vues : `ArrayBuffer`: `Int8Array`, `Uint8Array` etc., la liste entière va bientôt suivre. +Il faut noter qu'il n'y a pas de construteur appelé `TypedArray`, Il s'agit d'un terme pour représenter une des vues par dessus un `ArrayBuffer`: `Int8Array`, `Uint8Array` etc. La liste entière va bientôt suivre. Lorsque vous voyez quelque chose comme `new TypedArray`, Il s'agit de n'importe quoi parmi `new Int8Array`, `new Uint8Array`, etc. @@ -116,7 +116,7 @@ new TypedArray(); alert( arr8[1] ); // 232, 1000 ne rentre pas dans 8 bits (explications plus loin) ``` -4. Pour un argument numérique `length` -- Il crée un tableau typé qui contient autant d'éléments. Sa taille en octet va être `length` multiplié par la taille en octets d'un seul élément `TypedArray.BYTES_PER_ELEMENT`: +4. Si un argument `length` est fourni -- Il crée un tableau typé qui contient autant d'éléments. Sa taille en octets va être `length` multiplié par la taille en octets d'un seul élément `TypedArray.BYTES_PER_ELEMENT`: ```js run let arr = new Uint16Array(4); // Création d'un tableau typé de 4 entiers alert( Uint16Array.BYTES_PER_ELEMENT ); // 2 octets par entier @@ -125,9 +125,9 @@ new TypedArray(); 5. Sans arguments, il crée un tableau typé de taille nulle. -Nous pouvons créer un tableau typé directement, sans mentionner un `ArrayBuffer`. Mais une vue ne peut pas exister sans un `ArrayBuffer`, donc il sera créé automatiquement dans tous les cas, sauf le premier (quand il est passé en argument). +Nous pouvons créer un tableau typé directement sans fournir un `ArrayBuffer`. Mais une vue ne peut pas exister sans, donc il sera créé automatiquement dans tous les cas, sauf le premier (quand il est passé en argument). -Pour accéder à l'`ArrayBuffer`, ils y a plusieurs propriétés: +Pour accéder à l'`ArrayBuffer`, il y a plusieurs propriétés: - `arr.buffer` -- qui fait référence à l'`ArrayBuffer`. - `arr.byteLength` -- qui correspond à la taille de l'`ArrayBuffer`. @@ -188,7 +188,7 @@ alert(uint8array[1]); // 1 `Uint8ClampedArray` possède un comportement différent. Il garde 255 pour n'importe quel nombre qui est plus grand que 255, et 0 pour n'importe quel nombre négatif. Ce comportement est utile dans le traitement d'images. -## TypedArray methods +## Méthodes des tableaux typés `TypedArray` possède les méthodes de `Array`, avec quelques exceptions notables. @@ -208,7 +208,7 @@ Les méthodes nous permettent de copier des tableaux typés, de les mélanger, d ## DataView -[DataView](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView) est une vue spéciale non typée par dessus `ArrayBuffer`. Il permet d'accéder aux données avec n'importe quel décalage et avec n'importe quel format. +[DataView](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView) est une vue spéciale non typée par dessus `ArrayBuffer`. Elle permet d'accéder aux données avec n'importe quel décalage et avec n'importe quel format. - Pour les tableaux typés, le constructeur détermine le format. Le tableau entier est supposé être uniforme. Le i-ème nombre est noté `arr[i]`. - Avec `DataView` nous accédons aux données avec des méthodes comme `.getUint8(i)` ou `.getUint16(i)`. Nous choisissons le format au moment de l'utilisation de la méthode au lieu du moment de la création. @@ -219,7 +219,7 @@ Voici la syntaxe: new DataView(buffer, [byteOffset], [byteLength]) ``` -- **`buffer`** -- `ArrayBuffer`. Contrairement aux tableaux typés, `DataView` ne crée pas un buffer lui même. Nous avons besoin de le lui fournir directement. +- **`buffer`** -- `ArrayBuffer`. Contrairement aux tableaux typés, `DataView` ne crée pas soit même un buffer. Nous avons besoin de le lui fournir directement. - **`byteOffset`** -- L'octet de départ de la vue (par défaut à 0). - **`byteLength`** -- La taille totale de la vue en octets (par défaut jusqu'à la fin de `buffer`). @@ -243,7 +243,7 @@ alert( dataView.getUint32(0) ); // 4294967295 (Plus grand entier non signé en 3 dataView.setUint32(0, 0); // Fixe le nombre sous 4 octets à 0, fixant ainsi tous les octets à 0 ``` -`DataView` est utile lorsque l'on met des données sous plusieurs formats dans le même buffer. Par exemple, on stocke une séquence de paires (16-bit integer, 32-bit float). Le `DataView` nous permettra d'y accéder facilement. +`DataView` est utile lorsque l'on met des données sous plusieurs formats dans le même buffer. Par exemple, on stocke une séquence de paires (16-bit integer, 32-bit float). `DataView` nous permettra d'y accéder facilement. ## Résumé @@ -256,9 +256,9 @@ Pour faire presque n'importe quelle opération sur un `ArrayBuffer`, nous avons - `Uint8ClampedArray` -- pour les entiers de 8 bits, "clamps" them on assignment. - `Int8Array`, `Int16Array`, `Int32Array` -- pour les entiers signés (peuvent être négatifs). - `Float32Array`, `Float64Array` -- pour les nombres flottants signés de 32 et 64 bits. -- Ou d'une `DataView` -- la vue qui utilise des méthodes pour spécifier un format, e.g. `getUint8(offset)`. +- Ou d'un `DataView` -- la vue qui utilise des méthodes pour spécifier un format, e.g. `getUint8(offset)`. -Dans la majorité des cas, on crée et on opère directement sur les tableaux typés, laissant `ArrayBuffer` en arrière. On peut toujours y accéder avec `.buffer` et faire une nouvelle vie si besoin. +Dans la majorité des cas, on crée et on opère directement sur les tableaux typés, laissant `ArrayBuffer` en arrière. On peut toujours y accéder avec `.buffer` et faire une nouvelle vue si besoin. Il y a également 2 termes supplémentaires, qui sont utilisés dans les descriptions des méthodes pour travailler sur les données binaires: - `ArrayBufferView` qui est le terme pour tous les types de vues. pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy