You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: 1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md
+4-5Lines changed: 4 additions & 5 deletions
Original file line number
Diff line number
Diff line change
@@ -1,5 +1,4 @@
1
-
2
-
Essayez de lancer:
1
+
Essayez de lancer :
3
2
4
3
```js run
5
4
let str ="Hello";
@@ -10,15 +9,15 @@ alert(str.test);
10
9
```
11
10
12
11
Selon que vous utilisiez `use strict` ou non, le résultat peut être :
12
+
13
13
1.`undefined` (pas de mode strict)
14
14
2. une erreur (mode strict)
15
15
16
-
Pourquoi ? Répétons ce qui se pase à la ligne`(*)`:
16
+
Pourquoi ? Répétons ce qui se pase à la ligne`(*)`:
17
17
18
18
1. Lorsqu'on accède à une propiété de `str`, un "wrapper d'objet" (conteneur) est créé.
19
19
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`.
22
21
23
22
**Cet exemple montre clairement que les primitives ne sont pas des objets.**
Copy file name to clipboardExpand all lines: 1-js/05-data-types/01-primitives-methods/article.md
+21-22Lines changed: 21 additions & 22 deletions
Original file line number
Diff line number
Diff line change
@@ -1,21 +1,21 @@
1
1
# Méthodes des primitives
2
2
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).
4
4
5
5
Examinons les principales différences entre primitives et objets.
6
6
7
7
Une primitive
8
+
8
9
- Est une valeur de type primitif.
9
10
- Il existe 7 types primitifs : `string`, `number`, `bigint`, `boolean`, `symbol`, `null` et `undefined`.
10
11
11
-
12
12
Un objet
13
+
13
14
- 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.
15
16
16
17
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.
17
18
18
-
19
19
```js run
20
20
let john = {
21
21
name:"John",
@@ -31,26 +31,26 @@ Nous avons donc crée un objet `john` avec la méthode `sayHI`.
31
31
32
32
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.
33
33
34
-
Mais, ces fonctionnalités ont un coût!
34
+
Mais, ces fonctionnalités ont un coût!
35
35
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.
37
37
38
38
## Une primitive en tant qu'objet
39
39
40
-
Voici le paradoxe auquel est confronté le créateur de JavaScript:
40
+
Voici le paradoxe auquel est confronté le créateur de JavaScript:
41
41
42
42
- 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.
43
43
- Les primitives doivent être aussi rapides et légères que possible.
44
44
45
-
La solution semble peu commode, mais la voici:
45
+
La solution semble peu commode, mais la voici:
46
46
47
47
1. Les primitives sont toujours primitives. Une seule valeur, au choix.
48
48
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.
49
49
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.
50
50
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.
52
52
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.
Simple, non? Voici ce qui se passe réellement dans `str.toUpperCase()`:
64
64
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()`.
66
66
2. Cette méthode s'exécute et retourne une nouvelle chaîne de caractères (indiquée par `alert`).
67
67
3. L'objet spécial est détruit, laissant le primitif `str` seul.
68
68
69
69
Les primitives peuvent donc fournir des méthodes, mais elles restent légères.
70
70
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.
72
72
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:
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).
82
82
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)`.
86
85
87
86
En JavaScript, cela est également possible pour des raisons historique, mais fortement **déconseillé**. Cela peut très vite se compliquer à plusieurs endroits.
88
87
89
-
Par exemple:
88
+
Par exemple:
90
89
91
90
```js run
92
91
alert( typeof0 ); // "number"
@@ -104,17 +103,17 @@ if (zero) { // zéro est vrai, parce que c'est un objet
104
103
}
105
104
```
106
105
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).
108
107
109
-
Par exemple, ceci est entièrement valide:
108
+
Par exemple, ceci est entièrement valide:
110
109
111
110
```js
112
111
let num =Number("123"); // convertir une chaîne de caractères en nombre
113
112
```
114
113
````
115
114
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".
118
117
119
118
Une tentative d'accès à une propriété d'une telle valeur donnerait l'erreur suivante:
120
119
@@ -125,5 +124,5 @@ alert(null.test); // error
125
124
126
125
## Résumé
127
126
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.
129
128
- 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.
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.
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 :
Copy file name to clipboardExpand all lines: 1-js/05-data-types/02-number/2-why-rounded-down/task.md
+5-6Lines changed: 5 additions & 6 deletions
Original file line number
Diff line number
Diff line change
@@ -2,21 +2,20 @@ importance: 4
2
2
3
3
---
4
4
5
-
# Pourquoi 6.35.toFixed(1) == 6.3?
5
+
# Pourquoi 6.35.toFixed(1) == 6.3?
6
6
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).
8
8
9
-
Par exemple:
9
+
Par exemple:
10
10
11
11
```js run
12
12
alert( 1.35.toFixed(1) ); // 1.4
13
13
```
14
14
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`?
Copy file name to clipboardExpand all lines: 1-js/05-data-types/02-number/3-repeat-until-number/solution.md
+2-4Lines changed: 2 additions & 4 deletions
Original file line number
Diff line number
Diff line change
@@ -1,4 +1,3 @@
1
-
2
1
```js run demo
3
2
functionreadNumber() {
4
3
let num;
@@ -8,7 +7,7 @@ function readNumber() {
8
7
} while ( !isFinite(num) );
9
8
10
9
if (num ===null|| num ==='') returnnull;
11
-
10
+
12
11
return+num;
13
12
}
14
13
@@ -19,5 +18,4 @@ La solution est un peu plus complexe qu'elle n'y paraît car nous devons gérer
19
18
20
19
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`.
21
20
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`.
Copy file name to clipboardExpand all lines: 1-js/05-data-types/02-number/9-random-int-min-max/solution.md
+5-5Lines changed: 5 additions & 5 deletions
Original file line number
Diff line number
Diff line change
@@ -1,10 +1,10 @@
1
1
# La solution simple mais fausse
2
2
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:
4
4
5
5
```js run
6
6
functionrandomInteger(min, max) {
7
-
let rand = min +Math.random() * (max - min);
7
+
let rand = min +Math.random() * (max - min);
8
8
returnMath.round(rand);
9
9
}
10
10
@@ -15,7 +15,7 @@ La fonction marche, mais elle est incorrecte. La probabilité d'obtenir les vale
15
15
16
16
Si vous exécutez l'exemple ci-dessous plusieurs fois, vous verrez facilement que `2` apparaît le plus souvent.
17
17
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:
19
19
20
20
```js no-beautify
21
21
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
27
27
28
28
# La bonne solution
29
29
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:
31
31
32
32
```js run
33
33
*!*
@@ -55,7 +55,7 @@ function randomInteger(min, max) {
55
55
alert( randomInteger(1, 3) );
56
56
```
57
57
58
-
Maintenant,tous les intervalles sont mappés de cette façon:
58
+
Maintenant,tous les intervalles sont mappés de cette façon:
0 commit comments