From 39f2114f9797eb51994966c6bb8ff1814c9a4da8 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 12:36:08 +0100 Subject: unslug fr: move --- .../global_objects/function/apply/index.html | 211 +++++++++++++++++ .../global_objects/function/arguments/index.html | 91 ++++++++ .../global_objects/function/bind/index.html | 250 +++++++++++++++++++++ .../global_objects/function/call/index.html | 177 +++++++++++++++ .../global_objects/function/caller/index.html | 83 +++++++ .../global_objects/function/displayname/index.html | 81 +++++++ .../reference/global_objects/function/index.html | 153 +++++++++++++ .../global_objects/function/length/index.html | 89 ++++++++ .../global_objects/function/name/index.html | 201 +++++++++++++++++ .../global_objects/function/tosource/index.html | 67 ++++++ .../global_objects/function/tostring/index.html | 98 ++++++++ 11 files changed, 1501 insertions(+) create mode 100644 files/fr/web/javascript/reference/global_objects/function/apply/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/function/arguments/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/function/bind/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/function/call/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/function/caller/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/function/displayname/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/function/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/function/length/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/function/name/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/function/tosource/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/function/tostring/index.html (limited to 'files/fr/web/javascript/reference/global_objects/function') diff --git a/files/fr/web/javascript/reference/global_objects/function/apply/index.html b/files/fr/web/javascript/reference/global_objects/function/apply/index.html new file mode 100644 index 0000000000..6c1f23d146 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/apply/index.html @@ -0,0 +1,211 @@ +--- +title: Function.prototype.apply() +slug: Web/JavaScript/Reference/Objets_globaux/Function/apply +tags: + - Function + - JavaScript + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply +--- +
{{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).

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

Syntaxe

+ +
fun.apply(thisArg, [argsArray])
+ +

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

Valeur de retour

+ +

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

+ +

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.

+ +

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.

+ +

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.

+
+ +

Exemples

+ +

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.

+ +
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++) {
+        this["propriété" + nProp] = arguments[nProp];
+    }
+}
+
+var monTableau = [4, "Coucou monde !", false];
+var monInstance = MonConstructeur.constructor(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 */
+var nombres = [5, 6, 2, 3, 7];
+
+/* usage de Math.min/Math.max et de la méthode apply */
+var max = Math.max.apply(null, nombres);
+/* Equivalent à Math.max(nombres[0], ...)
+  ou Math.max(5, 6, ..) */
+
+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)
+    max = nombres[i];
+  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:

+ +
function minimumDuTableau(tab) {
+  var min = Infinity;
+  var QUANTUM = 32768;
+
+  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);
+  }
+
+  return min;
+}
+
+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

+ + diff --git a/files/fr/web/javascript/reference/global_objects/function/arguments/index.html b/files/fr/web/javascript/reference/global_objects/function/arguments/index.html new file mode 100644 index 0000000000..13bfc16dd3 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/arguments/index.html @@ -0,0 +1,91 @@ +--- +title: Function.arguments +slug: Web/JavaScript/Reference/Objets_globaux/Function/arguments +tags: + - Déprécié + - Function + - JavaScript + - Propriété + - Reference + - arguments +translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments +--- +
{{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).

+ +

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")}}.

+ +

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

+ +

Exemples

+ +
function f(n) { g(n-1); }
+
+function g(n) {
+  console.log("avant : " + g.arguments[0]);
+  if(n>0) f(n);
+  console.log("après : " + g.arguments[0]);
+}
+
+f(2);
+
+console.log("fonction terminée : " + g.arguments);
+
+// On aura l'affichage de :
+
+// avant : 1
+// avant : 0
+// 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

+ + diff --git a/files/fr/web/javascript/reference/global_objects/function/bind/index.html b/files/fr/web/javascript/reference/global_objects/function/bind/index.html new file mode 100644 index 0000000000..dd214fe306 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/bind/index.html @@ -0,0 +1,250 @@ +--- +title: Function.prototype.bind() +slug: Web/JavaScript/Reference/Objets_globaux/Function/bind +tags: + - ECMAScript 2015 + - ECMAScript 5 + - Function + - JavaScript + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind +--- +
{{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.

+ +
{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}}
+ + + +

Syntaxe

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

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

Valeur de retour

+ +

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

+ +

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.

+ +

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

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.

+ +

Exemples

+ +

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.

+ +

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,
+            // pour un navigateur, this est
+            // l'objet window
+var module = {
+  x: 81,
+  getX: function() { return this.x; }
+};
+
+module.getX(); // 81
+
+var getX = module.getX;
+getX(); // 9, car ici, this fait référence à l'objet global
+
+// On crée une nouvelle fonction à laquelle on lie module en
+// tant que 'this'
+var boundGetX = getX.bind(module);
+boundGetX(); // 81
+
+ +

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.

+ +
function list() {
+  return Array.prototype.slice.call(arguments);
+}
+
+var list1 = list(1, 2, 3); // [1, 2, 3]
+
+// Créer une fonction avec un argument prédéfini
+var leadingThirtysevenList = list.bind(null, 37);
+
+var list2 = leadingThirtysevenList(); // [37]
+var list3 = leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3]
+
+
+function sommeArguments(arg1, arg2){
+  return arg1 + arg2;
+}
+
+var ajouter37 = sommeArguments.bind(null, 37);
+
+var resultat = ajouter37(5); // 37 + 5 = 42
+
+ +

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.

+ +
function Fleur() {
+  this.nbPétales = Math.floor( Math.random() * 12 ) + 1;
+}
+
+// On déclare floraison après un délai d'une seconde
+Fleur.prototype.floraison = function() {
+  window.setTimeout( this.declare.bind( this ), 1000 );
+};
+
+Fleur.prototype.declare = function() {
+  console.log('Je suis une fleur avec ' +
+     this.nbPétales + ' pétales !');
+};
+
+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

+ +
+

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 :

+ +
function Point(x, y) {
+  this.x = x;
+  this.y = y;
+}
+
+Point.prototype.toString = function() {
+  return this.x + "," + this.y;
+};
+
+var p = new Point(1, 2);
+p.toString(); // "1,2"
+
+
+var emptyObj = {};
+var YAxisPoint = Point.bind(emptyObj, 0 /* x */);
+// non supporté dans le polyfill ci dessous,
+// fonctionne avec le bind natif :
+var YAxisPoint = Point.bind(null,0 /* x */);
+
+var axisPoint = new YAxisPoint(5);
+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")}}.

+ +
// 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
+// (même si ce n'est généralement pas l'effet )
+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.

+ +

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.

+ +

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;
+
+// ... un peu plus loin
+
+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 :

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

+ + diff --git a/files/fr/web/javascript/reference/global_objects/function/call/index.html b/files/fr/web/javascript/reference/global_objects/function/call/index.html new file mode 100644 index 0000000000..b419b7eca6 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/call/index.html @@ -0,0 +1,177 @@ +--- +title: Function.prototype.call() +slug: Web/JavaScript/Reference/Objets_globaux/Function/call +tags: + - Function + - JavaScript + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function/call +--- +
{{JSRef}}
+ +

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

+ +
Note : Bien que la syntaxe de cette fonction ressemble à celle de {{jsxref("Function.apply", "apply()")}}, la différence fondamentale réside dans le fait que call() accepte une liste d'arguments, tandis que la méthode apply() accepte un unique tableau d'arguments.
+ +
{{EmbedInteractiveExample("pages/js/function-call.html")}}
+ + + +

Syntaxe

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

Paramètres

+ +
+
thisArg
+
La valeur this fournie pour l'appel de la fonction fun. La valeur peut être différente de celle normalement perçue par la méthode : si la méthode est une fonction utilisée dans un code en {{jsxref("Fonctions/Strict_mode", "mode non-strict", "", 1)}}, {{jsxref("null")}} and {{jsxref("undefined")}} seront remplacés par l'objet global et les valeurs primitives seront encapsulées en objets.
+
arg1, arg2, ...
+
Les arguments pour la fonction.
+
+ +

Valeur de retour

+ +

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

+ +

Description

+ +

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

+ +

Il est possible d'affecter un objet this différent lors de l'appel à une fonction existante. En général, this fait référence à l'objet courant, celui sur lequel est appelée la méthode. Avec call, on peut écrire une méthode une seule fois et ensuite en hériter dans un autre objet, sans avoir à réécrire cette méthode pour ce nouvel objet.

+ +

Exemples

+ +

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

+ +

Il est possible d'utiliser call pour chaîner le constructeur d'un objet, de façon similaire à Java. Dans l'exemple suivant, le constructeur de l'objet Product est défini avec deux paramètres, name et price. Deux autres fonctions, Food et Toy invoquent Product en passant this, name et price. Product initialise les propriétés name et price, tandis que les fonctions spécialisées définissent la propriété category.

+ +
function Product(name, price) {
+  this.name = name;
+  this.price = price;
+}
+
+function Food(name, price) {
+  Product.call(this, name, price);
+  this.category = 'food';
+}
+
+function Toy(name, price) {
+  Product.call(this, name, price);
+  this.category = 'toy';
+}
+
+var cheese = new Food('feta', 5);
+var fun = new Toy('robot', 40);
+
+ +

Utiliser call() pour invoquer une fonction anonyme

+ +

Dans cet exemple (purement inventé), on crée une fonction anonyme et on utilise call pour l'invoquer sur chaque objet d'un tableau. Le principal but de cette fonction anonyme est d'ajouter une fonction print sur chaque élément qui permet d'afficher l'index de l'objet. Le passage de l'objet en tant que valeur this n'était pas nécessaire, mais il permet d'expliquer le sujet.

+ +
var animaux = [
+  {espece: 'Lion', nom: 'Roi'},
+  {espece: 'Éléphant', nom: 'Dumbo'}
+];
+
+for (var i = 0; i < animaux.length; i++) {
+  (function (i) {
+    this.print = function () {
+      console.log('#' + i  + ' ' + this.espece + ' : ' + this.nom);
+    }
+    this.print();
+  }).call(animaux[i], i);
+}
+
+ +

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

+ +

Dans l'exemple qui suit, on utilise la méthode call() sur la fonction saluer() afin de l'appliquer à l'objet personne1 :

+ +
function saluer() {
+  var reponse = [this.nom, "est un", this.role, "."].join(" ");
+  console.log(reponse);
+}
+
+var personne1 = {
+  nom: "Sénèque",
+  role: "philosophe"
+};
+
+saluer.call(personne1); // Sénèque est un philosophe.
+
+ +

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

+ +

Dans l'exemple qui suit, on appelle la fonction afficher() sans lui passer d'argument. C'est donc l'objet global qui est utilisé comme contexte :

+ +
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';
+
+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

+ + diff --git a/files/fr/web/javascript/reference/global_objects/function/caller/index.html b/files/fr/web/javascript/reference/global_objects/function/caller/index.html new file mode 100644 index 0000000000..9956ad14ee --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/caller/index.html @@ -0,0 +1,83 @@ +--- +title: Function.caller +slug: Web/JavaScript/Reference/Objets_globaux/Function/caller +tags: + - Function + - JavaScript + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller +--- +
{{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.

+ +

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.

+ +

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.

+ +

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 :

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

+ +
f(2) -> g(1) -> f(1) -> g(0) -> stop()
+
+ +

Et ceci est vrai :

+ +
stop.caller === g && f.caller === g && g.caller === f
+
+ +

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

+ +
var f = stop;
+var stack = 'Stack trace:';
+while (f) {
+  stack += '\n' + f.name;
+  f = f.caller;
+}
+
+ +

la boucle ne s'arrêterait jamais.

+ +

Exemples

+ +

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

+ +

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

+ +
function maFonction() {
+  if (maFonction.caller == null) {
+    return 'Fonction appelée au plus haut niveau !';
+  } else {
+    return 'Fonction appelée par ' + maFonction.caller;
+  }
+}
+
+ +

Spécifications

+ +

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

+ +

Compatibilité des navigateurs

+ + + +

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

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/function/displayname/index.html b/files/fr/web/javascript/reference/global_objects/function/displayname/index.html new file mode 100644 index 0000000000..dc9f7fc870 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/displayname/index.html @@ -0,0 +1,81 @@ +--- +title: Function.displayName +slug: Web/JavaScript/Reference/Objets_globaux/Function/displayName +tags: + - Function + - JavaScript + - Non-standard + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName +--- +
{{JSRef}} {{Non-standard_header}}
+ +

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

+ +

Description

+ +

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

+ +
function faireTruc() { }
+
+console.log(faireTruc.displayName); // "undefined"
+
+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)}}:

+ +
var objet = {
+  uneMéthode: function () {}
+};
+
+objet.uneMéthode.displayName = 'uneMéthode';
+
+console.log(objet.uneMéthode.displayName);
+// "uneMéthode"
+
+try { uneMéthode } catch(e) { console.log(e); }
+// ReferenceError: uneMéthode is not defined
+
+ +

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

+ +
var objet = {
+  // anonyme
+  uneMéthode: function(valeur) {
+    this.displayName = "uneMéthode (" + valeur + ")";
+  }
+};
+
+console.log(objet.uneMéthode.displayName); // "undefined"
+
+objet.uneMéthode("123")
+console.log(objet.uneMéthode.displayName); // "uneMéthode (123)"
+
+ +

Exemples

+ +

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()":

+ +
var a = function () { };
+a.displayName = 'Ma Fonction';
+
+a;
+
+ +

Spécifications

+ +

N'appartient à aucune spécification.

+ +

Compatibilité des navigateurs

+ + + +

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

diff --git a/files/fr/web/javascript/reference/global_objects/function/index.html b/files/fr/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..01c2a34869 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,153 @@ +--- +title: Function +slug: Web/JavaScript/Reference/Objets_globaux/Function +tags: + - Constructor + - Function + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +
{{JSRef}}
+ +

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.

+ +
{{EmbedInteractiveExample("pages/js/function-constructor.html")}}
+ + + +

Syntaxe

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

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

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.

+ +

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.

+ +

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.

+ +

Le prototype de Function

+ +

Propriétés

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

Méthodes

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

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

+ +

Définir des arguments avec le constructeur Function

+ +

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

+ +
// Cet exemple peut être lancé dans votre console JavaScript
+
+// On crée un fonction qui prend deux arguments
+// et qui en renvoie la somme
+var ajoute = new Function('a', 'b', 'return a + b');
+
+// On appelle la fonction
+ajoute(2, 6);
+// > 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".

+ +

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.

+ +
var x = 10;
+
+function créerFonction1() {
+  var x = 20;
+  return new Function("return x;"); // ici |x| fait référence au |x| global
+}
+
+function créerFonction2() {
+  var x = 20;
+  function f() {
+    return x; // ici |x| fait référence au |x| local juste avant
+  }
+  return f;
+}
+
+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

+ + diff --git a/files/fr/web/javascript/reference/global_objects/function/length/index.html b/files/fr/web/javascript/reference/global_objects/function/length/index.html new file mode 100644 index 0000000000..023b40a5f8 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/length/index.html @@ -0,0 +1,89 @@ +--- +title: Function.length +slug: Web/JavaScript/Reference/Objets_globaux/Function/length +tags: + - Function + - JavaScript + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function/length +--- +
{{JSRef}}
+ +

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

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

+ +

Propriété du constructeur Function

+ +

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.

+ +

Propriété du prototype de Function

+ +

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

+ +

Exemples

+ +
console.log(Function.length); /* 1 */
+
+console.log((function()        {}).length); /* 0 */
+console.log((function(a)       {}).length); /* 1 */
+console.log((function(a, b)    {}).length); /* 2 etc. */
+console.log((function(...args) {}).length);
+// 0, le paramètre du reste n'est pas compté
+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

+ + diff --git a/files/fr/web/javascript/reference/global_objects/function/name/index.html b/files/fr/web/javascript/reference/global_objects/function/name/index.html new file mode 100644 index 0000000000..b9b6f8300e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/name/index.html @@ -0,0 +1,201 @@ +--- +title: Function.name +slug: Web/JavaScript/Reference/Objets_globaux/Function/name +tags: + - ECMAScript 2015 + - Function + - JavaScript + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function/name +--- +
{{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.

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

+ +

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() {}
+faireUnTruc.name; // "faireUnTruc"
+
+ +

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

+ +
(new Function).name; // "anonymous"
+ +

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

+ +
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)}}:

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

+ +
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()")}}.

+ +

Notation raccourcie pour les méthodes

+ +
var o = {
+  toto(){}
+};
+o.toto.name; // "toto";
+ +

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.

+ +
function toto() {};
+toto.bind({}).name; // "bound toto"
+
+ +

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.

+ +
var o = {
+  get toto(){},
+  set toto(x){}
+};
+
+var descripteur = Object.getOwnPropertyDescriptor(o, "toto");
+descripteur.get.name; // "get toto"
+descripteur.set.name; // "set toto";
+ +

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) :

+ +
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() :

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

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

+ +

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 :

+ +
var sym1 = Symbol("Toto");
+var sym2 = Symbol();
+var o = {
+  [sym1]: function(){},
+  [sym2]: function(){}
+};
+
+o[sym1].name; // "[Toto]"
+o[sym2].name; // ""
+ +

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 :

+ +
function Toto() {};
+var toto = new Toto();
+
+if (Toto.constructor.name === 'Toto') {
+  console.log("'toto' est une instance de 'Toto'");
+} else {
+  console.log('Oups !');
+}
+
+ +

pourrait être compressé en :

+ +
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")}}

diff --git a/files/fr/web/javascript/reference/global_objects/function/tosource/index.html b/files/fr/web/javascript/reference/global_objects/function/tosource/index.html new file mode 100644 index 0000000000..3eb4b0d6dc --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/tosource/index.html @@ -0,0 +1,67 @@ +--- +title: Function.prototype.toSource() +slug: Web/JavaScript/Reference/Objets_globaux/Function/toSource +tags: + - Function + - JavaScript + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource +--- +
{{JSRef}}{{non-standard_header}}
+ +

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

+ +

Syntaxe

+ +
function.toSource();
+Function.toSource();
+
+ +

Valeur de retour

+ +

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

+ +

Description

+ +

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

+ + + +

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.

+ +

Spécifications

+ +

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

+ +

Compatibilité des navigateurs

+ + + +

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

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/function/tostring/index.html b/files/fr/web/javascript/reference/global_objects/function/tostring/index.html new file mode 100644 index 0000000000..db667ff0f6 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/function/tostring/index.html @@ -0,0 +1,98 @@ +--- +title: Function.prototype.toString() +slug: Web/JavaScript/Reference/Objets_globaux/Function/toString +tags: + - Function + - JavaScript + - Méthode + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString +--- +
{{JSRef}}
+ +

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")}}
+ + + +

Syntaxe

+ +
function.toString(indentation)
+ +

Valeur de retour

+ +

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

+ +

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.

+ +

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.

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

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

+ + -- cgit v1.2.3-54-g00ecf