Skip to content

Commit 4020dc6

Browse files
authored
Merge pull request #461 from ArmandDelessert/patch-1-js-05-data-types
Apporte plusieurs corrections au chapitre 1.5 (Data Types)
2 parents 9198767 + cf97412 commit 4020dc6

File tree

45 files changed

+584
-655
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

45 files changed

+584
-655
lines changed

1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,4 @@
1-
2-
Essayez de lancer:
1+
Essayez de lancer :
32

43
```js run
54
let str = "Hello";
@@ -10,15 +9,15 @@ alert(str.test);
109
```
1110

1211
Selon que vous utilisiez `use strict` ou non, le résultat peut être :
12+
1313
1. `undefined` (pas de mode strict)
1414
2. une erreur (mode strict)
1515

16-
Pourquoi ? Répétons ce qui se pase à la ligne`(*)`:
16+
Pourquoi ? Répétons ce qui se pase à la ligne `(*)`:
1717

1818
1. Lorsqu'on accède à une propiété de `str`, un "wrapper d'objet" (conteneur) est créé.
1919
2. En mode strict, l'écriture à l'intérieur est une erreur.
20-
3. Sinon, l'opération avec la propriété est poursuivie, l'objet obtient la propriété `test`, mais après cela, "l'objet wrapper" disparaît, de sorte que dans la dernière ligne, `str` n'a aucune trace de la propriété.
21-
20+
3. Sinon, l'opération avec la propriété est poursuivie, l'objet obtient la propriété `test`. Mais après cela, "l'objet wrapper" disparaît, de sorte que dans la dernière ligne, `str` n'a aucune trace de la propriété `test`.
2221

2322
**Cet exemple montre clairement que les primitives ne sont pas des objets.**
2423

1-js/05-data-types/01-primitives-methods/1-string-new-property/task.md

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,6 @@ importance: 5
44

55
# Pouvons-nous ajouter une propiété à une primitive ?
66

7-
87
Considérons le code suivant:
98

109
```js
@@ -15,4 +14,4 @@ str.test = 5;
1514
alert(str.test);
1615
```
1716

18-
Qu'en pensez-vous, ça va marcher? Qu'est-ce qui sera montré?
17+
Pensez-vous que ça va fonctionner ? Qu'est-ce qui sera affiché ?

1-js/05-data-types/01-primitives-methods/article.md

Lines changed: 21 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,21 @@
11
# Méthodes des primitives
22

3-
JavaScript nous permet de travailler avec des primitives (chaînes de caractères, nombres, etc.) comme s'il s'agissait d'objets. Ils prévoient également des méthodes pour les appeler en tant que tel. Nous étudierons cela très bientôt, mais nous verrons d'abord comment cela fonctionne car, bien entendu, les primitives ne sont pas des objets ( et nous allons rendre cela plus clair).
3+
JavaScript nous permet de travailler avec des primitives (chaînes de caractères, nombres, etc.) comme s'il s'agissait d'objets. Ils prévoient également des méthodes pour les appeler en tant que tel. Nous étudierons cela très bientôt, mais nous verrons d'abord comment cela fonctionne car, bien entendu, les primitives ne sont pas des objets (et nous allons rendre cela plus clair).
44

55
Examinons les principales différences entre primitives et objets.
66

77
Une primitive
8+
89
- Est une valeur de type primitif.
910
- Il existe 7 types primitifs : `string`, `number`, `bigint`, `boolean`, `symbol`, `null` et `undefined`.
1011

11-
1212
Un objet
13+
1314
- Est capable de stocker plusieurs valeurs en tant que propriétés.
14-
- Peut être crée avec `{}`, par exemple:`{name:"John", age: 30}`. Il existe d'autres types d'objets en JavaScript : les fonctions, par exemple, sont des objets.
15+
- Peut être créé avec `{}`, par exemple : `{name: "John", age: 30}`. Il existe d'autres types d'objets en JavaScript. Les fonctions, par exemple, sont des objets.
1516

1617
L'une des meilleurs choses à propos des objets est que nous pouvons stocker une fonction en tant que l'une de ses propriétés.
1718

18-
1919
```js run
2020
let john = {
2121
name: "John",
@@ -31,26 +31,26 @@ Nous avons donc crée un objet `john` avec la méthode `sayHI`.
3131

3232
De nombreux objets intégrés existent déjà, tels que ceux qui fonctionnent avec des dates, des erreurs, des éléments HTML, etc. Ils ont des propriétés et des méthodes différente.
3333

34-
Mais, ces fonctionnalités ont un coût!
34+
Mais, ces fonctionnalités ont un coût !
3535

36-
Les objets sont "plus lourds" que les primitives. Ils ont besoin de ressources supplémentaires pour soutenir le mécanisme interne.
36+
Les objets sont "plus lourds" que les primitives. Ils ont besoin de ressources supplémentaires pour soutenir le mécanisme interne.
3737

3838
## Une primitive en tant qu'objet
3939

40-
Voici le paradoxe auquel est confronté le créateur de JavaScript:
40+
Voici le paradoxe auquel est confronté le créateur de JavaScript :
4141

4242
- Il y a beaucoup de choses que l'on voudrait faire avec une primitive telle qu'une chaîne de caractères ou un nombre. Ce serait génial d'y avoir accès avec des méthodes.
4343
- Les primitives doivent être aussi rapides et légères que possible.
4444

45-
La solution semble peu commode, mais la voici:
45+
La solution semble peu commode, mais la voici :
4646

4747
1. Les primitives sont toujours primitives. Une seule valeur, au choix.
4848
2. Le langage permet d'accéder aux méthodes et aux propriétés des chaînes de caractères, des nombres, des booléens et des symboles.
4949
3. Pour que cela fonctionne, un "wrapper d'objet" (conteneur) spécial est crée pour fournir la fonctionnalité supplémentaire, puis il est détruit.
5050

51-
Les "wrapper d'objets" (conteneurs) sont différents pour chaque type de primitive et sont appelés: `String`, `Number`, `Boolean` et `Symbol`. Ainsi, ils fournissent différents ensembles de méthodes.
51+
Les "wrapper d'objets" (conteneurs) sont différents pour chaque type de primitive et sont appelés `String`, `Number`, `Boolean` et `Symbol`. Ainsi, ils fournissent différents ensembles de méthodes.
5252

53-
Par exemple, il existe une méthode de string [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) qui renvoie une chaîne de caractères `str` en majuscule.
53+
Par exemple, il existe une méthode de string [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) qui renvoie une chaîne de caractères `str` en majuscule.
5454

5555
Voici comment ça fonctionne:
5656

@@ -62,15 +62,15 @@ alert( str.toUpperCase() ); // HELLO
6262

6363
Simple, non? Voici ce qui se passe réellement dans `str.toUpperCase()`:
6464

65-
1. La chaîne de caractères `str` est une primitive. Ainsi, au moment d'accéder à sa propriété, un objet spécial est crée, qui connaît la valeur de la chaîne de caractères et possède des méthodes utiles, comme `toUpperCase()`.
65+
1. La chaîne de caractères `str` est une primitive. Ainsi, au moment d'accéder à sa propriété, un objet spécial est crée, qui connaît la valeur de la chaîne de caractères et possède des méthodes utiles, comme `toUpperCase()`.
6666
2. Cette méthode s'exécute et retourne une nouvelle chaîne de caractères (indiquée par `alert`).
6767
3. L'objet spécial est détruit, laissant le primitif `str` seul.
6868

6969
Les primitives peuvent donc fournir des méthodes, mais elles restent légères.
7070

71-
Le moteur JavaScript optimise fortement ce processus. il peut même ignorer la création de l'objet supplémentaire. Mais il doit toujours adhérer à la spécification et se comporter comme s'il en crée une.
71+
Le moteur JavaScript optimise fortement ce processus. Il peut même ignorer la création de l'objet supplémentaire. Mais il doit toujours adhérer à la spécification et se comporter comme s'il en crée un.
7272

73-
Un nombre a ses propres méthodes, par exemple, [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) arrondit le nombre à la précision indiquée:
73+
Un nombre a ses propres méthodes, par exemple, [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) arrondit le nombre à la précision indiquée :
7474

7575
```js run
7676
let n = 1.23456;
@@ -80,13 +80,12 @@ alert( n.toFixed(2) ); // 1.23
8080

8181
Nous verrons des méthodes plus spécifiques dans les chapitres [Nombres](https://javascript.info/number) et [Chaînes de caractères](https://javascript.info/string).
8282

83-
84-
````warn header="Les constructeurs `String/Number/Boolean` sont réservés à un usage interne."
85-
Certains langages comme Java nous permettent de créer des "wrapper d'objet" (conteneur) pour les primitives en utilisant une syntaxe telle que `new Number(1)` ou `new Boolean (false)`.
83+
````warn header="Les constructeurs `String`, `Number` et `Boolean` sont réservés à un usage interne."
84+
Certains langages comme Java nous permettent de créer des "wrapper d'objet" (conteneur) pour les primitives en utilisant une syntaxe telle que `new Number(1)` ou `new Boolean(false)`.
8685

8786
En JavaScript, cela est également possible pour des raisons historique, mais fortement **déconseillé**. Cela peut très vite se compliquer à plusieurs endroits.
8887

89-
Par exemple:
88+
Par exemple :
9089

9190
```js run
9291
alert( typeof 0 ); // "number"
@@ -104,17 +103,17 @@ if (zero) { // zéro est vrai, parce que c'est un objet
104103
}
105104
```
106105

107-
Par ailleurs, utiliser les mêmes fonctions `Chaîne / Nombre / Booléen` sans `new` est une chose totalement valide et même recommandée. Ils convertissent une valeur dans le type correspondant : une chaîne de caractères, un nombre ou un booléen (primitive).
106+
Par ailleurs, utiliser les mêmes fonctions `String`, `Number` et `Boolean` sans `new` est une chose totalement valide et même recommandée. Ils convertissent une valeur dans le type correspondant : une chaîne de caractères, un nombre ou un booléen (primitive).
108107

109-
Par exemple, ceci est entièrement valide:
108+
Par exemple, ceci est entièrement valide :
110109

111110
```js
112111
let num = Number("123"); // convertir une chaîne de caractères en nombre
113112
```
114113
````
115114
116-
````warn header="null/undefined n'ont pas de méthode"
117-
Les primitives spéciales null et undefined sont des exceptions. Elles n'ont pas de "wrapper d'objet" (conteneur) correspondants et ne fournissent aucune méthode. En un sens, elles sont "les plus primitives".
115+
````warn header="`null` / `undefined` n'ont pas de méthode"
116+
Les primitives spéciales `null` et `undefined` sont des exceptions. Elles n'ont pas de "wrapper d'objet" (conteneur) correspondants et ne fournissent aucune méthode. En un sens, elles sont "les plus primitives".
118117
119118
Une tentative d'accès à une propriété d'une telle valeur donnerait l'erreur suivante:
120119
@@ -125,5 +124,5 @@ alert(null.test); // error
125124

126125
## Résumé
127126

128-
- Les primitives sauf null et undefined fournissent de nombreuses méthodes utiles. Nous étudierons cela dans les prochains chapitres.
127+
- Les primitives sauf `null` et `undefined` fournissent de nombreuses méthodes utiles. Nous étudierons cela dans les prochains chapitres.
129128
- Officiellement, ces méthodes fonctionnent via des objets temporaires, mais les moteurs JavaScript sont bien ajustés pour optimiser cela en interne, elles ne sont donc pas coûteuses à appeler.

1-js/05-data-types/02-number/1-sum-interface/solution.md

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,3 @@
1-
2-
31
```js run demo
42
let a = +prompt("Le premier numéro?", "");
53
let b = +prompt("Le second numéro?", "");
Lines changed: 7 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,33 +1,31 @@
1-
En interne, la fraction décimale `6.35` est un fichier binaire sans fin. Comme toujours dans de tels cas, il est stocké avec une perte de précision.
1+
En interne, la fraction décimale `6.35` est un nombre binaire sans fin. Comme toujours dans de tels cas, il est stocké avec une perte de précision.
22

3-
Voyons cela:
3+
Voyons cela :
44

55
```js run
66
alert( 6.35.toFixed(20) ); // 6.34999999999999964473
77
```
88

9-
La perte de précision peut causer à la fois une augmentation et une diminution d'un nombre. Dans ce cas particulier, le nombre diminue un peu, c'est pourquoi il a été arrondi à 3.
9+
La perte de précision peut causer à la fois une augmentation et une diminution d'un nombre. Dans ce cas particulier, le nombre diminue un peu, c'est pourquoi il a été arrondi à 6.3.
1010

11-
Et quand est-il de `1.35`?
11+
Et quand est-il de `1.35` ?
1212

1313
```js run
1414
alert( 1.35.toFixed(20) ); // 1.35000000000000008882
1515
```
1616

17-
Ici, la perte de précision rend le nombre un peu plus grand, c'est pourquoi il a été arrondi à 4.
17+
Ici, la perte de précision rend le nombre un peu plus grand, c'est pourquoi il a été arrondi à 1.4.
1818

1919
**Comment pouvons-nous résoudre le problème avec `6.35` si nous voulons qu'il soit arrondi correctement ?**
2020

21-
Nous devons le rapprocher d'un nombre entier avant d'arrondir:
21+
Nous devons le rapprocher d'un nombre entier avant d'arrondir :
2222

2323
```js run
2424
alert( (6.35 * 10).toFixed(20) ); // 63.50000000000000000000
2525
```
2626

27-
Notez que `63.5` n'a aucune perte de précision. C'est parce que la partie décimale `0.5` est en réalité `1/2`. Les fractions divisées par les puissances de `2` sont représentées sans perte de précision dans le système binaire, on peut maintenant les arrondir:
28-
27+
Notez que `63.5` n'a aucune perte de précision. C'est parce que la partie décimale `0.5` est en réalité `1/2`. Les fractions divisées par les puissances de `2` sont représentées sans perte de précision dans le système binaire, on peut maintenant les arrondir :
2928

3029
```js run
3130
alert( Math.round(6.35 * 10) / 10); // 6.35 -> 63.5 -> 64(arrondi) -> 6.4
3231
```
33-

1-js/05-data-types/02-number/2-why-rounded-down/task.md

Lines changed: 5 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2,21 +2,20 @@ importance: 4
22

33
---
44

5-
# Pourquoi 6.35.toFixed(1) == 6.3?
5+
# Pourquoi 6.35.toFixed(1) == 6.3 ?
66

7-
Selon la documentation, `Math.round` et `toFixed` arrondissent tous les deux au nombre le plus proche: `0..4` arrondi par défaut (à la baisse) tantdis que `5..9` arrondi par excès (à la hausse).
7+
Selon la documentation, `Math.round` et `toFixed` arrondissent tous les deux au nombre le plus proche : `0..4` arrondi par défaut (à la baisse) tantdis que `5..9` arrondi par excès (à la hausse).
88

9-
Par exemple:
9+
Par exemple :
1010

1111
```js run
1212
alert( 1.35.toFixed(1) ); // 1.4
1313
```
1414

15-
Dans l'exemple similaire ci-dessous, pourquoi est-ce que `6.35` est arrondi à `6.3` et non `6.4`?
15+
Dans l'exemple similaire ci-dessous, pourquoi est-ce que `6.35` est arrondi à `6.3` et non `6.4` ?
1616

1717
```js run
1818
alert( 6.35.toFixed(1) ); // 6.3
1919
```
2020

21-
Comment arrondir `6.35` de la bonne manière?
22-
21+
Comment arrondir `6.35` de la bonne manière ?

1-js/05-data-types/02-number/3-repeat-until-number/solution.md

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
21
```js run demo
32
function readNumber() {
43
let num;
@@ -8,7 +7,7 @@ function readNumber() {
87
} while ( !isFinite(num) );
98

109
if (num === null || num === '') return null;
11-
10+
1211
return +num;
1312
}
1413

@@ -19,5 +18,4 @@ La solution est un peu plus complexe qu'elle n'y paraît car nous devons gérer
1918

2019
Nous répétons donc la demande jusqu'à ce qu'il s'agisse d'un "nombre régulier". Les lignes `null` (cancel) et vide répondent également à cette condition car, sous forme numérique, elles valent `0`.
2120

22-
Après que nous nous sommes arrêtés, nous devons traiter spécialement les lignes `null` et vides (retourner `null`), car les convertit en nombre renverrait `0`.
23-
21+
Après que nous nous sommes arrêtés, nous devons traiter spécialement les lignes `null` et vides (retourner `null`), car les convertir en nombre renverrait `0`.

1-js/05-data-types/02-number/3-repeat-until-number/task.md

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,4 +11,3 @@ La valeur résultante doit être renvoyée sous forme de nombre.
1111
Le visiteur peut également arrêter le processus en entrant une ligne vide ou en appuyant sur "CANCEL". Dans ce cas, la fonction doit renvoyer `null`.
1212

1313
[Lancer la démo]
14-
Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
1-
C'est parce que je n'aurais jamais égalé 10.
1+
C'est parce que `i` ne sera jamais exactement égal à 10.
22

3-
Exécutez-le pour voir les valeurs *réelles* de i:
3+
Exécutez-le pour voir les valeurs *réelles* de i :
44

55
```js run
66
let i = 0;
@@ -12,6 +12,6 @@ while (i < 11) {
1212

1313
Aucun d'entre eux n'est exactement `10`.
1414

15-
De telles choses se produisent à cause des pertes de précision lors de l'ajout de fractions comme `0.2`.
15+
De telles choses se produisent à cause des pertes de précision lors de l'ajout des fractions comme `0.2`.
1616

17-
Conclusion: évitez les contrôles d"égalité lorsque vous travaillez avec des fractions décimales."
17+
Conclusion : évitez les contrôles d'égalité lorsque vous travaillez avec des fractions décimales.

1-js/05-data-types/02-number/4-endless-loop-error/task.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ importance: 4
44

55
# Une boucle infinie
66

7-
Cette boucle est infinie. Ça ne finit jamais. Pourquoi?
7+
Cette boucle est infinie. Ça ne finit jamais. Pourquoi ?
88

99
```js
1010
let i = 0;
Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,18 @@
11
Nous devons "mapper" toutes les valeurs de l'intervalle 0...1 en valeurs de `min` à `max`.
22

3-
Cela peut être fait en deux étapes:
3+
Cela peut être fait en deux étapes :
44

5-
1. Si nous multiplions un nombre aléatoire de 0... 1 par `max-min`, l'intervalle des valeurs possible augmente de `0..1` à `0..max-min`.
5+
1. Si nous multiplions un nombre aléatoire de 0...1 par `max-min`, l'intervalle des valeurs possible augmente de `0..1` à `0..max-min`.
66
2. Maintenant, si nous ajoutons `min`, l'intervalle possible devient de `min` à `max`.
77

8-
La fonction:
8+
La fonction :
99

1010
```js run
1111
function random(min, max) {
1212
return min + Math.random() * (max - min);
1313
}
1414

15-
alert( random(1, 5) );
16-
alert( random(1, 5) );
17-
alert( random(1, 5) );
15+
alert( random(1, 5) );
16+
alert( random(1, 5) );
17+
alert( random(1, 5) );
1818
```
19-

1-js/05-data-types/02-number/8-random-min-max/task.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ La fonction intégrée `Math.random()` crée une valeur aléatoire de 0 à 1 (1
88

99
Ecrivez la fonction `random(min, max)` pour générer un nombre aléatoire compris entre `min` et `max` (max non compris).
1010

11-
Quelques exemples:
11+
Quelques exemples :
1212

1313
```js
1414
alert( random(1, 5) ); // 1.2345623452

1-js/05-data-types/02-number/9-random-int-min-max/solution.md

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,10 @@
11
# La solution simple mais fausse
22

3-
La solution la plus simple mais fausse serait de générer une valeur de `min` à `max` et de l'arrondir:
3+
La solution la plus simple mais fausse serait de générer une valeur de `min` à `max` et de l'arrondir :
44

55
```js run
66
function randomInteger(min, max) {
7-
let rand = min + Math.random() * (max - min);
7+
let rand = min + Math.random() * (max - min);
88
return Math.round(rand);
99
}
1010

@@ -15,7 +15,7 @@ La fonction marche, mais elle est incorrecte. La probabilité d'obtenir les vale
1515

1616
Si vous exécutez l'exemple ci-dessous plusieurs fois, vous verrez facilement que `2` apparaît le plus souvent.
1717

18-
Cela se produit car `Math.round()` obtient des nombres aléatoires à partir de l'intervalle `1..3` et les arrondit comme ici:
18+
Cela se produit car `Math.round()` obtient des nombres aléatoires à partir de l'intervalle `1..3` et les arrondit comme ici :
1919

2020
```js no-beautify
2121
values from 1 ... to 1.4999999999 devient 1
@@ -27,7 +27,7 @@ Maintenant, nous pouvons clairement voir que `1` obtient deux fois moins de vale
2727

2828
# La bonne solution
2929

30-
il existe de nombreuses solutions correctes à la tâche. L'une d'elles consiste à ajuster les limites d'intervalle. Pour garantir les mêmes intervalles, nous pouvons générer des valeurs comprises entre `0.5` et `3.5`, ajoutant ainsi les probabilités requises:
30+
Il existe de nombreuses solutions correctes à la tâche. L'une d'elles consiste à ajuster les limites d'intervalle. Pour garantir les mêmes intervalles, nous pouvons générer des valeurs comprises entre `0.5` et `3.5`, ajoutant ainsi les probabilités requises :
3131

3232
```js run
3333
*!*
@@ -55,7 +55,7 @@ function randomInteger(min, max) {
5555
alert( randomInteger(1, 3) );
5656
```
5757

58-
Maintenant,tous les intervalles sont mappés de cette façon:
58+
Maintenant, tous les intervalles sont mappés de cette façon :
5959

6060
```js no-beautify
6161
values from 1 ... to 1.9999999999 devient 1

1-js/05-data-types/02-number/9-random-int-min-max/task.md

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -4,12 +4,11 @@ importance: 2
44

55
# Un entier aléatoire de min à max
66

7-
Créez une fonction `randomInteger(min, max)` qui génère un nombre entier aléatoire compris entre `min` et `max` (`min` et `max` inclut).
7+
Créez une fonction `randomInteger(min, max)` qui génère un nombre entier aléatoire compris entre `min` et `max` (`min` et `max` inclut).
88

99
Tout nombre compris dans l'intervalle `min..max` doit apparaître avec la même probabilité.
1010

11-
12-
Quelques exemples:
11+
Quelques exemples :
1312

1413
```js
1514
alert( randomInteger(1, 5) ); // 1

0 commit comments

Comments
 (0)