Skip to content

Commit dc98ddc

Browse files
authored
Merge pull request #26 from HachemiH/master
Translate Rest parameters and spread operator in french language
2 parents 36e8ed6 + f8e6d31 commit dc98ddc

File tree

1 file changed

+72
-72
lines changed
  • 1-js/06-advanced-functions/02-rest-parameters-spread-operator

1 file changed

+72
-72
lines changed
Lines changed: 72 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,20 @@
1-
# Rest parameters and spread operator
1+
# Les paramètres Rest et l'opérateur spread
22

3-
Many JavaScript built-in functions support an arbitrary number of arguments.
3+
De nombreuses fonctions intégrées à JavaScript prennent en charge un nombre arbitraire d'arguments.
44

5-
For instance:
5+
Par exemple :
66

7-
- `Math.max(arg1, arg2, ..., argN)` -- returns the greatest of the arguments.
8-
- `Object.assign(dest, src1, ..., srcN)` -- copies properties from `src1..N` into `dest`.
9-
- ...and so on.
7+
- `Math.max(arg1, arg2, ..., argN)` -- renvoie le plus grand des arguments.
8+
- `Object.assign(dest, src1, ..., srcN)` -- copie les propriétés de `src1..N` dans `dest`.
9+
- ... etc.
1010

11-
In this chapter we'll learn how to do the same. And, more importantly, how to feel comfortable working with such functions and arrays.
11+
Dans ce chapitre, nous allons apprendre à faire de même. Et, plus important encore, comment être à l'aise avec ces fonctions et ces tableaux.
1212

13-
## Rest parameters `...`
13+
## Les paramètres Rest `...`
1414

15-
A function can be called with any number of arguments, no matter how it is defined.
15+
Une fonction peut être appelée avec un nombre quelconque d'arguments, peu importe comment elle a été définie.
1616

17-
Like here:
17+
Comme ici :
1818
```js run
1919
function sum(a, b) {
2020
return a + b;
@@ -23,14 +23,14 @@ function sum(a, b) {
2323
alert( sum(1, 2, 3, 4, 5) );
2424
```
2525

26-
There will be no error because of "excessive" arguments. But of course in the result only the first two will be counted.
26+
Il n'y aura pas d'erreur en raison d'arguments "excessifs". Mais bien sûr, dans le résultat, seuls les deux premiers seront comptés.
2727

28-
The rest parameters can be mentioned in a function definition with three dots `...`. They literally mean "gather the remaining parameters into an array".
28+
Les paramètres restants peuvent être mentionnés dans une fonction définition à trois points `...`. Ils signifient littéralement "rassemblez les paramètres restants dans un tableau".
2929

30-
For instance, to gather all arguments into array `args`:
30+
Par exemple, pour rassembler tous les arguments dans un tableau `args` :
3131

3232
```js run
33-
function sumAll(...args) { // args is the name for the array
33+
function sumAll(...args) { // args est le nom du tableau
3434
let sum = 0;
3535

3636
for (let arg of args) sum += arg;
@@ -43,15 +43,15 @@ alert( sumAll(1, 2) ); // 3
4343
alert( sumAll(1, 2, 3) ); // 6
4444
```
4545

46-
We can choose to get the first parameters as variables, and gather only the rest.
46+
Nous pouvons choisir d’obtenir les premiers paramètres sous forme de variables et de ne rassembler que le reste.
4747

48-
Here the first two arguments go into variables and the rest go into `titles` array:
48+
Ici, les deux premiers arguments vont dans les variables et le reste dans le tableau `titles` :
4949

5050
```js run
5151
function showName(firstName, lastName, ...titles) {
5252
alert( firstName + ' ' + lastName ); // Julius Caesar
5353

54-
// the rest go into titles array
54+
// le reste va dans le tableau titles
5555
// i.e. titles = ["Consul", "Imperator"]
5656
alert( titles[0] ); // Consul
5757
alert( titles[1] ); // Imperator
@@ -61,55 +61,55 @@ function showName(firstName, lastName, ...titles) {
6161
showName("Julius", "Caesar", "Consul", "Imperator");
6262
```
6363

64-
````warn header="The rest parameters must be at the end"
65-
The rest parameters gather all remaining arguments, so the following does not make sense and causes an error:
64+
````warn header="Les paramètres rest doivent être à la fin"
65+
Les paramètres rest regroupent tous les arguments restants. Par conséquent, ce qui suit n'a pas de sens et génère une erreur :
6666
6767
```js
68-
function f(arg1, ...rest, arg2) { // arg2 after ...rest ?!
68+
function f(arg1, ...rest, arg2) { // arg2 après ...rest ?!
6969
// error
7070
}
7171
```
7272
73-
The `...rest` must always be last.
73+
Le `...rest` doit toujours être le dernier.
7474
````
7575

76-
## The "arguments" variable
76+
## La variable "arguments"
7777

78-
There is also a special array-like object named `arguments` that contains all arguments by their index.
78+
Il existe également un objet spécial array-like nommé `arguments` qui contient tous les arguments en fonction de leur index.
7979

80-
For instance:
80+
Par exemple :
8181

8282
```js run
8383
function showName() {
8484
alert( arguments.length );
8585
alert( arguments[0] );
8686
alert( arguments[1] );
8787

88-
// it's iterable
88+
// c'est iterable
8989
// for(let arg of arguments) alert(arg);
9090
}
9191

92-
// shows: 2, Julius, Caesar
92+
// affiche : 2, Julius, Caesar
9393
showName("Julius", "Caesar");
9494

95-
// shows: 1, Ilya, undefined (no second argument)
95+
// affiche : 1, Ilya, undefined (pas de second argument)
9696
showName("Ilya");
9797
```
9898

99-
In old times, rest parameters did not exist in the language, and using `arguments` was the only way to get all arguments of the function, no matter their total number.
99+
Autrefois, les paramètres rest n'existaient pas dans le langage, et utiliser les `arguments` était le seul moyen d'obtenir tous les arguments de la fonction, quel que soit leur nombre total.
100100

101-
And it still works, we can use it today.
101+
Et cela fonctionne toujours, nous pouvons l'utiliser aujourd'hui.
102102

103-
But the downside is that although `arguments` is both array-like and iterable, it's not an array. It does not support array methods, so we can't call `arguments.map(...)` for example.
103+
Mais l’inconvénient est que, bien que les `arguments` ressemblent à un tableau et qu’ils soient itératifs, ce n’est pas un tableau. Il ne supporte pas les méthodes de tableau, nous ne pouvons donc pas appeler `arguments.map(...)` par exemple.
104104

105-
Also, it always contains all arguments. We can't capture them partially, like we did with rest parameters.
105+
De plus, il contient toujours tous les arguments. Nous ne pouvons pas les capturer partiellement, comme nous l’avons fait avec les paramètres rest.
106106

107-
So when we need these features, then rest parameters are preferred.
107+
Ainsi, lorsque nous avons besoin de ces fonctionnalités, les paramètres rest sont préférés.
108108

109-
````smart header="Arrow functions do not have `\"arguments\"`"
110-
If we access the `arguments` object from an arrow function, it takes them from the outer "normal" function.
109+
````smart header="Les fonctions fléchées n'ont pas d'`\"arguments\"`"
110+
Si nous accédons à l'objet `arguments` à partir d'une fonction fléchée, il le prend à la fonction externe "normale".
111111

112-
Here's an example:
112+
Voici un exemple :
113113

114114
```js run
115115
function f() {
@@ -121,23 +121,23 @@ f(1); // 1
121121
```
122122
````
123123
124-
As we remember, arrow functions don't have their own `this`. Now we know they don't have the special `arguments` object either.
124+
Comme nous nous en souvenons, les fonctions fléchées n’ont pas leur propre `this`. Nous savons maintenant qu’ils n’ont pas non plus l’objet spécial `arguments`.
125125
126-
## Spread operator [#spread-operator]
126+
## L'opérateur Spread [#spread-operator]
127127
128-
We've just seen how to get an array from the list of parameters.
128+
Nous venons de voir comment obtenir un tableau à partir de la liste de paramètres.
129129
130-
But sometimes we need to do exactly the reverse.
130+
Mais parfois, nous devons faire exactement l'inverse.
131131
132-
For instance, there's a built-in function [Math.max](mdn:js/Math/max) that returns the greatest number from a list:
132+
Par exemple, il existe une fonction intégrée [Math.max](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Math/max) qui renvoie le plus grand nombre d'une liste :
133133
134134
```js run
135135
alert( Math.max(3, 5, 1) ); // 5
136136
```
137137
138-
Now let's say we have an array `[3, 5, 1]`. How do we call `Math.max` with it?
138+
Maintenant, disons que nous avons un tableau `[3, 5, 1]`. Comment appelons-nous `Math.max` avec ?
139139
140-
Passing it "as is" won't work, because `Math.max` expects a list of numeric arguments, not a single array:
140+
Le passer "tel quel" ne fonctionnera pas, car `Math.max` attend une liste d’arguments numériques et non un tableau :
141141
142142
```js run
143143
let arr = [3, 5, 1];
@@ -147,21 +147,21 @@ alert( Math.max(arr) ); // NaN
147147
*/!*
148148
```
149149
150-
And surely we can't manually list items in the code `Math.max(arr[0], arr[1], arr[2])`, because we may be unsure how many there are. As our script executes, there could be a lot, or there could be none. And that would get ugly.
150+
Et nous ne pouvons sûrement pas lister manuellement les éléments dans le code `Math.max(arr[0], arr[1], arr[2])`, parce que nous pouvons ne pas savoir combien il y en a. Au fur et à mesure que notre script s'exécute, il peut y en avoir beaucoup ou pas du tout. Et ça deviendrait moche.
151151
152-
*Spread operator* to the rescue! It looks similar to rest parameters, also using `...`, but does quite the opposite.
152+
*Spread operator* à la rescousse! Il ressemble aux paramètres rest, en utilisant également `...`, mais fait tout le contraire.
153153
154-
When `...arr` is used in the function call, it "expands" an iterable object `arr` into the list of arguments.
154+
Quand `...arr` est utilisé dans l'appel de fonction, il "développe" un objet itérable `arr` dans la liste des arguments.
155155
156-
For `Math.max`:
156+
Pour `Math.max` :
157157
158158
```js run
159159
let arr = [3, 5, 1];
160160
161-
alert( Math.max(...arr) ); // 5 (spread turns array into a list of arguments)
161+
alert( Math.max(...arr) ); // 5 (spread transforme un tableau en une liste d'arguments)
162162
```
163163
164-
We also can pass multiple iterables this way:
164+
Nous pouvons aussi passer plusieurs iterables de cette façon :
165165
166166
```js run
167167
let arr1 = [1, -2, 3, 4];
@@ -170,7 +170,7 @@ let arr2 = [8, 3, -8, 1];
170170
alert( Math.max(...arr1, ...arr2) ); // 8
171171
```
172172
173-
We can even combine the spread operator with normal values:
173+
On peut même combiner l'opérateur spread avec des valeurs normales :
174174
175175
176176
```js run
@@ -180,7 +180,7 @@ let arr2 = [8, 3, -8, 1];
180180
alert( Math.max(1, ...arr1, 2, ...arr2, 25) ); // 25
181181
```
182182
183-
Also, the spread operator can be used to merge arrays:
183+
De plus, l'opérateur spread peut être utilisé pour fusionner des tableaux :
184184
185185
```js run
186186
let arr = [3, 5, 1];
@@ -190,56 +190,56 @@ let arr2 = [8, 9, 15];
190190
let merged = [0, ...arr, 2, ...arr2];
191191
*/!*
192192
193-
alert(merged); // 0,3,5,1,2,8,9,15 (0, then arr, then 2, then arr2)
193+
alert(merged); // 0,3,5,1,2,8,9,15 (0, ensuite arr, ensuite 2, ensuite arr2)
194194
```
195195
196-
In the examples above we used an array to demonstrate the spread operator, but any iterable will do.
196+
Dans les exemples ci-dessus, nous avons utilisé un tableau pour illustrer l'opérateur spread, mais toutes les fonctions itérables feront l'affaire.
197197
198-
For instance, here we use the spread operator to turn the string into array of characters:
198+
Par exemple, nous utilisons ici l'opérateur spread pour transformer le string en tableau de caractères :
199199
200200
```js run
201201
let str = "Hello";
202202
203203
alert( [...str] ); // H,e,l,l,o
204204
```
205205
206-
The spread operator internally uses iterators to gather elements, the same way as `for..of` does.
206+
L’opérateur spread utilise en interne des itérateurs pour rassembler les éléments, de la même manière que `for..of`.
207207
208-
So, for a string, `for..of` returns characters and `...str` becomes `"H","e","l","l","o"`. The list of characters is passed to array initializer `[...str]`.
208+
Donc, pour une chaine de caractères, `for..of` retourn des caractères et `...str` devient `"H","e","l","l","o"`. La liste de caractères est transmise à l'initialiseur de tableau `[...str]`.
209209
210-
For this particular task we could also use `Array.from`, because it converts an iterable (like a string) into an array:
210+
Pour cette tâche particulière, nous pourrions également utiliser `Array.from`, car il convertit un itérable (comme une chaîne de caractères) en un tableau :
211211
212212
```js run
213213
let str = "Hello";
214214
215-
// Array.from converts an iterable into an array
215+
// Array.from convertit un itérable en tableau
216216
alert( Array.from(str) ); // H,e,l,l,o
217217
```
218218
219-
The result is the same as `[...str]`.
219+
Le résultat est le même que `[...str]`.
220220
221-
But there's a subtle difference between `Array.from(obj)` and `[...obj]`:
221+
Mais il existe une différence subtile entre `Array.from(obj)` et `[...obj]` :
222222
223-
- `Array.from` operates on both array-likes and iterables.
224-
- The spread operator operates only on iterables.
223+
- `Array.from` fonctionne à la fois sur les tableaux et les iterables.
224+
- L'opérateur spread ne fonctionne que sur des iterables.
225225
226-
So, for the task of turning something into an array, `Array.from` tends to be more universal.
226+
Donc, pour transformer quelque chose en tableau, `Array.from` tend à être plus universel.
227227
228228
229-
## Summary
229+
## Résumé
230230
231-
When we see `"..."` in the code, it is either rest parameters or the spread operator.
231+
Quand on voit `"..."` dans le code, il s’agit soit des paramètres rest ou de l’opérateur spread.
232232
233-
There's an easy way to distinguish between them:
233+
Il existe un moyen facile de les distinguer :
234234
235-
- When `...` is at the end of function parameters, it's "rest parameters" and gathers the rest of the list of arguments into an array.
236-
- When `...` occurs in a function call or alike, it's called a "spread operator" and expands an array into a list.
235+
- Lorsque `...` se trouve à la fin des paramètres de fonction, il s'agit des "paramètres rest" et rassemble le reste de la liste des arguments dans un tableau.
236+
- Lorsque `...` est présent dans un appel de fonction ou similaire, on l'appelle "opérateur spread" (opérateur de propagation) et étend un tableau en une liste.
237237
238-
Use patterns:
238+
Modèles d'utilisation :
239239
240-
- Rest parameters are used to create functions that accept any number of arguments.
241-
- The spread operator is used to pass an array to functions that normally require a list of many arguments.
240+
- Les paramètres rest permettent de créer des fonctions acceptant un nombre quelconque d'arguments.
241+
- L'opérateur spread est utilisé pour passer un tableau à des fonctions nécessitant normalement une liste d'arguments.
242242
243-
Together they help to travel between a list and an array of parameters with ease.
243+
Ensemble, ils permettent de voyager facilement entre une liste et un tableau de paramètres.
244244
245-
All arguments of a function call are also available in "old-style" `arguments`: array-like iterable object.
245+
Tous les arguments d'un appel de fonction sont également disponibles dans les `arguments` "à l'ancienne" : objet itérable array-like.

0 commit comments

Comments
 (0)