1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
---
title: Function.prototype.call()
slug: Web/JavaScript/Reference/Global_Objects/Function/call
tags:
- Function
- JavaScript
- Méthode
- Reference
translation_of: Web/JavaScript/Reference/Global_Objects/Function/call
original_slug: Web/JavaScript/Reference/Objets_globaux/Function/call
---
{{JSRef}}
La méthode **`call()`** réalise un appel à une fonction avec une valeur `this` donnée et des arguments fournis individuellement.
> **Note :** Bien que la syntaxe de cette fonction ressemble à celle de {{jsxref("Function.apply", "apply()")}}, la différence fondamentale réside dans le fait que `call()` accepte **une liste d'arguments**, tandis que la méthode `apply()` accepte **un unique tableau d'arguments**.
{{EmbedInteractiveExample("pages/js/function-call.html")}}
## Syntaxe
fun.call(thisArg[, arg1[, arg2[, ...]]])
### Paramètres
- `thisArg`
- : La valeur `this` fournie pour l'appel de la fonction _`fun`_. La valeur peut être différente de celle normalement perçue par la méthode : si la méthode est une fonction utilisée dans un code en {{jsxref("Fonctions/Strict_mode", "mode non-strict", "", 1)}}, {{jsxref("null")}} and {{jsxref("undefined")}} seront remplacés par l'objet global et les valeurs primitives seront encapsulées en objets.
- `arg1, arg2, ...`
- : Les arguments pour la fonction.
### Valeur de retour
Le résultat de l'appel de la fonction invoquée avec la valeur `this` indiquée et les arguments fournis.
## Description
La méthode `call()` permet d'appeler une fonction rattachée à un objet donné sur un autre objet.
Il est possible d'affecter un objet `this` différent lors de l'appel à une fonction existante. En général, `this` fait référence à l'objet courant, celui sur lequel est appelée la méthode. Avec `call`, on peut écrire une méthode une seule fois et ensuite en hériter dans un autre objet, sans avoir à réécrire cette méthode pour ce nouvel objet.
## Exemples
### Utiliser `call()` pour chaîner le constructeur d'un objet.
Il est possible d'utiliser `call` pour chaîner le constructeur d'un objet, de façon similaire à Java. Dans l'exemple suivant, le constructeur de l'objet `Product` est défini avec deux paramètres, `name` et `price`. Deux autres fonctions, `Food` et `Toy` invoquent `Product` en passant `this,` `name` et `price`. `Product` initialise les propriétés `name` et `price`, tandis que les fonctions spécialisées définissent la propriété `category`.
```js
function Product(name, price) {
this.name = name;
this.price = price;
}
function Food(name, price) {
Product.call(this, name, price);
this.category = 'food';
}
function Toy(name, price) {
Product.call(this, name, price);
this.category = 'toy';
}
var cheese = new Food('feta', 5);
var fun = new Toy('robot', 40);
```
### Utiliser `call()` pour invoquer une fonction anonyme
Dans cet exemple (purement inventé), on crée une fonction anonyme et on utilise `call` pour l'invoquer sur chaque objet d'un tableau. Le principal but de cette fonction anonyme est d'ajouter une fonction `print` sur chaque élément qui permet d'afficher l'index de l'objet. Le passage de l'objet en tant que valeur `this` n'était pas nécessaire, mais il permet d'expliquer le sujet.
```js
var animaux = [
{espece: 'Lion', nom: 'Roi'},
{espece: 'Éléphant', nom: 'Dumbo'}
];
for (var i = 0; i < animaux.length; i++) {
(function (i) {
this.print = function () {
console.log('#' + i + ' ' + this.espece + ' : ' + this.nom);
}
this.print();
}).call(animaux[i], i);
}
```
### Utiliser `call()` pour appeler une fonction avec un objet pour `this`
Dans l'exemple qui suit, on utilise la méthode `call()` sur la fonction `saluer()` afin de l'appliquer à l'objet `personne1` :
```js
function saluer() {
var reponse = [this.nom, "est un", this.role, "."].join(" ");
console.log(reponse);
}
var personne1 = {
nom: "Sénèque",
role: "philosophe"
};
saluer.call(personne1); // Sénèque est un philosophe.
```
### Utiliser `call()` pour appeler une fonction sans indiquer de premier argument
Dans l'exemple qui suit, on appelle la fonction `afficher()` sans lui passer d'argument. C'est donc l'objet global qui est utilisé comme contexte :
```js
var prenom = 'Archibald';
function afficher() {
console.log('prenom vaut ' + this.prenom);
}
afficher.call(); // prenom est Archibald
```
> **Note :** La valeur de `this` sera {{jsxref("undefined")}} en mode strict.
>
> ```js
> 'use strict';
>
> var prenom = 'Archibald';
>
> function afficher() {
> console.log('prenom vaut ' + this.prenom);
> }
>
> afficher.call(); // Cannot read the property prenom' of undefined
> ```
## Spécifications
| Spécification | État | Commentaires |
| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Définition initiale. Implémentée avec JavaScript 1.3. |
| {{SpecName('ES5.1', '#sec-15.3.4.4', 'Function.prototype.call')}} | {{Spec2('ES5.1')}} | |
| {{SpecName('ES6', '#sec-function.prototype.call', 'Function.prototype.call')}} | {{Spec2('ES6')}} | |
| {{SpecName('ESDraft', '#sec-function.prototype.call', 'Function.prototype.call')}} | {{Spec2('ESDraft')}} | |
## Compatibilité des navigateurs
{{Compat("javascript.builtins.Function.call")}}
## Voir aussi
- {{jsxref("Function.prototype.bind()")}}
- {{jsxref("Function.prototype.apply()")}}
- [Introduction à JavaScript orienté objet](/fr/docs/Web/JavaScript/Introduction_à_JavaScript_orienté_objet)
|
