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` 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 à 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); // 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, puis 0, 0, 0 (4 valeurs au total)
}
```
-## TypedArray
+## TypedArray - tableau typé
-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). Elles 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 pour représenter une des vues par dessus un `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 tableaux typés 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.
+Un constructeur `TypedArray` (soit `Int8Array` ou `Float64Array`, peut importe) se comporte différement en fonction du type des arguments.
-There are 5 variants of arguments:
+Il y a 5 variantes d'arguments:
```js
new TypedArray(buffer, [byteOffset], [length]);
@@ -91,92 +92,92 @@ 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`.
+ 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 tableau typé 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 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. 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. 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); // 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 tableau typé 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 tableau typé 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 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).
-To access the `ArrayBuffer`, there are properties:
-- `arr.buffer` -- references the `ArrayBuffer`.
-- `arr.byteLength` -- the length of the `ArrayBuffer`.
+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`.
-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 tableaux typés:
-- `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 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="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`.
+Car en effet `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 tableau typé ? 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é:
-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:
-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;
@@ -185,88 +186,86 @@ 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` 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` 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 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`.
-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 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`. Elle 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 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`).
-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). `DataView` nous permettra d'y accéder facilement.
-## 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 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'un `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 tableaux typés, laissant `ArrayBuffer` en arrière. On peut toujours y accéder avec `.buffer` et faire une nouvelle vue 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 "toutes sortes de données binaires" -- un `ArrayBuffer` ou une vue par dessus.
-Here's a cheatsheet:
+Voici un résumé:
diff --git a/4-binary/index.md b/4-binary/index.md
index 2b0c5dc82..e500f2edc 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.
+Manipulation des données binaires et les fichiers en JavaScript.
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: