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
Notez une chose très intéressante. Les méthodes intégrées telles que `filter`, `map` et autres renvoient des nouveaux objets exactement du type hérité `PowerArray`. Leur implémentation interne utilise la propriété d'objet `constructor` pour cela.
25
25
26
26
Dans l'exemple ci-dessus,
27
+
27
28
```js
28
29
arr.constructor=== PowerArray
29
30
```
@@ -34,7 +35,7 @@ Encore plus, nous pouvons personnaliser ce comportement.
34
35
35
36
Nous pouvons ajouter un accésseur statique spécial `Symbol.species` à la classe. S'il existe, il devrait renvoyer le constructeur que JavaScript utilisera en interne pour créer de nouvelles entités dans `map`, `filter`, etc.
36
37
37
-
Si nous souhaitons que des méthodes intégrées comme `map` ou `filter` renvoient des tableaux classiques, nous pouvons retourner `Array` dans `Symbol.species`, comme ici:
38
+
Si nous souhaitons que des méthodes intégrées comme `map` ou `filter` renvoient des tableaux classiques, nous pouvons retourner `Array` dans `Symbol.species`, comme ici:
38
39
39
40
```js run
40
41
classPowerArrayextendsArray {
@@ -57,7 +58,7 @@ alert(arr.isEmpty()); // false
57
58
let filteredArr =arr.filter(item=> item >=10);
58
59
59
60
*!*
60
-
// filteredArr n'est pas PowerArray, mais Array
61
+
// filteredArr n'est pas un PowerArray, mais un Array
61
62
*/!*
62
63
alert(filteredArr.isEmpty()); // Error: filteredArr.isEmpty is not a function
63
64
```
@@ -70,17 +71,17 @@ D'autres collections, telles que `Map` et `Set`, fonctionnent de la même maniè
70
71
71
72
## Pas d'héritage statique dans les éléments intégrés
72
73
73
-
Les objets intégrés ont leurs propres méthodes statiques, par exemple `Object.keys`,`Array.isArray` etc.
74
+
Les objets intégrés ont leurs propres méthodes statiques, par exemple `Object.keys`,`Array.isArray`, etc.
74
75
75
-
Comme nous le savons déjà, les classes natives s'étendent les uns des autres. Par exemple, `Array`extends`Object`.
76
+
Comme nous le savons déjà, les classes natives s'étendent les uns des autres. Par exemple, `Array`étend (hérite de)`Object`.
76
77
77
78
Normalement, lorsqu'une classe en étend une autre, les méthodes statiques et non statiques sont héritées. Cela a été expliqué en détail dans le chapitre [](info:static-properties-methods#statics-and-inheritance).
78
79
79
-
Mais les classes intégrées sont une exception. Ils n'héritent pas les méthodes statiques les uns des autres.
80
+
Mais les classes intégrées sont une exception. Elles n'héritent pas des méthodes statiques les unes des autres.
80
81
81
82
Par exemple, `Array` et `Date` héritent de `Object`, de sorte que leurs instances ont des méthodes issues de `Object.prototype`. Mais `Array.[[Prototype]]` ne fait pas référence à `Object`, il n'y a donc pas, par exemple, de méthode statique `Array.keys()` (ou `Date.keys()`).
82
83
83
-
Voici la structure d'image pour `Date` et `Object`:
84
+
Voici le schéma la structure pour `Date` et `Object`:
Copy file name to clipboardExpand all lines: 1-js/09-classes/06-instanceof/article.md
+43-41Lines changed: 43 additions & 41 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1,31 +1,32 @@
1
-
# Vérification de classe: "instanceof"
1
+
# Vérification de classe: "instanceof"
2
2
3
3
L'opérateur `instanceof` permet de vérifier si un objet appartient à une certaine classe. Il prend également en compte l'héritage.
4
4
5
5
Une telle vérification peut être nécessaire dans de nombreux cas. Nous l'utilisons ici pour construire une fonction *polymorphique*, celle qui traite les arguments différemment en fonction de leur type.
6
6
7
7
## L'opérateur instanceof [#ref-instanceof]
8
8
9
-
La syntaxe est la suivante:
9
+
La syntaxe est la suivante :
10
+
10
11
```js
11
12
obj instanceof Class
12
13
```
13
14
14
15
Cela renvoie `true` si `obj` appartient à la `Class` ou à une classe qui en hérite.
15
16
16
-
Par exemple:
17
+
Par exemple:
17
18
18
19
```js run
19
20
classRabbit {}
20
21
let rabbit =newRabbit();
21
22
22
-
// est-ce un objet de la classe Rabbit?
23
+
// est-ce un objet de la classe Rabbit?
23
24
*!*
24
25
alert( rabbit instanceof Rabbit ); // true
25
26
*/!*
26
27
```
27
28
28
-
Cela fonctionne aussi avec les fonctions constructeur:
29
+
Cela fonctionne aussi avec les fonctions constructeur:
29
30
30
31
```js run
31
32
*!*
@@ -36,7 +37,7 @@ function Rabbit() {}
36
37
alert( newRabbit() instanceof Rabbit ); // true
37
38
```
38
39
39
-
...Et avec des classes intégrées comme `Array`:
40
+
...Et avec des classes intégrées comme `Array`:
40
41
41
42
```js run
42
43
let arr = [1, 2, 3];
@@ -48,14 +49,14 @@ Veuillez noter que `arr` appartient également à la classe `Object`. C'est parc
48
49
49
50
Normalement, l’opérateur `instanceof` examine la chaîne prototypale pour la vérification. Nous pouvons également définir une logique personnalisée dans la méthode statique `Symbol.hasInstance`.
50
51
51
-
L'algorithme de `obj instanceof Class` fonctionne à peu près comme suit:
52
+
L'algorithme de `obj instanceof Class` fonctionne à peu près comme suit:
52
53
53
-
1. S'il existe une méthode statique `Symbol.hasInstance`, appelez-la simplement: `Class[Symbol.hasInstance](obj)`. Cela devrait renvoyer `true` ou `false`, et nous avons terminé. C'est ainsi que nous pouvons personnaliser le comportement de `instanceof`.
54
+
1. S'il existe une méthode statique `Symbol.hasInstance`, appelez-la simplement: `Class[Symbol.hasInstance](obj)`. Cela devrait renvoyer `true` ou `false`, et nous avons terminé. C'est ainsi que nous pouvons personnaliser le comportement de `instanceof`.
54
55
55
-
Par exemple:
56
+
Par exemple:
56
57
57
58
```js run
58
-
// configuration du contrôle de instanceOf qui suppose que
59
+
// configuration du contrôle de instanceof qui suppose que
59
60
// tout ce qui a la propriété canEat est un animal
60
61
classAnimal {
61
62
static [Symbol.hasInstance](obj) {
@@ -68,9 +69,10 @@ let obj = { canEat: true };
68
69
alert(obj instanceof Animal); // true: Animal[Symbol.hasInstance](obj) est appelée
69
70
```
70
71
71
-
2. La plupart des classes n'ont pas `Symbol.hasInstance`. Dans ce cas, la logique standard est utilisée: `obj instanceOf Class` vérifie si `Class.prototype` est égale à l'un des prototypes de la chaîne prototypale `obj`.
72
+
2. La plupart des classes n'ont pas `Symbol.hasInstance`. Dans ce cas, la logique standard est utilisée : `obj instanceof Class` vérifie si `Class.prototype` est égale à l'un des prototypes de la chaîne prototypale `obj`.
73
+
74
+
En d'autres termes, on compare l'un après l'autre :
72
75
73
-
En d'autres termes, comparez les uns après les autres:
Voici l'illustration de ce que `rabbit instanceof Animal` compare avec `Animal.prototype`:
104
+
Voici l'illustration de ce que `rabbit instanceof Animal` compare avec `Animal.prototype`:
103
105
104
106
105
107
106
-
À propos, il y a aussi une méthode [objA.isPrototypeOf(objB)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/isPrototypeOf), qui renvoie `true` si `objA` se trouve quelque part dans la chaîne de prototypes pour `objB`. Ainsi, le test de `obj instanceof Class` peut être reformulé comme suit: `Class.prototype.isPrototypeOf(obj)`.
108
+
À propos, il y a aussi une méthode [objA.isPrototypeOf(objB)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/isPrototypeOf), qui renvoie `true` si `objA` se trouve quelque part dans la chaîne de prototypes pour `objB`. Ainsi, le test de `obj instanceof Class` peut être reformulé comme suit: `Class.prototype.isPrototypeOf(obj)`.
107
109
108
-
C'est drôle, mais le constructeur `Class` lui-même ne participe pas au contrôle! Seule la chaîne de prototypes et `Class.prototype` compte.
110
+
C'est drôle, mais le constructeur `Class` lui-même ne participe pas au contrôle! Seule la chaîne de prototypes et `Class.prototype` compte.
109
111
110
-
Cela peut avoir des conséquences intéressantes lorsque une propriété `prototype` est modifiée après la création de l'objet.
112
+
Cela peut avoir des conséquences intéressantes lorsqu'une propriété `prototype` est modifiée après la création de l'objet.
111
113
112
-
Comme ici:
114
+
Comme ici:
113
115
114
116
```js run
115
117
functionRabbit() {}
@@ -118,15 +120,15 @@ let rabbit = new Rabbit();
118
120
// le prototype est changé
119
121
Rabbit.prototype= {};
120
122
121
-
// ...plus un rabbit!
123
+
// ...plus un rabbit!
122
124
*!*
123
125
alert( rabbit instanceof Rabbit ); // false
124
126
*/!*
125
127
```
126
128
127
-
## Bonus: Object.prototype.toString pour le type
129
+
## Bonus: Object.prototype.toString pour le type
128
130
129
-
Nous savons déjà que les objets simples sont convertis en chaîne sous la forme `[objet Objet]`:
131
+
Nous savons déjà que les objets simples sont convertis en chaîne sous la forme `[objet Objet]`:
130
132
131
133
```js run
132
134
let obj = {};
@@ -137,32 +139,32 @@ alert(obj.toString()); // la même chose
137
139
138
140
C'est leur implémentation de `toString`. Mais il existe une fonctionnalité cachée qui rend `toString` beaucoup plus puissant que cela. Nous pouvons l'utiliser comme un `typeof` étendu et une alternative pour `instanceof`.
139
141
140
-
Cela semble étrange? Effectivement. Démystifions.
142
+
Cela semble étrange? Effectivement. Démystifions.
141
143
142
144
Par [spécification](https://tc39.github.io/ecma262/#sec-object.prototype.tostring), le `toString` intégré peut être extrait de l'objet et exécuté dans le contexte de toute autre valeur. Et son résultat dépend de cette valeur.
143
145
144
146
- Pour un nombre, ce sera `[object Number]`
145
147
- Pour un booléen, ce sera `[object Boolean]`
146
-
- Pour `null`: `[objet Null]`
147
-
- Pour `undefined`: `[objet Undefined]`
148
-
- Pour les tableaux: `[objet Array]`
149
-
- ... etc (personnalisable).
148
+
- Pour `null`: `[objet Null]`
149
+
- Pour `undefined`: `[objet Undefined]`
150
+
- Pour les tableaux: `[objet Array]`
151
+
- ... etc. (personnalisable).
150
152
151
-
Montrons cela:
153
+
Montrons cela:
152
154
153
155
```js run
154
156
// copier la méthode toString dans une variable pour plus d'utilité
Ici nous avons utilisé [call](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/call) comme décrit dans le chapitre [](info:call-apply-decorators) exécuter la fonction `objectToString` dans le contexte `this=arr`.
165
+
Ici nous avons utilisé [call](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/call) comme décrit dans le chapitre [](info:call-apply-decorators) pour exécuter la fonction `objectToString` dans le contexte `this=arr`.
164
166
165
-
En interne, l'algorithme `toString` examine `this` et renvoie le résultat correspondant. Plus d'exemples:
167
+
En interne, l'algorithme `toString` examine `this` et renvoie le résultat correspondant. Plus d'exemples:
Comme vous pouvez le constater, le résultat est exactement `Symbol.toStringTag` (s'il existe), encapsulé dans `[objet ...]`.
201
203
202
-
À la fin, nous avons "typeof sur stéroïdes" qui fonctionne non seulement pour les types de données primitifs, mais aussi pour les objets intégrés et peut même être personnalisé.
204
+
Au final, nous avons un "typeof sous stéroïdes" qui fonctionne non seulement pour les types de données primitifs, mais aussi pour les objets intégrés et qui peut même être personnalisé.
203
205
204
-
Nous pouvons utiliser `{}.toString.call` au lieu de `instanceof` pour les objets intégrés lorsque nous voulons obtenir le type sous forme de chaîne plutôt que simplement pour vérifier.
206
+
Nous pouvons utiliser `{}.toString.call` au lieu de `instanceof` pour les objets intégrés lorsque nous voulons obtenir le type sous forme de chaîne de caractères plutôt que pour simplement vérifier.
205
207
206
208
## Résumé
207
209
208
-
Résumons les méthodes de vérification de type que nous connaissons:
210
+
Résumons les méthodes de vérification de type que nous connaissons:
0 commit comments