From bf8e099b9c8b3c60d60b3712b4fc97b052c39887 Mon Sep 17 00:00:00 2001 From: julieng Date: Tue, 3 Aug 2021 08:03:23 +0200 Subject: convert content to md --- .../global_objects/function/apply/index.md | 244 +++++++++------------ .../global_objects/function/arguments/index.md | 82 +++---- .../global_objects/function/bind/index.md | 186 +++++++--------- .../global_objects/function/call/index.md | 166 ++++++-------- .../global_objects/function/caller/index.md | 67 +++--- .../global_objects/function/displayname/index.md | 46 ++-- .../reference/global_objects/function/index.md | 150 ++++++------- .../global_objects/function/length/index.md | 88 +++----- .../global_objects/function/name/index.md | 177 ++++++++------- .../global_objects/function/tosource/index.md | 73 +++--- .../global_objects/function/tostring/index.md | 110 ++++------ 11 files changed, 607 insertions(+), 782 deletions(-) (limited to 'files/fr/web/javascript/reference/global_objects/function') diff --git a/files/fr/web/javascript/reference/global_objects/function/apply/index.md b/files/fr/web/javascript/reference/global_objects/function/apply/index.md index a8dcbf5fab..f4e6698445 100644 --- a/files/fr/web/javascript/reference/global_objects/function/apply/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/apply/index.md @@ -9,76 +9,74 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply original_slug: Web/JavaScript/Reference/Objets_globaux/Function/apply --- -
{{JSRef}}
+{{JSRef}} -

La méthode apply() appelle une fonction en lui passant une valeur this et des arguments sous forme d'un tableau (ou d'un objet semblable à un tableau).

+La méthode **`apply()`** appelle une fonction en lui passant une valeur `this` et des `arguments` sous forme d'un tableau (ou d'un objet [semblable à un tableau](/fr/docs/Web/JavaScript/Guide/Objets_élémentaires_JavaScript#Manipuler_des_objets_semblables_aux_tableaux)). -

Note : Bien que la syntaxe de cette fonction ressemble à celle de {{jsxref("Function.call", "call()")}}, elle est différente car call() accepte une liste d'arguments, tandis que apply() accepte un tableau d'arguments.

+> **Note :** Bien que la syntaxe de cette fonction ressemble à celle de {{jsxref("Function.call", "call()")}}, elle est différente car `call()` accepte **une liste d'arguments**, tandis que `apply()` accepte un **tableau d'arguments**. -

Note : Quand on utilise {{jsxref("undefined")}} ou {{jsxref("null")}} comme premier argument pour cette fonction, on peut obtenir un résultat similaire avec la syntaxe de décomposition.

+> **Note :** Quand on utilise {{jsxref("undefined")}} ou {{jsxref("null")}} comme premier argument pour cette fonction, on peut obtenir un résultat similaire avec la [syntaxe de décomposition](/fr/docs/Web/JavaScript/Reference/Opérateurs/Syntaxe_décomposition). -
{{EmbedInteractiveExample("pages/js/function-apply.html")}}
+{{EmbedInteractiveExample("pages/js/function-apply.html")}} -

Syntaxe

+## Syntaxe -
fun.apply(thisArg, [argsArray])
+ fun.apply(thisArg, [argsArray]) -

Paramètres

+### Paramètres -
-
thisArg
-
La valeur de this fournie pour l'appel à la fonction fun. On notera que, sous certaines conditions, this peut ne pas être la valeur exacte vue par la méthode : si la méthode est une fonction utilisée en mode {{jsxref("Strict_mode", "mode non-strict", "", 1)}}, {{jsxref("null")}} et {{jsxref("undefined")}} seront remplacées par l'objet global, et les valeurs primitives seront encapsulées. Cet argument n'est pas optionnel.
-
argsArray
-
Un objet semblable à un tableau qui définit les arguments avec lesquel fun devrait être appelée, ou {{jsxref("null")}} ou {{jsxref("undefined")}} si aucun argument n'est passé à la fonction. Avec ECMAScript 5, ces arguments peuvent être représentés par un objet semblable un tableau. Voir ci-après pour plus d'informations sur la compatibilité des navigateurs.
-
+- `thisArg` + - : La valeur de `this` fournie pour l'appel à la fonction _`fun`_. On notera que, sous certaines conditions, `this` peut ne pas être la valeur exacte vue par la méthode : si la méthode est une fonction utilisée en mode {{jsxref("Strict_mode", "mode non-strict", "", 1)}}, {{jsxref("null")}} et {{jsxref("undefined")}} seront remplacées par l'objet global, et les valeurs primitives seront encapsulées. Cet argument n'est pas optionnel. +- `argsArray` + - : Un objet semblable à un tableau qui définit les arguments avec lesquel _`fun`_ devrait être appelée, ou {{jsxref("null")}} ou {{jsxref("undefined")}} si aucun argument n'est passé à la fonction. Avec ECMAScript 5, ces arguments peuvent être représentés par un objet semblable un tableau. Voir ci-après pour plus d'informations sur [la compatibilité des navigateurs](#compat). -

Valeur de retour

+### Valeur de retour -

Le résultat obtenu en appelant la fonction avec la valeur this indiquée et les arguments fournis.

+Le résultat obtenu en appelant la fonction avec la valeur `this` indiquée et les arguments fournis. -

Description

+## Description -

Il est possible d'utiliser un objet this différent lors de l'appel à une fonction existante. this fait référence à l'objet courant, l'objet appelant. Avec apply, on peut écrire une méthode une seule fois et en hériter dans un autre objet, sans avoir à la réécrire dans le nouvel objet.

+Il est possible d'utiliser un objet `this` différent lors de l'appel à une fonction existante. `this` fait référence à l'objet courant, l'objet appelant. Avec `apply`, on peut écrire une méthode une seule fois et en hériter dans un autre objet, sans avoir à la réécrire dans le nouvel objet. -

apply est similaire à {{jsxref("Function.call", "call()")}}, hormis pour le type d'arguments supporté. Il est possible d'utiliser un tableau à la place d'un ensemble de paramètres. Avec apply, il est également possible d'utiliser un littéral de tableau, par exemple, fun.apply(this, ['manger', 'bananes']), ou un objet {{jsxref("Array")}}, par exemple, fun.apply(this, new Array('manger', 'bananes')).

+`apply` est similaire à {{jsxref("Function.call", "call()")}}, hormis pour le type d'arguments supporté. Il est possible d'utiliser un tableau à la place d'un ensemble de paramètres. Avec `apply`, il est également possible d'utiliser un littéral de tableau, par exemple, `fun.apply(this, ['manger', 'bananes'])`, ou un objet {{jsxref("Array")}}, par exemple, `fun.apply(this, new Array('manger', 'bananes'))`. -

On peut aussi passer {{jsxref("Fonctions/arguments", "arguments ")}} en tant que paramètre argsArray. arguments étant une variable locale à la fonction. Celle-ci peut également être utilisée pour tous les arguments non spécifiés de l'objet appelé. Ainsi, il n'est pas nécessaire de connaître les arguments de l'objet appelé lors d'un appel à la méthode apply. arguments peut être utilisé pour passer tous les arguments à l'objet appelé. L'objet appelé gèrera alors la manipulation des arguments.

+On peut aussi passer {{jsxref("Fonctions/arguments", "arguments ")}} en tant que paramètre `argsArray`. `arguments` étant une variable locale à la fonction. Celle-ci peut également être utilisée pour tous les arguments non spécifiés de l'objet appelé. Ainsi, il n'est pas nécessaire de connaître les arguments de l'objet appelé lors d'un appel à la méthode `apply`. `arguments` peut être utilisé pour passer tous les arguments à l'objet appelé. L'objet appelé gèrera alors la manipulation des arguments. -

Depuis la cinquième édition d'ECMAScript, il est possible d'utiliser des objet semblables à des tableaux à la place. En pratique tout objet possédant une propriété length et une propriété entière comprise entre [0..length[ est un objet semblable à un tableau. On peut ainsi, par exemple, utiliser un objet {{domxref("NodeList")}} ou un objet quelconque comme {'length': 2, '0': 'manger', '1': 'bananes'}.

+Depuis la cinquième édition d'ECMAScript, il est possible d'utiliser des objet semblables à des tableaux à la place. En pratique tout objet possédant une propriété `length` et une propriété entière comprise entre `[0..length[` est un objet semblable à un tableau. On peut ainsi, par exemple, utiliser un objet {{domxref("NodeList")}} ou un objet quelconque comme `{'length': 2, '0': 'manger', '1': 'bananes'}`. -
-

Note : Beaucoup de navigateurs, y compris Chrome 14 et Internet Explorer 9 n'acceptent pas encore un objet semblable à un tableau, ils déclencheront un exception.

-
+> **Note :** Beaucoup de navigateurs, y compris Chrome 14 et Internet Explorer 9 n'acceptent pas encore un objet semblable à un tableau, ils déclencheront un exception. -

Exemples

+## Exemples -

Utiliser apply pour chaîner des constructeurs

+### Utiliser `apply` pour chaîner des constructeurs -

Il est possible d'utiliser apply afin de chaîner les {{jsxref("Opérateurs/L_opérateur_new", "constructeurs","",1)}} d'un objet, de façon sembable au chaînage utilisé en java. Dans l'exemple suivant, on crée une {{jsxref("Function")}} globale appelée construct, qui permet d'utiliser un objet de type Array associé à un constructeur au lieu d'une liste d'arguments.

+Il est possible d'utiliser `apply` afin de chaîner les {{jsxref("Opérateurs/L_opérateur_new", "constructeurs","",1)}} d'un objet, de façon sembable au chaînage utilisé en java. Dans l'exemple suivant, on crée une {{jsxref("Function")}} globale appelée `construct`, qui permet d'utiliser un objet de type `Array` associé à un constructeur au lieu d'une liste d'arguments. -
Function.prototype.construct = function (aArgs) {
+```js
+Function.prototype.construct = function (aArgs) {
   var nouvelObjet = Object.create(this.prototype);
   this.apply(nouvelObjet, aArgs);
   return nouvelObjet;
 };
-
- -
-

Note : La méthode {{jsxref("Object.create()")}} utilisée ci-avant est relativement nouvelle. Pour une autre méthode qui utilise les closure, on pourra utiliser :

- -
Function.prototype.construct = function(aArgs) {
-  var fConstructeur = this, fNouveauConstructeur = function() {
-    fConstructeur.apply(this, aArgs);
-  };
-  fNouveauConstructeur.prototype = fConstructeur.prototype;
-  return new fNouveauConstructeur();
-};
-
- -

Exemple d'utilisation :

- -
function MonConstructeur () {
-    for (var nProp = 0; nProp < arguments.length; nProp++) {
+```
+
+> **Note :** La méthode {{jsxref("Object.create()")}} utilisée ci-avant est relativement nouvelle. Pour une autre méthode qui utilise les `closure`, on pourra utiliser :
+>
+> ```js
+> Function.prototype.construct = function(aArgs) {
+>   var fConstructeur = this, fNouveauConstructeur = function() {
+>     fConstructeur.apply(this, aArgs);
+>   };
+>   fNouveauConstructeur.prototype = fConstructeur.prototype;
+>   return new fNouveauConstructeur();
+> };
+> ```
+
+Exemple d'utilisation :
+
+```js
+function MonConstructeur () {
+    for (var nProp = 0; nProp < arguments.length; nProp++) {
         this["propriété" + nProp] = arguments[nProp];
     }
 }
@@ -89,38 +87,39 @@ var monInstance = MonConstructeur.construct(monTableau);
 console.log(monInstance.propriété1); // "Coucou monde !"
 console.log(monInstance instanceof MonConstructeur); // "true"
 console.log(monInstance.constructor); // "MonConstructeur"
-
- -
-

Note : On pourrait également utiliser {{jsxref("Object/__proto__", "Object.__proto__")}}

- -
Function.prototype.construct = function (aArgs) {
-  var oNew = {};
-  oNew.__proto__ = this.prototype;
-  this.apply(oNew, aArgs);
-  return oNew;
-};
-
- -

ou encore le constructeur {{jsxref("Function")}} :

- -
Function.prototype.construct = function (aArgs) {
-  var fNewConstr = new Function("");
-  fNewConstr.prototype = this.prototype;
-  var oNew = new fNewConstr();
-  this.apply(oNew, aArgs);
-  return oNew;
-};
-
-
- -

Note : Attention, cette méthode non-native Function.construct ne fonctionnera pas avec certains contructeurs natifs (tels que {{jsxref("Date", "Date")}}). Dans ce cas précis, on peut utiliser la méthode {{jsxref("Function.bind")}} (pour exemple, si on prend le tableau suivant [2012, 11, 4] utilisé sur le constructeur de l'objet Date : on peut écrire ceci : new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))() – cependant cela reste une pratique à éviter si possible et à ne pas utiliser en dans un environnement de production).

- -

Utiliser apply et des fonctions natives

- -

Un usage singulier de apply permet d'appeler des fonctions natives pour réaliser par exemple des tâches qui autrement auraient nécessité une boucle sur toutes les valeurs d'un tableau. Pour illustrer ce concept, on prend l'exemple de Math.max/Math.min qui permettent d'extraire la valeur maximum/minimale de notre tableau.

- -
/* min/max tableau de nombres */
+```
+
+> **Note :** On pourrait également utiliser {{jsxref("Object/__proto__", "Object.__proto__")}}
+>
+> ```js
+> Function.prototype.construct = function (aArgs) {
+>   var oNew = {};
+>   oNew.__proto__ = this.prototype;
+>   this.apply(oNew, aArgs);
+>   return oNew;
+> };
+> ```
+>
+> ou encore le constructeur {{jsxref("Function")}} :
+>
+> ```js
+> Function.prototype.construct = function (aArgs) {
+>   var fNewConstr = new Function("");
+>   fNewConstr.prototype = this.prototype;
+>   var oNew = new fNewConstr();
+>   this.apply(oNew, aArgs);
+>   return oNew;
+> };
+> ```
+
+> **Note :** Attention, cette méthode non-native `Function.construct` ne fonctionnera pas avec certains contructeurs natifs (tels que {{jsxref("Date", "Date")}}). Dans ce cas précis, on peut utiliser la méthode {{jsxref("Function.bind")}} (pour exemple, si on prend le tableau suivant `[2012, 11, 4]` utilisé sur le constructeur de l'objet `Date` : on peut écrire ceci : `new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()` – cependant cela reste une pratique à éviter si possible et à ne pas utiliser en dans un environnement de production).
+
+### Utiliser `apply` et des fonctions natives
+
+Un usage singulier de `apply` permet d'appeler des fonctions natives pour réaliser par exemple des tâches qui autrement auraient nécessité une boucle sur toutes les valeurs d'un tableau. Pour illustrer ce concept, on prend l'exemple de `Math.max`/`Math.min` qui permettent d'extraire la valeur maximum/minimale de notre tableau.
+
+```js
+/* min/max tableau de nombres */
 var nombres = [5, 6, 2, 3, 7];
 
 /* usage de Math.min/Math.max et de la méthode apply */
@@ -133,20 +132,22 @@ var min = Math.min.apply(null, nombres);
 /* vs. algorithme trivial avec une boucle */
 max = -Infinity, min = +Infinity;
 
-for (var i = 0; i < nombres.length; i++) {
-  if (nombres[i] > max)
+for (var i = 0; i < nombres.length; i++) {
+  if (nombres[i] > max)
     max = nombres[i];
-  if (nombres[i] < min)
+  if (nombres[i] < min)
     min = nombres[i];
-}
+} +``` -

Note : l'utilisation de apply peut provoquer l'atteinte du seuil limite du nombres d'arguments supporté par le moteur Javascript. Les conséquences de cette utilisation abusive (on évoque plus de 10000 arguments) peuvent varier selon les moteurs Javascript (JavaScript contient une limite en dur de 65536), car une liberté subsiste quant à l'implémentation du moteur. Des moteurs lèveront une exception si le seuil est atteint. Il est donc préférable d'apporter une attention toute particulière au nombre d'arguments passés. (Illustrerons ce cas dans l'exemple suivant avec un moteur factice capable de ne gérer que 4 arguments au maximum (les limites natives sont, bien sûr, plus élevées), et reprenons les arguments de l'exemple précédent 5, 6, 2, 3 passés à la méthode apply plutôt que notre tableau entier.) Imaginons que notre tableau soit progressivement peuplé de milliers d'éléments, une stratégie spécifique devra être appliquée, par exemple en appliquant la méthode apply sur des portions du tableau:

+Note : l'utilisation de `apply` peut provoquer l'atteinte du seuil limite du nombres d'arguments supporté par le moteur Javascript. Les conséquences de cette utilisation abusive (on évoque plus de 10000 arguments) peuvent varier selon les moteurs Javascript (JavaScript contient une limite en dur de [65536](https://bugs.webkit.org/show_bug.cgi?id=80797)), car une liberté subsiste quant à l'implémentation du moteur. Des moteurs lèveront une exception si le seuil est atteint. Il est donc préférable d'apporter une attention toute particulière au nombre d'arguments passés. (Illustrerons ce cas dans l'exemple suivant avec un moteur factice capable de ne gérer que 4 arguments au maximum (les limites natives sont, bien sûr, plus élevées), et reprenons les arguments de l'exemple précédent `5, 6, 2, 3` passés à la méthode `apply` plutôt que notre tableau entier.) Imaginons que notre tableau soit progressivement peuplé de milliers d'éléments, une stratégie spécifique devra être appliquée, par exemple en appliquant la méthode apply sur des portions du tableau: -
function minimumDuTableau(tab) {
+```js
+function minimumDuTableau(tab) {
   var min = Infinity;
   var QUANTUM = 32768;
 
-  for (var i = 0, longueur = tab.length; i < len; i += QUANTUM) {
+  for (var i = 0, longueur = tab.length; i < len; i += QUANTUM) {
     var submin = Math.min.apply(null,
                                 tab.slice(i, Math.min(i + QUANTUM, longueur)));
     min = Math.min(submin, min);
@@ -156,53 +157,26 @@ for (var i = 0; i < nombres.length; i++) {
 }
 
 var min = minimumDuTableau([5, 6, 2, 3, 7]);
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES3')}}{{Spec2('ES3')}}Définition initiale. Implémentée avec JavaScript 1.3.
{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-function.prototype.apply', 'Function.prototype.apply')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Function.apply")}}

- -

Voir aussi

- - +``` + +## 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.3', 'Function.prototype.apply')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-function.prototype.apply', 'Function.prototype.apply')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Function.apply")}} + +## Voir aussi + +- L'objet {{jsxref("Fonctions/arguments", "arguments")}} +- {{jsxref("Function.prototype.bind()")}} +- {{jsxref("Function.prototype.call()")}} +- {{jsxref("Fonctions", "Les fonctions et portées de fonctions", "", 1)}} +- {{jsxref("Reflect.apply()")}} +- [La syntaxe de décomposition permettant d'exploser un tableau](/fr/docs/Web/JavaScript/Reference/Opérateurs/Syntaxe_décomposition) diff --git a/files/fr/web/javascript/reference/global_objects/function/arguments/index.md b/files/fr/web/javascript/reference/global_objects/function/arguments/index.md index 6723204679..a8272388ce 100644 --- a/files/fr/web/javascript/reference/global_objects/function/arguments/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/arguments/index.md @@ -11,25 +11,26 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments original_slug: Web/JavaScript/Reference/Objets_globaux/Function/arguments --- -
{{JSRef}} {{Deprecated_header}}
+{{JSRef}} {{Deprecated_header}} -

La propriété function.arguments fait référence à un objet dont la structure est semblable à celle d'un tableau dont les éléments correspondent aux arguments passés à une fonction. En lieu et place, il faut désormais utiliser {{jsxref("Fonctions/arguments", "arguments")}}. Cette propriété est interdite en mode stricte à cause de l'optimisation de la queue des appels (tail call optimization).

+La propriété **`function.arguments`** fait référence à un objet dont la structure est semblable à celle d'un tableau dont les éléments correspondent aux arguments passés à une fonction. En lieu et place, il faut désormais utiliser {{jsxref("Fonctions/arguments", "arguments")}}. Cette propriété est interdite en mode stricte à cause de [l'optimisation de la queue des appels (_tail call optimization_)](https://www.ecma-international.org/ecma-262/6.0/#sec-addrestrictedfunctionproperties). -

Description

+## Description -

La syntaxe function.arguments est obsolète.  La méthode recommandée pour accéder à l'objet {{jsxref("Fonctions/arguments", "arguments")}} disponible au sein des fonctions est simplement de faire référence à la variable {{jsxref("Fonctions/arguments", "arguments")}}.

+La syntaxe `function.arguments` est obsolète.  La méthode recommandée pour accéder à l'objet {{jsxref("Fonctions/arguments", "arguments")}} disponible au sein des fonctions est simplement de faire référence à la variable {{jsxref("Fonctions/arguments", "arguments")}}. -

Si on utilise la récursivité (autrement dit si une fonction f apparaît plusieurs fois dans la pile d'appels ou encore qu'une fonction f s'appelle elle-même), la valeur de f.arguments représentera les arguments correspondant à l'appel le plus « récent » de la fonction.

+Si on utilise la récursivité (autrement dit si une fonction `f` apparaît plusieurs fois dans la pile d'appels ou encore qu'une fonction `f` s'appelle elle-même), la valeur de `f.arguments` représentera les arguments correspondant à l'appel le plus « récent » de la fonction. -

La valeur de la propriété arguments est normalement null si la fonction n'est pas « en cours » (au sens où elle aurait été appelée et qu'elle n'ait pas fini son exécution).

+La valeur de la propriété `arguments` est normalement `null` si la fonction n'est pas « en cours » (au sens où elle aurait été appelée et qu'elle n'ait pas fini son exécution). -

Exemples

+## Exemples -
function f(n) { g(n-1); }
+```js
+function f(n) { g(n-1); }
 
 function g(n) {
   console.log("avant : " + g.arguments[0]);
-  if(n>0) f(n);
+  if(n>0) f(n);
   console.log("après : " + g.arguments[0]);
 }
 
@@ -44,47 +45,22 @@ console.log("fonction terminée : " + g.arguments);
 // après : 0
 // après : 1
 // fonction terminée : null
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0. Dépréciée pour être remplacée par {{jsxref("Fonctions/arguments", "arguments")}} décrit par ES3.
{{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}{{Spec2('ES5.1')}}Objet {{jsxref("Fonctions/arguments", "arguments")}}
{{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}{{Spec2('ES6')}}Objet {{jsxref("Fonctions/arguments", "arguments")}}
{{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}}{{Spec2('ESDraft')}}Objet {{jsxref("Fonctions/arguments", "arguments")}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Function.arguments")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | Statut | Commentaires | +| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. Dépréciée pour être remplacée par {{jsxref("Fonctions/arguments", "arguments")}} décrit par ES3. | +| {{SpecName('ES5.1', '#sec-10.6', 'arguments object')}} | {{Spec2('ES5.1')}} | Objet {{jsxref("Fonctions/arguments", "arguments")}} | +| {{SpecName('ES6', '#sec-arguments-object', 'arguments object')}} | {{Spec2('ES6')}} | Objet {{jsxref("Fonctions/arguments", "arguments")}} | +| {{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}} | {{Spec2('ESDraft')}} | Objet {{jsxref("Fonctions/arguments", "arguments")}} | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Function.arguments")}} + +## Voir aussi + +- L'objet {{jsxref("Fonctions/arguments", "arguments")}} +- {{jsxref("Fonctions", "Les fonctions et les portées de fonctions", "", 1)}} diff --git a/files/fr/web/javascript/reference/global_objects/function/bind/index.md b/files/fr/web/javascript/reference/global_objects/function/bind/index.md index 747fa29f94..a2484ba8da 100644 --- a/files/fr/web/javascript/reference/global_objects/function/bind/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/bind/index.md @@ -12,59 +12,56 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind original_slug: Web/JavaScript/Reference/Objets_globaux/Function/bind --- -
{{JSRef}}
+{{JSRef}} -

La méthode bind() crée une nouvelle fonction qui, lorsqu'elle est appelée, a pour contexte this la valeur passée en paramètre et éventuellement une suite d'arguments qui précéderont ceux fournis à l'appel de la fonction créée.

+La méthode **`bind()`** crée une nouvelle fonction qui, lorsqu'elle est appelée, a pour contexte [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this) la valeur passée en paramètre et éventuellement une suite d'arguments qui précéderont ceux fournis à l'appel de la fonction créée. -
{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}}
+{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}} -

Syntaxe

+## Syntaxe -
let boundFunc = func.bind(thisArg[, arg1[, arg2[, ...]]])
+ let boundFunc = func.bind(thisArg[, arg1[, arg2[, ...]]]) -

Paramètres

+### Paramètres -
-
thisArg
-
La valeur que l'on doit passer est le paramètre this de la fonction cible func quand la fonction est appelée. La valeur est ignorée si la fonction liée est construite en utilisant l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Lorsque vous utilisez bind pour créer une fonction (fournie comme un rappel) dans un setTimeout, toute valeur primitive passée comme thisArg est convertie en objet. Si aucun argument n'est fourni dans bind, le this de cette fonction est traité comme le thisArg de la nouvelle fonction.
-
arg1, arg2, ... {{optional_inline}}
-
Arguments à faire précéder aux arguments fournis à la fonction liée lors de l'invocation de func.
-
+- `thisArg` + - : La valeur que l'on doit passer est le paramètre `this` de la fonction cible _`func`_ quand la fonction est appelée. La valeur est ignorée si la fonction liée est construite en utilisant l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Lorsque vous utilisez `bind` pour créer une fonction (fournie comme un rappel) dans un `setTimeout`, toute valeur primitive passée comme `thisArg` est convertie en objet. Si aucun argument n'est fourni dans `bind`, le `this` de cette fonction est traité comme le `thisArg` de la nouvelle fonction. +- `arg1, arg2, ...` {{optional_inline}} + - : Arguments à faire précéder aux arguments fournis à la fonction liée lors de l'invocation de _`func`_. -

Valeur de retour

+### Valeur de retour -

Une copie de la fonction fournie avec la valeur this indiquée et les arguments initiaux fournis.

+Une copie de la fonction fournie avec la valeur `this` indiquée et les arguments initiaux fournis. -

Description

+## Description -

La fonction bind() crée une nouvelle fonction liée, qui est un objet de fonction exotique (un terme de l'ECMAScript 2015) qui enveloppe l'objet de fonction original. L'appel de la fonction liée entraîne généralement l'exécution de sa fonction enveloppée.

+La fonction `bind()` crée une nouvelle **fonction liée**, qui est un _objet de fonction exotique_ (un terme de l'ECMAScript 2015) qui enveloppe l'objet de fonction original. L'appel de la fonction liée entraîne généralement l'exécution de sa fonction enveloppée. -

Une fonction liée possède les propriétés internes suivantes :

+Une fonction liée possède les propriétés internes suivantes : -
-
[[BoundTargetFunction]]
-
L'objet de fonction enveloppé
-
[[BoundThis]]
-
La valeur qui est toujours transmise est la valeur this lors de l'appel de la fonction enveloppée.
-
[[BoundArguments]]
-
Une liste de valeurs dont les éléments sont utilisés comme premiers arguments pour tout appel à la fonction enveloppée.
-
[[Call]]
-
Exécute le code associé à cet objet. Invoqué par une expression d'appel de fonction. Les arguments de la méthode interne sont constitués d'une valeur this et d'une liste contenant les arguments passés à la fonction par une expression d'appel.
-
+- **`[[BoundTargetFunction]]`** + - : L'objet de fonction enveloppé +- **`[[BoundThis]]`** + - : La valeur qui est toujours transmise est la valeur `this` lors de l'appel de la fonction enveloppée. +- **`[[BoundArguments]]`** + - : Une liste de valeurs dont les éléments sont utilisés comme premiers arguments pour tout appel à la fonction enveloppée. +- **`[[Call]]`** + - : Exécute le code associé à cet objet. Invoqué par une expression d'appel de fonction. Les arguments de la méthode interne sont constitués d'une valeur `this` et d'une liste contenant les arguments passés à la fonction par une expression d'appel. -

Lorsqu'une fonction liée est appelée, elle appelle la méthode interne [[Call]] dans [[BoundTargetFunction]], avec les arguments suivants Call(boundThis, ...args). Là où boundThis est [[BoundThis]], args est [[BoundArguments]], suivi des arguments passés par l'appel de fonction.

+Lorsqu'une fonction liée est appelée, elle appelle la méthode interne `[[Call]]` dans `[[BoundTargetFunction]]`, avec les arguments suivants `Call(boundThis, ...args)`. _Là où _`boundThis` est `[[BoundThis]]`, `args` est `[[BoundArguments]]`, suivi des arguments passés par l'appel de fonction. -

Une fonction liée peut également être construite à l'aide de l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Ce faisant, on agit comme si la fonction cible avait été construite. La valeur fournie this est ignorée, tandis que des arguments préparés sont fournis à la fonction émulée.

+Une fonction liée peut également être construite à l'aide de l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}. Ce faisant, on agit comme si la fonction cible avait été construite. La valeur fournie `this` est ignorée, tandis que des arguments préparés sont fournis à la fonction émulée. -

Exemples

+## Exemples -

Créer une fonction liée

+### Créer une fonction liée -

La façon la plus simple d'utiliser bind()est de faire une fonction qui, peu importe la façon dont elle est appellée, le sera avec une certaine valeur this donnée.

+La façon la plus simple d'utiliser `bind()`est de faire une fonction qui, peu importe la façon dont elle est appellée, le sera avec une certaine valeur `this` donnée. -

Une erreur courante lorsqu'on débute en JavaScript est d'extraire une méthode d'un objet, puis plus tard d'appeler cette méthode depuis un objet et de s'attendre à utiliser l'objet original en tant que valeur de this (par exemple en utilisant cette méthode dans un callback). Sans précaution, cependant, l'objet original est perdu. Créer une fonction liée depuis la méthode, en utilisant l'objet original, résout simplement le problème :

+Une erreur courante lorsqu'on débute en JavaScript est d'extraire une méthode d'un objet, puis plus tard d'appeler cette méthode depuis un objet et de s'attendre à utiliser l'objet original en tant que valeur de `this` (par exemple en utilisant cette méthode dans un _callback_). Sans précaution, cependant, l'objet original est perdu. Créer une fonction liée depuis la méthode, en utilisant l'objet original, résout simplement le problème : -
this.x = 9; // en dehors de tout contexte,
+```js
+this.x = 9; // en dehors de tout contexte,
             // pour un navigateur, this est
             // l'objet window
 var module = {
@@ -81,13 +78,14 @@ getX(); // 9, car ici, this fait référence à l'objet global
 // tant que 'this'
 var boundGetX = getX.bind(module);
 boundGetX(); // 81
-
+``` -

Fonctions partiellement appliquées

+### Fonctions partiellement appliquées -

Dans l'exemple suivant, on utilise bind() afin de créer une fonction avec des arguments initiaux prédéfinis. Ces arguments, s'il y en a, suivent le this fourni et sont ensuite insérés au début des arguments passés à la fonction cible, suivis par les arguments passés à la fonction liée au moment où celle-ci est appelée.

+Dans l'exemple suivant, on utilise `bind()` afin de créer une fonction avec des arguments initiaux prédéfinis. Ces arguments, s'il y en a, suivent le `this` fourni et sont ensuite insérés au début des arguments passés à la fonction cible, suivis par les arguments passés à la fonction liée au moment où celle-ci est appelée. -
function list() {
+```js
+function list() {
   return Array.prototype.slice.call(arguments);
 }
 
@@ -107,13 +105,14 @@ function sommeArguments(arg1, arg2){
 var ajouter37 = sommeArguments.bind(null, 37);
 
 var resultat = ajouter37(5); // 37 + 5 = 42
-
+``` -

Utiliser bind avec setTimeout

+### Utiliser `bind` avec `setTimeout` -

Par défaut à l'intérieur de {{domxref("window.setTimeout()")}}, le mot-clé this sera attribué à l'objet {{domxref("window")}} (ou l'objet global). Lorsqu'on travaille avec des méthodes de classe utilisant this qui se réfère à l'instance, on peut lier this de façon explicite afin d'être certain de manipuler l'instance.

+Par défaut à l'intérieur de {{domxref("window.setTimeout()")}}, le mot-clé `this` sera attribué à l'objet {{domxref("window")}} (ou l'objet `global`). Lorsqu'on travaille avec des méthodes de classe utilisant `this` qui se réfère à l'instance, on peut lier `this` de façon explicite afin d'être certain de manipuler l'instance. -
function Fleur() {
+```js
+function Fleur() {
   this.nbPétales = Math.floor( Math.random() * 12 ) + 1;
 }
 
@@ -130,17 +129,16 @@ Fleur.prototype.declare = function() {
 var fleur = new Fleur();
 fleur.floraison();
 // Après environ 1 seconde, on déclenche la méthode declare
-
+``` -

Les fonctions liées utilisées en tant que constructeurs

+### Les fonctions liées utilisées en tant que constructeurs -
-

Attention : Cette section illustre des capacités marginales et des cas aux limites concernant l'usage de la méthode bind(). Les méthodes montrées ci-après ne sont pas les façons les plus propres de faire les choses et ne devraient pas être utilisées en production.

-
+> **Attention :** Cette section illustre des capacités marginales et des cas aux limites concernant l'usage de la méthode bind(). Les méthodes montrées ci-après ne sont pas les façons les plus propres de faire les choses et ne devraient pas être utilisées en production. -

Les fonctions liées sont automatiquement disponibles à l'usage pour toutes les instances initialisées avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}} sur la fonction cible. Quand une fonction liée est utilisée pour construire une valeur, le this fourni est ignoré. Cependant, les arguments fournis sont toujours préremplis lors de l'appel au constructeur :

+Les fonctions liées sont automatiquement disponibles à l'usage pour toutes les instances initialisées avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}} sur la fonction cible. Quand une fonction liée est utilisée pour construire une valeur, le `this` fourni est ignoré. Cependant, les arguments fournis sont toujours préremplis lors de l'appel au constructeur : -
function Point(x, y) {
+```js
+function Point(x, y) {
   this.x = x;
   this.y = y;
 }
@@ -165,11 +163,12 @@ axisPoint.toString(); //  "0,5"
 axisPoint instanceof Point; // true
 axisPoint instanceof YAxisPoint; // true
 new Point(17, 42) instanceof YAxisPoint; // false
-
+``` -

On notera qu'il n'y a rien à faire de particulier pour pouvoir utiliser {{jsxref("Opérateurs/L_opérateur_new", "new")}} sur votre fonction liée. Le corollaire est qu'il n'y a rien à faire de plus pour créer une fonction liée qui soit appelée sans préfixe, même s'il est préférable d'appeler une fonction liée uniquement avec le mot-clé {{jsxref("Opérateurs/L_opérateur_new", "new")}}.

+On notera qu'il n'y a rien à faire de particulier pour pouvoir utiliser {{jsxref("Opérateurs/L_opérateur_new", "new")}} sur votre fonction liée. Le corollaire est qu'il n'y a rien à faire de plus pour créer une fonction liée qui soit appelée sans préfixe, même s'il est préférable d'appeler une fonction liée uniquement avec le mot-clé {{jsxref("Opérateurs/L_opérateur_new", "new")}}. -
// Cet exemple fonctionne dans votre console JavaScript
+```js
+// Cet exemple fonctionne dans votre console JavaScript
 // ...(sous réserve d'avoir utilisé le code précédent)
 
 // Peut toujours être appelé comme une fonction normale
@@ -177,71 +176,50 @@ new Point(17, 42) instanceof YAxisPoint; // false
 YAxisPoint(13);
 
 emptyObj.x + "," + emptyObj.y; // "0,13"
-
+``` -

Si on souhaite supporter le cas où la fonction liée  d'une fonction liée en utilisant seulement new, ou juste en l'appellant, la fonction cible doit outrepasser cette restriction.

+Si on souhaite supporter le cas où la fonction liée  d'une fonction liée en utilisant seulement `new`, ou juste en l'appellant, la fonction cible doit outrepasser cette restriction. -

Créer des raccourcis

+### Créer des raccourcis -
-

bind() est également utile dans les cas où on souhaite créer un raccourci vers une fonction qui requiert un this ayant une certaine valeur.

+`bind()` est également utile dans les cas où on souhaite créer un raccourci vers une fonction qui requiert un `this` ayant une certaine valeur. -

Si, par exemple, on considère la fonction {{jsxref("Array.prototype.slice")}} et qu'on souhaite l'utiliser pour convertir un objet semblable à un tableau en un objet array, on peut créer un raccourci de cette façon :

+Si, par exemple, on considère la fonction {{jsxref("Array.prototype.slice")}} et qu'on souhaite l'utiliser pour convertir un objet semblable à un tableau en un objet `array`, on peut créer un raccourci de cette façon : -
var slice = Array.prototype.slice;
+```js
+var slice = Array.prototype.slice;
 
 // ... un peu plus loin
 
-slice.apply(arguments);
+slice.apply(arguments); +``` -

Avec bind(), il est possible de simplifier cela. Dans l'exemple qui suit slice est une fonction liée à la fonction {{jsxref("Function.prototype.apply()", "apply()")}} de Function.prototype, et this défini en tant que fonction {{jsxref("Array.prototype.slice()", "slice()")}} de {{jsxref("Array.prototype")}}. Cela signifie que les appels à la méthode apply() peuvent être éliminés :

+Avec `bind()`, il est possible de simplifier cela. Dans l'exemple qui suit `slice` est une fonction liée à la fonction {{jsxref("Function.prototype.apply()", "apply()")}} de `Function.prototype`, et `this` défini en tant que fonction {{jsxref("Array.prototype.slice()", "slice()")}} de {{jsxref("Array.prototype")}}. Cela signifie que les appels à la méthode `apply()` peuvent être éliminés : -
// pareil que "slice" dans l'exemple précédent
+```js
+// pareil que "slice" dans l'exemple précédent
 var unboundSlice = Array.prototype.slice;
 var slice = Function.prototype.apply.bind(unboundSlice);
 
 // ...
 
 slice(arguments);
-
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES5.1', '#sec-15.3.4.5', 'Function.prototype.bind')}}{{Spec2('ES5.1')}}Définition initiale.
- Implémentée avec JavaScript 1.8.5
{{SpecName('ES2015', '#sec-function.prototype.apply', 'Function.prototype.bind')}}{{Spec2('ES2015')}}
{{SpecName('ESDraft', '#sec-function.prototype.bind', 'Function.prototype.bind')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Function.bind")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------------------------------------------ | +| {{SpecName('ES5.1', '#sec-15.3.4.5', 'Function.prototype.bind')}} | {{Spec2('ES5.1')}} | Définition initiale. Implémentée avec JavaScript 1.8.5 | +| {{SpecName('ES2015', '#sec-function.prototype.apply', 'Function.prototype.bind')}} | {{Spec2('ES2015')}} | | +| {{SpecName('ESDraft', '#sec-function.prototype.bind', 'Function.prototype.bind')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Function.bind")}} + +## Voir aussi + +- {{jsxref("Function.prototype.apply()")}} +- {{jsxref("Function.prototype.call()")}} +- {{jsxref("Fonctions", "Fonctions et portées de fonctions", "", 1)}} diff --git a/files/fr/web/javascript/reference/global_objects/function/call/index.md b/files/fr/web/javascript/reference/global_objects/function/call/index.md index 5cc70709d0..5226e7b387 100644 --- a/files/fr/web/javascript/reference/global_objects/function/call/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/call/index.md @@ -9,44 +9,43 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function/call original_slug: Web/JavaScript/Reference/Objets_globaux/Function/call --- -
{{JSRef}}
+{{JSRef}} -

La méthode call() réalise un appel à une fonction avec une valeur this donnée et des arguments fournis individuellement.

+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.

+> **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")}}
+{{EmbedInteractiveExample("pages/js/function-call.html")}} -

Syntaxe

+## Syntaxe -
fun.call(thisArg[, arg1[, arg2[, ...]]])
+ fun.call(thisArg[, arg1[, arg2[, ...]]]) -

Paramètres

+### 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.
-
+- `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

+### Valeur de retour -

Le résultat de l'appel de la fonction invoquée avec la valeur this indiquée et les arguments fournis.

+Le résultat de l'appel de la fonction invoquée avec la valeur `this` indiquée et les arguments fournis. -

Description

+## Description -

La méthode call() permet d'appeler une fonction rattachée à un objet donné sur un autre objet.

+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.

+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

+## Exemples -

Utiliser call() pour chaîner le constructeur d'un objet.

+### 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.

+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`. -
function Product(name, price) {
+```js
+function Product(name, price) {
   this.name = name;
   this.price = price;
 }
@@ -63,18 +62,19 @@ function Toy(name, price) {
 
 var cheese = new Food('feta', 5);
 var fun = new Toy('robot', 40);
-
+``` -

Utiliser call() pour invoquer une fonction anonyme

+### 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.

+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. -
var animaux = [
+```js
+var animaux = [
   {espece: 'Lion', nom: 'Roi'},
   {espece: 'Éléphant', nom: 'Dumbo'}
 ];
 
-for (var i = 0; i < animaux.length; i++) {
+for (var i = 0; i < animaux.length; i++) {
   (function (i) {
     this.print = function () {
       console.log('#' + i  + ' ' + this.espece + ' : ' + this.nom);
@@ -82,13 +82,14 @@ for (var i = 0; i < animaux.length; i++) {
     this.print();
   }).call(animaux[i], i);
 }
-
+``` -

Utiliser call() pour appeler une fonction avec un objet pour this

+### 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 :

+Dans l'exemple qui suit, on utilise la méthode `call()` sur la fonction `saluer()` afin de l'appliquer à l'objet `personne1` : -
function saluer() {
+```js
+function saluer() {
   var reponse = [this.nom, "est un", this.role, "."].join(" ");
   console.log(reponse);
 }
@@ -99,76 +100,51 @@ var personne1 = {
 };
 
 saluer.call(personne1); // Sénèque est un philosophe.
-
+``` -

Utiliser call() pour appeler une fonction sans indiquer de premier argument

+### 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 :

- -
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.

- -
'use strict';
+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(); // Cannot read the property prenom' of undefined
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{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

- - +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) diff --git a/files/fr/web/javascript/reference/global_objects/function/caller/index.md b/files/fr/web/javascript/reference/global_objects/function/caller/index.md index 92f4a60f1a..c7736a0831 100644 --- a/files/fr/web/javascript/reference/global_objects/function/caller/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/caller/index.md @@ -9,74 +9,73 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller original_slug: Web/JavaScript/Reference/Objets_globaux/Function/caller --- -
{{JSRef}} {{non-standard_header}}
+{{JSRef}} {{non-standard_header}} -

La propriété function.caller renvoie la fonction qui a appelé la fonction donnée. Cette propriété est interdite en mode strict.

+La propriété **`function.caller`** renvoie la fonction qui a appelé la fonction donnée. Cette propriété est interdite en mode strict. -

Description

+## Description -

Si la fonction f a été invoquée par du code situé au plus haut niveau, la valeur de f.caller sera {{jsxref("null")}}, sinon, ce sera la fonction qui a appelé f.

+Si la fonction `f` a été invoquée par du code situé au plus haut niveau, la valeur de `f.caller` sera {{jsxref("null")}}, sinon, ce sera la fonction qui a appelé `f`. -

Cette propriété remplace la propriété obsolète {{jsxref("Fonctions/arguments/caller", "arguments.caller")}} de l'objet {{jsxref("Fonctions/arguments", "arguments")}}.

+Cette propriété remplace la propriété obsolète {{jsxref("Fonctions/arguments/caller", "arguments.caller")}} de l'objet {{jsxref("Fonctions/arguments", "arguments")}}. -

La propriété spéciale __caller__ qui renvoyait l'objet qui dans lequel était fait l'appel a été supprimée pour des raisons de sécurités.

+La propriété spéciale `__caller__` qui renvoyait l'objet qui dans lequel était fait l'appel a été supprimée pour des raisons de sécurités. -

Notes

+### Notes -

Dans une fonction récursive, cette propriété ne peut pas être utilisée pour reconstituer la pile d'appels (call stack). Par exemple, si on a :

+Dans une fonction récursive, cette propriété ne peut pas être utilisée pour reconstituer la pile d'appels (_call stack_). Par exemple, si on a : -
function f(n) { g(n - 1); }
-function g(n) { if (n > 0) { f(n); } else { stop(); } }
+```js
+function f(n) { g(n - 1); }
+function g(n) { if (n > 0) { f(n); } else { stop(); } }
 f(2);
-
+``` -

Au moment où stop() est appelé, la pile sera :

+Au moment où `stop()` est appelé, la pile sera : -
f(2) -> g(1) -> f(1) -> g(0) -> stop()
-
+ f(2) -> g(1) -> f(1) -> g(0) -> stop() -

Et ceci est vrai :

+Et ceci est vrai : -
stop.caller === g && f.caller === g && g.caller === f
-
+ stop.caller === g && f.caller === g && g.caller === f -

Donc si on essaie d'obtenir la pile de cette façon :

+Donc si on essaie d'obtenir la pile de cette façon : -
var f = stop;
+```js
+var f = stop;
 var stack = 'Stack trace:';
 while (f) {
   stack += '\n' + f.name;
   f = f.caller;
 }
-
+``` -

la boucle ne s'arrêterait jamais.

+la boucle ne s'arrêterait jamais. -

Exemples

+## Exemples -

Vérifier la valeur de la propriété caller

+### Vérifier la valeur de la propriété `caller` -

Dans l'exemple suivant, on verifie la propriété caller de la fonction.

+Dans l'exemple suivant, on verifie la propriété `caller` de la fonction. -
function maFonction() {
+```js
+function maFonction() {
   if (maFonction.caller == null) {
     return 'Fonction appelée au plus haut niveau !';
   } else {
     return 'Fonction appelée par ' + maFonction.caller;
   }
 }
-
+``` -

Spécifications

+## Spécifications -

Ne fait partie d'aucune spécification. Implémentée avec JavaScript 1.5.

+Ne fait partie d'aucune spécification. Implémentée avec JavaScript 1.5. -

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

{{Compat("javascript.builtins.Function.caller")}}

+{{Compat("javascript.builtins.Function.caller")}} -

Voir aussi

+## Voir aussi - +- Le bug d'implémentation pour SpiderMonkey {{bug(65683)}} diff --git a/files/fr/web/javascript/reference/global_objects/function/displayname/index.md b/files/fr/web/javascript/reference/global_objects/function/displayname/index.md index 41224d8f33..374722f47c 100644 --- a/files/fr/web/javascript/reference/global_objects/function/displayname/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/displayname/index.md @@ -10,15 +10,16 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName original_slug: Web/JavaScript/Reference/Objets_globaux/Function/displayName --- -
{{JSRef}} {{Non-standard_header}}
+{{JSRef}} {{Non-standard_header}} -

La propriété function.displayName renvoie le nom affiché de la fonction.

+La propriété **`function.displayName`** renvoie le nom affiché de la fonction. -

Description

+## Description -

Lorsque la propriété displayName est définie, elle renvoie le nom affiché de la fonction :

+Lorsque la propriété `displayName` est définie, elle renvoie le nom affiché de la fonction : -
function faireTruc() { }
+```js
+function faireTruc() { }
 
 console.log(faireTruc.displayName); // "undefined"
 
@@ -27,11 +28,12 @@ var logMessage = function(contenu) { console.log(contenu) };
 logMessage.displayName = 'Afficher les messages dans le journal';
 
 console.log(logMessage.displayName); // "Afficher les messages dans le journal"
-
+``` -

Il est possible de définir une fonction avec un nom d'affichage grâce à une {{jsxref("Fonctions", "expression de fonctions","",1)}}:

+Il est possible de définir une fonction avec un nom d'affichage grâce à une {{jsxref("Fonctions", "expression de fonctions","",1)}}: -
var objet = {
+```js
+var objet = {
   uneMéthode: function () {}
 };
 
@@ -42,11 +44,12 @@ console.log(objet.uneMéthode.displayName);
 
 try { uneMéthode } catch(e) { console.log(e); }
 // ReferenceError: uneMéthode is not defined
-
+``` -

La propriété displayName peut être changée dynamiquement :

+La propriété `displayName` peut être changée dynamiquement : -
var objet = {
+```js
+var objet = {
   // anonyme
   uneMéthode: function(valeur) {
     this.displayName = "uneMéthode (" + valeur + ")";
@@ -57,24 +60,25 @@ console.log(objet.uneMéthode.displayName); // "undefined"
 
 objet.uneMéthode("123")
 console.log(objet.uneMéthode.displayName); // "uneMéthode (123)"
-
+``` -

Exemples

+## Exemples -

On souhaite généralement utiliser cette propriété dans les consoles et profileurs plutôt que {{jsxref("Function.name", "func.name")}}

+On souhaite généralement utiliser cette propriété dans les consoles et profileurs plutôt que {{jsxref("Function.name", "func.name")}} -

Le code suivant devrait afficher quelque chose comme "function Ma Fonction()":

+Le code suivant devrait afficher quelque chose comme "function Ma Fonction()": -
var a = function () { };
+```js
+var a = function () { };
 a.displayName = 'Ma Fonction';
 
 a;
-
+``` -

Spécifications

+## Spécifications -

N'appartient à aucune spécification.

+N'appartient à aucune spécification. -

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

{{Compat("javascript.builtins.Function.displayName")}}

+{{Compat("javascript.builtins.Function.displayName")}} diff --git a/files/fr/web/javascript/reference/global_objects/function/index.md b/files/fr/web/javascript/reference/global_objects/function/index.md index cbac58bc3c..4db2a14baa 100644 --- a/files/fr/web/javascript/reference/global_objects/function/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/index.md @@ -9,60 +9,59 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function original_slug: Web/JavaScript/Reference/Objets_globaux/Function --- -
{{JSRef}}
+{{JSRef}} -

Le constructeur Function crée un nouvel objet Function. En JavaScript, chaque fonction est un objet Function.

+Le constructeur **`Function`** crée un nouvel _objet_ `Function`. En JavaScript, chaque fonction est un objet `Function`. -

Appeler ce constructeur permet de créer des fonctions dynamiquement mais cette méthode souffre de défauts équivalents à {{jsxref("eval")}} en termes de sécurité et de performance. Toutefois, à la différence d'eval, le constructeur Function permet d'exécuter du code dans la portée globale.

+Appeler ce constructeur permet de créer des fonctions dynamiquement mais cette méthode souffre de défauts équivalents à {{jsxref("eval")}} en termes de sécurité et de performance. Toutefois, à la différence d'`eval`, le constructeur `Function` permet d'exécuter du code dans la portée globale. -
{{EmbedInteractiveExample("pages/js/function-constructor.html")}}
+{{EmbedInteractiveExample("pages/js/function-constructor.html")}} -

Syntaxe

+## Syntaxe -
new Function ([arg1[, arg2[, ...argN]],] corpsFonction)
+ new Function ([arg1[, arg2[, ...argN]],] corpsFonction) -

Paramètres

+### Paramètres -
-
arg1, arg2, ... argN
-
Les noms utilisés par la fonction pour les arguments formellement déclarés. Chacun doit être une chaîne de caractères correspondant à un identifiant JavaScript valide (ou une liste de telles chaînes séparées par des virgules). Par exemple : "x", "uneValeur", ou "a,b".
-
corpsFonction
-
Une chaîne de caractères qui contient les instructions JavaScript définissant la fonction.
-
+- `arg1, arg2, ... argN` + - : Les noms utilisés par la fonction pour les arguments formellement déclarés. Chacun doit être une chaîne de caractères correspondant à un identifiant JavaScript valide (ou une liste de telles chaînes séparées par des virgules). Par exemple : "`x`", "`uneValeur`", ou "`a,b`". +- `corpsFonction` + - : Une chaîne de caractères qui contient les instructions JavaScript définissant la fonction. -

Description

+## Description -

Les objets Function créés avec le constructeur Function sont analysés quand la fonction est créée. Ceci est moins efficace que de déclarer une fonction grâce à une {{jsxref("Opérateurs/L_opérateur_function","expression de fonction","",1)}} ou à une instruction {{jsxref("Instructions/function","function")}} car celles crées de cette façon sont analysées avec le reste du code.

+Les objets `Function` créés avec le constructeur `Function` sont analysés quand la fonction est créée. Ceci est moins efficace que de déclarer une fonction grâce à une {{jsxref("Opérateurs/L_opérateur_function","expression de fonction","",1)}} ou à une instruction {{jsxref("Instructions/function","function")}} car celles crées de cette façon sont analysées avec le reste du code. -

Tous les arguments passés à la fonction seront traités avec les noms des identifiants des paramètres de la fonction à créer, dans le même ordre dans lequel ils ont été passés. Si un argument n'est pas passé, la valeur du paramètre dans la fonction sera {{jsxref("undefined")}}.

+Tous les arguments passés à la fonction seront traités avec les noms des identifiants des paramètres de la fonction à créer, dans le même ordre dans lequel ils ont été passés. Si un argument n'est pas passé, la valeur du paramètre dans la fonction sera {{jsxref("undefined")}}. -

Appeler le constructeur Function comme une fonction (c'est-à-dire sans utiliser l'opérateur {{jsxref("Opérateurs/L_opérateur_new","new")}}) a le même effet que quand il est appelé comme constructeur.

+Appeler le constructeur `Function` comme une fonction (c'est-à-dire sans utiliser l'opérateur {{jsxref("Opérateurs/L_opérateur_new","new")}}) a le même effet que quand il est appelé comme constructeur. -

Propriétés et méthodes de Function

+## Propriétés et méthodes de `Function` -

L'objet global Function ne possède pas de méthodes ou de propriétés propres. Cependant, il est lui-même une fonction et hérite de certaines méthodes et propriétés depuis {{jsxref("Function.prototype")}} grâce à la chaîne de prototype.

+L'objet global `Function` ne possède pas de méthodes ou de propriétés propres. Cependant, il est lui-même une fonction et hérite de certaines méthodes et propriétés depuis {{jsxref("Function.prototype")}} grâce à la chaîne de prototype. -

Le prototype de Function

+## Le prototype de `Function` -

Propriétés

+### Propriétés -
{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/prototype', 'Propri.C3.A9t.C3.A9s')}}
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/prototype', 'Propri.C3.A9t.C3.A9s')}} -

Méthodes

+### Méthodes -
{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/prototype', 'M.C3.A9thodes')}}
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/prototype', 'M.C3.A9thodes')}} -

Les instances de Function

+## Les instances de `Function` -

Les instances de Function héritent des méthodes et propriétés de {{jsxref("Function.prototype")}}. Comme pour les autres constructeurs, il est possible de modifier le prototype du constructeur afin d'apporter des modifications à toutes les instances de Function.

+Les instances de `Function` héritent des méthodes et propriétés de {{jsxref("Function.prototype")}}. Comme pour les autres constructeurs, il est possible de modifier le prototype du constructeur afin d'apporter des modifications à toutes les instances de `Function`. -

Exemple

+## Exemple -

Définir des arguments avec le constructeur Function

+### Définir des arguments avec le constructeur `Function` -

Le code suivant permet de créer un objet Function qui utilise deux arguments :

+Le code suivant permet de créer un objet `Function` qui utilise deux arguments : -
// Cet exemple peut être lancé dans votre console JavaScript
+```js
+// Cet exemple peut être lancé dans votre console JavaScript
 
 // On crée un fonction qui prend deux arguments
 // et qui en renvoie la somme
@@ -70,16 +69,17 @@ var ajoute = new Function('a', 'b', 'return a + b');
 
 // On appelle la fonction
 ajoute(2, 6);
-// > 8
-
+// > 8 +``` -

Les arguments "a" et "b" sont les noms des arguments formellement déclarés utilisés dans le corps de la fonction : "return a + b".

+Les arguments "`a`" et "`b`" sont les noms des arguments formellement déclarés utilisés dans le corps de la fonction : "`return a + b`". -

Différence entre le constructeur Function et les déclarations de fonction

+### Différence entre le constructeur `Function` et les déclarations de fonction -

Les fonctions créées avec le constructeur {{jsxref("Function()")}} ne créent pas de fermetures liées au contexte de leur création. Ainsi, lorsqu'elles sont exécutées, elles ne peuvent accéder qu'aux variables globales et à leurs propres valeurs locales. Elles ne peuvent pas accéder aux variables de la portée dans laquelle le constructeur Function a été invoqué. Le comportement est différent de celui qu'on obtient avec {{jsxref("eval")}} avec du code contenant une expression de fonction.

+Les fonctions créées avec le constructeur {{jsxref("Function()")}} ne créent pas de fermetures liées au contexte de leur création. Ainsi, lorsqu'elles sont exécutées, elles ne peuvent accéder qu'aux variables globales et à leurs propres valeurs locales. Elles ne peuvent pas accéder aux variables de la portée dans laquelle le constructeur `Function` a été invoqué. Le comportement est différent de celui qu'on obtient avec {{jsxref("eval")}} avec du code contenant une expression de fonction. -
var x = 10;
+```js
+var x = 10;
 
 function créerFonction1() {
   var x = 20;
@@ -97,54 +97,30 @@ function créerFonction2() {
 var f1 = créerFonction1();
 console.log(f1());          // 10
 var f2 = créerFonction2();
-console.log(f2());          // 20
- -

Bien que ce code fonctionne dans un navigateur web, l'appel à f1() provoquera une {{jsxref("ReferenceError")}} dans Node.js car x ne sera pas trouvé. En effet, pour Node, la portée de plus haut niveau n'est pas la portée globale et x est ici local à la fonction.

- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.3', 'Function')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-function-objects', 'Function')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-function-objects', 'Function')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Function")}}

- -

Voir aussi

- - +console.log(f2()); // 20 +``` + +Bien que ce code fonctionne dans un navigateur web, l'appel à `f1()` provoquera une {{jsxref("ReferenceError")}} dans Node.js car `x` ne sera pas trouvé. En effet, pour Node, la portée de plus haut niveau n'est pas la portée globale et `x` est ici local à la fonction. + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.3', 'Function')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-function-objects', 'Function')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-function-objects', 'Function')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Function")}} + +## Voir aussi + +- {{jsxref("Fonctions", "Les fonctions","",1)}} +- L'instruction {{jsxref("Instructions/function", "function")}} +- L'expression {{jsxref("Opérateurs/L_opérateur_function", "function")}} +- L'instruction {{jsxref("Instructions/function*", "function*")}} +- L'expression {{jsxref("Opérateurs/function*", "function*")}} +- {{jsxref("AsyncFunction")}} +- {{jsxref("GeneratorFunction")}} diff --git a/files/fr/web/javascript/reference/global_objects/function/length/index.md b/files/fr/web/javascript/reference/global_objects/function/length/index.md index 7493f7d759..359031b990 100644 --- a/files/fr/web/javascript/reference/global_objects/function/length/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/length/index.md @@ -9,31 +9,28 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function/length original_slug: Web/JavaScript/Reference/Objets_globaux/Function/length --- -
{{JSRef}}
+{{JSRef}} -

La propriété length définit le nombre de paramètres attendus par la fonction.

+La propriété **`length`** définit le nombre de paramètres attendus par la fonction. -
{{EmbedInteractiveExample("pages/js/function-length.html")}}
+{{EmbedInteractiveExample("pages/js/function-length.html")}}{{js_property_attributes(0,0,1)}} +## Description +`length` est une propriété des fonctions qui indique le nombre d'arguments attendus par la fonction (ce qui correspond au nombre d'arguments formellement déclarés). Cette quantité n'inclue pas les {{jsxref("Fonctions/paramètres_du_reste", "paramètres du reste", "", 1)}} et ne compte que les paramètres situés avant le premier paramètre avec une valeur par défaut. Cette propriété est différente de {{jsxref("Fonctions/arguments/length", "arguments.length")}} qui est locale à la fonction et qui décrit le nombre d'arguments réellement passés à la fonction. -
{{js_property_attributes(0,0,1)}}
+### Propriété du constructeur `Function` -

Description

+Le constructeur {{jsxref("Function")}} est lui-même un objet {{jsxref("Function")}}. Sa propriété` length` vaut 1. Les attributs de cette propriété sont : Écrivable : `false`, Énumérable : `false`, Configurable : `true`. -

length est une propriété des fonctions qui indique le nombre d'arguments attendus par la fonction (ce qui correspond au nombre d'arguments formellement déclarés). Cette quantité n'inclue pas les {{jsxref("Fonctions/paramètres_du_reste", "paramètres du reste", "", 1)}} et ne compte que les paramètres situés avant le premier paramètre avec une valeur par défaut. Cette propriété est différente de {{jsxref("Fonctions/arguments/length", "arguments.length")}} qui est locale à la fonction et qui décrit le nombre d'arguments réellement passés à la fonction.

+### Propriété du prototype de `Function` -

Propriété du constructeur Function

+La propriété `length` du prototype de {{jsxref("Function")}} vaut 0. -

Le constructeur {{jsxref("Function")}} est lui-même un objet {{jsxref("Function")}}. Sa propriété length vaut 1. Les attributs de cette propriété sont : Écrivable : false, Énumérable : false, Configurable : true.

+## Exemples -

Propriété du prototype de Function

- -

La propriété length du prototype de {{jsxref("Function")}} vaut 0.

- -

Exemples

- -
console.log(Function.length); /* 1 */
+```js
+console.log(Function.length); /* 1 */
 
 console.log((function()        {}).length); /* 0 */
 console.log((function(a)       {}).length); /* 1 */
@@ -43,46 +40,21 @@ console.log((function(...args) {}).length);
 console.log((function(a, b = 1, c) {}).length);
 // 1, seuls les paramètres avant les valeurs par
 // défaut sont comptés
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.3.5.1', 'Function.length')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}{{Spec2('ES6')}}L'attribut configurable de cette propriété vaut true désormais.
{{SpecName('ESDraft', '#sec-function-instances-length', 'Function.length')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Function.length")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.3.5.1', 'Function.length')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}} | {{Spec2('ES6')}} | L'attribut `configurable` de cette propriété vaut `true` désormais. | +| {{SpecName('ESDraft', '#sec-function-instances-length', 'Function.length')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Function.length")}} + +## Voir aussi + +- {{jsxref("Function", "Function")}} diff --git a/files/fr/web/javascript/reference/global_objects/function/name/index.md b/files/fr/web/javascript/reference/global_objects/function/name/index.md index 0f8df52d94..2d1fe90437 100644 --- a/files/fr/web/javascript/reference/global_objects/function/name/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/name/index.md @@ -10,133 +10,142 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function/name original_slug: Web/JavaScript/Reference/Objets_globaux/Function/name --- -
{{JSRef}}
+{{JSRef}} -

La propriété function.name est une propriété en lecture seule qui renvoie le nom de la fonction courante ou "anonymous" si celle-ci a été créée de façon anonyme.

+La propriété **`function.name`** est une propriété en lecture seule qui renvoie le nom de la fonction courante ou `"anonymous"` si celle-ci a été créée de façon anonyme. -
{{EmbedInteractiveExample("pages/js/function-name.html")}}
+{{EmbedInteractiveExample("pages/js/function-name.html")}}{{js_property_attributes(0,0,1)}} +> **Note :** Dans les implémentations non-standards antérieures à ES2015, l'attribut `configurable` valait `false`. +## Exemples -
{{js_property_attributes(0,0,1)}}
+### Instruction de fonction -
-

Note : Dans les implémentations non-standards antérieures à ES2015, l'attribut configurable valait false.

-
+La propriété `name` renvoie le nom de la fonction lorsque celle-ci est utilisée dans une instruction de fonction. -

Exemples

- -

Instruction de fonction

- -

La propriété name renvoie le nom de la fonction lorsque celle-ci est utilisée dans une instruction de fonction.

- -
function faireUnTruc() {}
+```js
+function faireUnTruc() {}
 faireUnTruc.name; // "faireUnTruc"
-
+``` -

Fonctions créées avec un constructeur

+### Fonctions créées avec un constructeur -

Lorsqu'on crée une fonction avec new Function(...) ou simplement Function(...), on crée uniquement des objets dont le nom est "anonymous".

+Lorsqu'on crée une fonction avec `new Function(...)` ou simplement `Function(...)`, on crée uniquement des objets dont le nom est "anonymous". -
(new Function).name; // "anonymous"
+```js +(new Function).name; // "anonymous" +``` -

Inférence des noms de fonction

+### Inférence des noms de fonction -

Les variables et les méthodes permettent d'inférer (c'est-à-dire de « deviner ») le nom des fonctions anonymes en fonction de leur position syntaxique (cette fonctionnalité est apparue avec ECMAScript 2015).

+Les variables et les méthodes permettent d'inférer (c'est-à-dire de « deviner ») le nom des fonctions anonymes en fonction de leur position syntaxique (cette fonctionnalité est apparue avec ECMAScript 2015). -
var f = function() {};
+```js
+var f = function() {};
 var objet = {
   uneMéthode: function() {}
 };
 
 console.log(f.name); // "f"
 console.log(objet.uneMéthode.name); // "uneMéthode"
-
+``` -

On peut définir une fonction avec un nom grâce à une {{jsxref("Opérateurs/L_opérateur_function", "expression de fonction", "", 1)}}:

+On peut définir une fonction avec un nom grâce à une {{jsxref("Opérateurs/L_opérateur_function", "expression de fonction", "", 1)}}: -
var objet = {
+```js
+var objet = {
   uneMéthode: function objet_maMéthode() {}
 };
 console.log(objet.uneMéthode.name); // logs "objet_maMéthode"
 
 try { objet_maMéthode } catch(e) { console.log(e); }
 // ReferenceError: objet_maMéthode is not defined
-
+``` -

On ne peut pas changer le nom d'une fonction, cette propriété est uniquement en lecture :

+On ne peut pas changer le nom d'une fonction, cette propriété est uniquement en lecture : -
var objet = {
+```js
+var objet = {
   // anonyme
   uneMéthode: function() {}
 };
 
 objet.uneMéthode.name = 'uneMéthode';
 console.log(object.uneMéthode.name); // une chaîne vide, uneMéthode est anonyme
-
+``` -

Pour modifier le nom, on pourrait cependant utiliser la méthode {{jsxref("Object.defineProperty()")}}.

+Pour modifier le nom, on pourrait cependant utiliser la méthode {{jsxref("Object.defineProperty()")}}. -

Notation raccourcie pour les méthodes

+### Notation raccourcie pour les méthodes -
var o = {
+```js
+var o = {
   toto(){}
 };
-o.toto.name; // "toto";
+o.toto.name; // "toto"; +``` -

Noms des fonctions liées

+### Noms des fonctions liées -

{{jsxref("Function.bind()")}} produit une fonction dont le nom sera la chaîne "bound " suivi du nom de la fonction.

+{{jsxref("Function.bind()")}} produit une fonction dont le nom sera la chaîne "bound " suivi du nom de la fonction. -
function toto() {};
+```js
+function toto() {};
 toto.bind({}).name; // "bound toto"
-
+``` -

Noms de fonction pour les accesseurs et les mutateurs

+### Noms de fonction pour les accesseurs et les mutateurs -

Lorsqu'on utilise les propriétés d'accesseur get / set, "get" ou "set" apparaîtra avant le nom de la fonction.

+Lorsqu'on utilise les propriétés d'accesseur [`get`](/fr/docs/Web/JavaScript/Reference/Fonctions/get) / [`set`](/fr/docs/Web/JavaScript/Reference/Fonctions/set), "get" ou "set" apparaîtra avant le nom de la fonction. -
var o = {
+```js
+var o = {
   get toto(){},
   set toto(x){}
 };
 
 var descripteur = Object.getOwnPropertyDescriptor(o, "toto");
 descripteur.get.name; // "get toto"
-descripteur.set.name; // "set toto";
+descripteur.set.name; // "set toto"; +``` -

Noms des fonctions utilisées dans les classes

+### Noms des fonctions utilisées dans les classes -

On peut utiliser la notation obj.constructor.name pour vérifier la « classe » d'un objet (attention aux avertissements ci-après) :

+On peut utiliser la notation `obj.constructor.name` pour vérifier la « classe » d'un objet (attention aux avertissements ci-après) : -
function Toto() {}  // Syntaxe ES2015 : class Toto {}
+```js
+function Toto() {}  // Syntaxe ES2015 : class Toto {}
 
 var instanceDeToto = new Toto();
 console.log(instanceDeToto.constructor.name); // affiche "Toto" dans la console
-
+``` -

Attention : l'interpréteur utilisera la propriété native Function.name uniquement si la fonction ne possède pas une propriété en propre intitulée name (cf section 9.2.11 de la spécification ECMAScript2015). Cependant, ES2015 indique que les propriétés définies avec mot-clé static seront des propriétés propres de la fonction constructrice (cf. ECMAScript2015, 14.5.14.21.b + 12.2.6.9). Ainsi, il n'est plus possible d'obtenir le nom de la classe si celle-ci possède une méthode statique intitulée name() :

+**Attention :** l'interpréteur utilisera la propriété native `Function.name` uniquement si la fonction ne possède pas une propriété en propre intitulée _name_ (cf section [9.2.11 de la spécification ECMAScript2015](https://www.ecma-international.org/ecma-262/6.0/#sec-setfunctionname)). Cependant, ES2015 indique que les propriétés définies avec mot-clé _static_ seront des propriétés propres de la fonction constructrice (cf. ECMAScript2015, [14.5.14.21.b](https://www.ecma-international.org/ecma-262/6.0/#sec-runtime-semantics-classdefinitionevaluation) + [12.2.6.9](https://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer-runtime-semantics-propertydefinitionevaluation)). Ainsi, il n'est plus possible d'obtenir le nom de la classe si celle-ci possède une méthode statique intitulée `name()` : -
class Toto {
+```js
+class Toto {
   constructor() {}
   static name() {}
 }
-
+``` -

Avec static name(), Toto.name ne contient plus le nom de la classe mais une référence à l'objet name(). La définition utilisée ci-avant se comporte de façon semblable à ce fragment de code ES5 :

+Avec `static name()`, `Toto.name` ne contient plus le nom de la classe mais une référence à l'objet `name()`. La définition utilisée ci-avant se comporte de façon semblable à ce fragment de code ES5 : -
function Toto() {}
+```js
+function Toto() {}
 Object.defineProperty(Toto, 'name', { writable: true });
 Toto.name = function() {};
-
+``` -

Il est donc parfois erroné de penser que Function.name pointe toujours vers le nom de la classe.

+Il est donc parfois erroné de penser que `Function.name` pointe toujours vers le nom de la classe. -

Noms de fonction sous la forme de symboles

+### Noms de fonction sous la forme de symboles -

Si un symbole ({{jsxref("Symbol")}}) est utilisé comme nom d'une fonction et que celui-ci dispose d'une description, c'est cette dernière qui sera utilisée comme nom de la méthode, entre crochets :

+Si un symbole ({{jsxref("Symbol")}}) est utilisé comme nom d'une fonction et que celui-ci dispose d'une description, c'est cette dernière qui sera utilisée comme nom de la méthode, entre crochets : -
var sym1 = Symbol("Toto");
+```js
+var sym1 = Symbol("Toto");
 var sym2 = Symbol();
 var o = {
   [sym1]: function(){},
@@ -144,13 +153,15 @@ var o = {
 };
 
 o[sym1].name; // "[Toto]"
-o[sym2].name; // ""
+o[sym2].name; // "" +``` -

Compresseurs et outils de minification JavaScript

+## Compresseurs et outils de minification JavaScript -

Attention à l'utilisation de Function.name lorsque le code source est transformé par certains outils. En effet, ceux-ci réduisent généralement la taille d'un programme en compressant les espaces et en modifiant parfois les noms de variables. Ainsi, un fragment de code comme :

+Attention à l'utilisation de `Function.name` lorsque le code source est transformé par certains outils. En effet, ceux-ci réduisent généralement la taille d'un programme en compressant les espaces et en modifiant parfois les noms de variables. Ainsi, un fragment de code comme : -
function Toto() {};
+```js
+function Toto() {};
 var toto = new Toto();
 
 if (Toto.constructor.name === 'Toto') {
@@ -158,43 +169,29 @@ if (Toto.constructor.name === 'Toto') {
 } else {
   console.log('Oups !');
 }
-
+``` -

pourrait être compressé en :

+pourrait être compressé en : -
function a() {};
+```js
+function a() {};
 var b = new a();
 if (b.constructor.name === 'Toto') {
   console.log("'toto' est une instance de 'Toto'");
 } else {
   console.log('Oups !');
 }
-
- -

Dans la version non-compressée, la condition du test est remplie et on affiche 'toto' est une instance de 'Toto' dans la console. Mais dans la version compressée, la condition n'est pas vérifiée. Lorsqu'on utilise name, il faut s'assurer que les outils utilisés ne modifient pas le nom des fonctions.

- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-name', 'name')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-function-instances-name', 'name')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Function.name")}}

+``` + +Dans la version non-compressée, la condition du test est remplie et on affiche _'toto' est une instance de 'Toto'_ dans la console. Mais dans la version compressée, la condition n'est pas vérifiée. Lorsqu'on utilise `name`, il faut s'assurer que les outils utilisés ne modifient pas le nom des fonctions. + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------ | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-name', 'name')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-function-instances-name', 'name')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Function.name")}} diff --git a/files/fr/web/javascript/reference/global_objects/function/tosource/index.md b/files/fr/web/javascript/reference/global_objects/function/tosource/index.md index cfc1e8f26a..ad358e7be6 100644 --- a/files/fr/web/javascript/reference/global_objects/function/tosource/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/tosource/index.md @@ -9,58 +9,55 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource original_slug: Web/JavaScript/Reference/Objets_globaux/Function/toSource --- -
{{JSRef}}{{non-standard_header}}
+{{JSRef}}{{non-standard_header}} -

La méthode toSource() renvoie une chaîne de caractères représentant le code source de l'objet.

+La méthode **`toSource()`** renvoie une chaîne de caractères représentant le code source de l'objet. -

Syntaxe

+## Syntaxe -
function.toSource();
-Function.toSource();
-
+ function.toSource(); + Function.toSource(); -

Valeur de retour

+### Valeur de retour -

Une chaîne de caractères représentant le code source de l'objet.

+Une chaîne de caractères représentant le code source de l'objet. -

Description

+## Description -

La méthode toSource() renvoie les valeurs suivantes :

+La méthode `toSource()` renvoie les valeurs suivantes : - +- Pour les fonctions définies dans les scripts, `toSource()` renverra la chaîne correspondant au code source JavaScript de l'objet. -

De façon générale, cette méthode est utilisée en interne par le moteur JavaScript et n'est pas utilisée dans les scripts tiers. Il est possible d'utiliser cette méthode pour une aide au débogage et pouvoir examiner le contenu d'un objet.

+ ```js + function coucou() { + console.log("Coucou le monde"); + } -

Spécifications

+ coucou.toSource(); + // produira la chaîne de caractères + // "function coucou() { + // console.log(\"Coucou le monde\"); + // }" + ``` -

Ne fait partie d'aucune spécification. Implémentée avec JavaScript 1.3.

+De façon générale, cette méthode est utilisée en interne par le moteur JavaScript et n'est pas utilisée dans les scripts tiers. Il est possible d'utiliser cette méthode pour une aide au débogage et pouvoir examiner le contenu d'un objet. -

Compatibilité des navigateurs

+## Spécifications -

{{Compat("javascript.builtins.Function.toSource")}}

+Ne fait partie d'aucune spécification. Implémentée avec JavaScript 1.3. -

Voir aussi

+## Compatibilité des navigateurs - +{{Compat("javascript.builtins.Function.toSource")}} + +## Voir aussi + +- {{jsxref("Object.prototype.toSource()")}} diff --git a/files/fr/web/javascript/reference/global_objects/function/tostring/index.md b/files/fr/web/javascript/reference/global_objects/function/tostring/index.md index 625eb83203..0eac5c45c6 100644 --- a/files/fr/web/javascript/reference/global_objects/function/tostring/index.md +++ b/files/fr/web/javascript/reference/global_objects/function/tostring/index.md @@ -10,86 +10,62 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString original_slug: Web/JavaScript/Reference/Objets_globaux/Function/toString --- -
{{JSRef}}
+{{JSRef}} -

La méthode toString() renvoie une chaîne de caractères représentant le code source de la fonction.

+La méthode **`toString()`** renvoie une chaîne de caractères représentant le code source de la fonction. -
{{EmbedInteractiveExample("pages/js/function-tostring.html")}}
+{{EmbedInteractiveExample("pages/js/function-tostring.html")}} -

Syntaxe

+## Syntaxe -
function.toString(indentation)
+ function.toString(indentation) -

Valeur de retour

+### Valeur de retour -

Une chaîne de caractères qui représente le code source de la fonction.

+Une chaîne de caractères qui représente le code source de la fonction. -

Description

+## Description -

L'objet {{jsxref("Function")}} redéfinit la méthode {{jsxref("Object.prototype.toString", "toString")}} de l'objet {{jsxref("Object")}} ; il n'hérite donc pas de {{jsxref("Object.prototype.toString")}}. Pour les objets {{jsxref("Function")}}, la méthode toString renvoie une chaîne de caractères représentant l'objet sous la forme d'une déclaration de fonction. Pour ce faire, toString décompile la fonction pour renvoyer une chaîne qui contient le mot-clé function, la liste des arguments, les accolades et la source correspondant au corps de la fonction.

+L'objet {{jsxref("Function")}} redéfinit la méthode {{jsxref("Object.prototype.toString", "toString")}} de l'objet {{jsxref("Object")}} ; il n'hérite donc pas de {{jsxref("Object.prototype.toString")}}. Pour les objets {{jsxref("Function")}}, la méthode `toString` renvoie une chaîne de caractères représentant l'objet sous la forme d'une déclaration de fonction. Pour ce faire, `toString` décompile la fonction pour renvoyer une chaîne qui contient le mot-clé `function`, la liste des arguments, les accolades et la source correspondant au corps de la fonction. -

Le moteur JavaScript appelle la méthode toString automatiquement lorsqu'un objet {{jsxref("Function")}} doit être représenté textuellement (par exemple lorsqu'une fonction doit être concaténée avec une chaîne de caractères).

+Le moteur JavaScript appelle la méthode `toString` automatiquement lorsqu'un objet {{jsxref("Function")}} doit être représenté textuellement (par exemple lorsqu'une fonction doit être concaténée avec une chaîne de caractères). -

La méthode toString() lèvera une exception {{jsxref("TypeError")}} (« Function.prototype.toString called on incompatible object ») si la valeur this n'est pas un objet Function.

+La méthode `toString()` lèvera une exception {{jsxref("TypeError")}} (« Function.prototype.toString called on incompatible object ») si la valeur this n'est pas un objet `Function`. -
Function.prototype.toString.call("toto"); // TypeError
-
+```js example-bad +Function.prototype.toString.call("toto"); // TypeError +``` -

Si la méthode toString() est appelée sur des fonctions natives qui ne sont pas définies dans le script, toString() renvoie une chaîne de caractères indiquant le caractère natif :

+Si la méthode `toString()` est appelée sur des fonctions natives qui ne sont pas définies dans le script, `toString()` renvoie une chaîne de caractères indiquant le caractère natif : -
Math.abs.toString();
+```js
+Math.abs.toString();
 
 "function abs() {
     [native code]
-}"
- -

Si la méthode toString() est appelée sur une fonction créée avec le constructeur Function, toString() renverra le code source d'une fonction intitulée anonymous et utilisera les paramètres et le corps de la fonction fournis.

- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.1.
Function.prototype.toString()BrouillonStandardise la chaîne de caractères utilisée pour les fonctions natives ainsi que la gestion des fins de ligne.
{{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}{{Spec2('ES6')}}Critères supplémentaires ajoutés sur la représentation de la chaîne.
{{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Function.toString")}}

- -

Notes spécifiques à Firefox

- - - -

Voir aussi

- - +}" +``` + +Si la méthode `toString()` est appelée sur une fonction créée avec le constructeur `Function`, `toString()` renverra le code source d'une fonction intitulée `anonymous` et utilisera les paramètres et le corps de la fonction fournis. + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | --------------------------------------------------------------------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.1. | +| [`Function.prototype.toString()`](https://tc39.github.io/Function-prototype-toString-revision/#sec-introduction) | Brouillon | Standardise la chaîne de caractères utilisée pour les fonctions natives ainsi que la gestion des fins de ligne. | +| {{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}} | {{Spec2('ES6')}} | Critères supplémentaires ajoutés sur la représentation de la chaîne. | +| {{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Function.toString")}} + +## Notes spécifiques à Firefox + +- À partir de Firefox 17.0, `Function.prototype.toString()` a été implémenté en sauvegardant le code source de la fonction. La méthode utilisant la décompilation a été retirée et le paramètre `indentation` n'est donc plus nécessaire. Pour plus d'informations, voir {{bug("761723")}}. +- À partir de Firefox 38 et jusqu'à Firefox 63, `Function.prototype.toString()` levait une exception pour les {{jsxref("Proxy")}} (cf. {{bug(1100936)}} et {{bug(1440468)}}). + +## Voir aussi + +- {{jsxref("Object.prototype.toString()")}} -- cgit v1.2.3-54-g00ecf