diff options
Diffstat (limited to 'files/fr/web/javascript/reference/functions/arguments')
4 files changed, 260 insertions, 332 deletions
diff --git a/files/fr/web/javascript/reference/functions/arguments/@@iterator/index.md b/files/fr/web/javascript/reference/functions/arguments/@@iterator/index.md index 406eb7bcdc..e6f4715714 100644 --- a/files/fr/web/javascript/reference/functions/arguments/@@iterator/index.md +++ b/files/fr/web/javascript/reference/functions/arguments/@@iterator/index.md @@ -11,19 +11,20 @@ tags: translation_of: Web/JavaScript/Reference/Functions/arguments/@@iterator original_slug: Web/JavaScript/Reference/Fonctions/arguments/@@iterator --- -<div>{{jsSidebar("Functions")}}</div> +{{jsSidebar("Functions")}} -<p>La valeur initiale de la propriété <code><strong>@@iterator</strong></code> est le même objet que la fonction utilisée pour la valeur initiale de la propriété {{jsxref("Array.prototype.values")}}.</p> +La valeur initiale de la propriété **`@@iterator`** est le même objet que la fonction utilisée pour la valeur initiale de la propriété {{jsxref("Array.prototype.values")}}. -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox"><var>arguments</var>[Symbol.iterator]()</pre> + arguments[Symbol.iterator]() -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Utiliser_une_boucle_for...of">Utiliser une boucle <code>for...of</code></h3> +### Utiliser une boucle `for...of` -<pre class="brush: js">function f() { +```js +function f() { // votre environnement doit supporter les // boucles for..of et les variables // définies avec let dans les boucles @@ -32,47 +33,21 @@ original_slug: Web/JavaScript/Reference/Fonctions/arguments/@@iterator } } f('w', 'y', 'k', 'o', 'p'); -</pre> +``` -<h2 id="Spécifications">Spécifications</h2> +## Spécifications -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">Statut</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-createunmappedargumentsobject', ' CreateUnmappedArgumentsObject')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Définition initiale.</td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-createmappedargumentsobject', ' CreateMappedArgumentsObject')}}</td> - <td>{{Spec2('ES6')}}</td> - <td>Définition initiale.</td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-createunmappedargumentsobject', 'CreateUnmappedArgumentsObject')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-createmappedargumentsobject', 'CreateMappedArgumentsObject')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - </tbody> -</table> +| Spécification | Statut | Commentaires | +| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES6', '#sec-createunmappedargumentsobject', ' CreateUnmappedArgumentsObject')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ES6', '#sec-createmappedargumentsobject', ' CreateMappedArgumentsObject')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-createunmappedargumentsobject', 'CreateUnmappedArgumentsObject')}} | {{Spec2('ESDraft')}} | | +| {{SpecName('ESDraft', '#sec-createmappedargumentsobject', 'CreateMappedArgumentsObject')}} | {{Spec2('ESDraft')}} | | -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> +## Compatibilité des navigateurs +{{Compat("javascript.functions.arguments.@@iterator")}} -<p>{{Compat("javascript.functions.arguments.@@iterator")}}</p> +## Voir aussi -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Array.prototype.values()")}}</li> -</ul> +- {{jsxref("Array.prototype.values()")}} diff --git a/files/fr/web/javascript/reference/functions/arguments/callee/index.md b/files/fr/web/javascript/reference/functions/arguments/callee/index.md index 4f69ce4490..bb8c7d6fa3 100644 --- a/files/fr/web/javascript/reference/functions/arguments/callee/index.md +++ b/files/fr/web/javascript/reference/functions/arguments/callee/index.md @@ -11,45 +11,52 @@ tags: translation_of: Web/JavaScript/Reference/Functions/arguments/callee original_slug: Web/JavaScript/Reference/Fonctions/arguments/callee --- -<div>{{jsSidebar("Functions")}}{{deprecated_header}}</div> +{{jsSidebar("Functions")}}{{deprecated_header}} -<p>La propriété <strong><code>arguments.callee</code></strong> contient la fonction en cours d'exécution.</p> +La propriété **`arguments.callee`** contient la fonction en cours d'exécution. -<h2 id="Description">Description</h2> +## Description -<p><code>callee</code> est une propriété de l'objet <code>arguments</code>. Elle peut être utilisée afin de faire référence à la fonction en cours d'exécution à l'intérieur de cette fonction. Cette propriété peut etre utile lorsqu'on ne connait pas le nom de la fonction (fonction anonyme par exemple).</p> +`callee` est une propriété de l'objet `arguments`. Elle peut être utilisée afin de faire référence à la fonction en cours d'exécution à l'intérieur de cette fonction. Cette propriété peut etre utile lorsqu'on ne connait pas le nom de la fonction (fonction anonyme par exemple). -<div class="warning"><p><strong>Attention :</strong> En <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>, ECMAScript 5 interdit la fonction <code>arguments.callee()</code>. Éviter de l'utiliser en utilisant un nom de fonction dans les expressions ou en utilisant une déclaration de fonction où la fonction s'appelle elle-même.</p></div> +> **Attention :** En [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), ECMAScript 5 interdit la fonction `arguments.callee()`. Éviter de l'utiliser en utilisant un nom de fonction dans les expressions ou en utilisant une déclaration de fonction où la fonction s'appelle elle-même. -<h3 id="Pourquoi_arguments.callee_a-t-il_été_retiré_du_mode_strict_ES5">Pourquoi <code>arguments.callee</code> a-t-il été retiré du mode strict ES5 ?</h3> +### Pourquoi `arguments.callee` a-t-il été retiré du mode strict ES5 ? -<p>(adapté d'une réponse<a href="http://stackoverflow.com/a/235760/578288" title="http://stackoverflow.com/a/235760/578288"> Stack Overflow par olliej</a>)</p> +(adapté d'une réponse[ Stack Overflow par olliej](http://stackoverflow.com/a/235760/578288 "http://stackoverflow.com/a/235760/578288")) -<p>Aux débuts de JavaScript, il n'était pas possible d'utiliser des expressions de fonction avec des noms. Il était donc impossible de faire une expression de fonction récursive.</p> +Aux débuts de JavaScript, il n'était pas possible d'utiliser des expressions de fonction avec des noms. Il était donc impossible de faire une expression de fonction récursive. -<p>Cette syntaxe produisait le résultat escompté :</p> +Cette syntaxe produisait le résultat escompté : -<pre class="brush: js">function factorielle (n) { - return !(n > 1) ? 1 : factorielle(n - 1) * n; +```js +function factorielle (n) { + return !(n > 1) ? 1 : factorielle(n - 1) * n; } -[1,2,3,4,5].map(factorielle);</pre> +[1,2,3,4,5].map(factorielle); +``` -<p>mais :</p> +mais : -<pre class="brush: js">[1,2,3,4,5].map(function (n) { - return !(n > 1) ? 1 : /* que met-on ici ? */ (n - 1) * n; -});</pre> +```js +[1,2,3,4,5].map(function (n) { + return !(n > 1) ? 1 : /* que met-on ici ? */ (n - 1) * n; +}); +``` -<p>ne fonctionnait pas. Pour que cela puisse fonctionner, on ajouta <code>arguments.callee</code> :</p> +ne fonctionnait pas. Pour que cela puisse fonctionner, on ajouta `arguments.callee` : -<pre class="brush: js">[1,2,3,4,5].map(function (n) { - return !(n > 1) ? 1 : arguments.callee(n - 1) * n; -});</pre> +```js +[1,2,3,4,5].map(function (n) { + return !(n > 1) ? 1 : arguments.callee(n - 1) * n; +}); +``` -<p>Cependant, ce fut une mauvaise solution (avec <code>caller</code> également) car elle rendit impossible l'<a href="https://fr.wikipedia.org/wiki/Extension_inline">extension inline</a> et la <a href="https://fr.wikipedia.org/wiki/R%C3%A9cursion_terminale">récursion terminale</a> de façon générale (il est possible d'y arriver de certaines façons mais cela entraînerait nécessairement un code moins efficace). Le second problème que cela entraîne est que l'appel récursif aura une autre valeur <code>this</code> :</p> +Cependant, ce fut une mauvaise solution (avec `caller` également) car elle rendit impossible l'[extension inline](https://fr.wikipedia.org/wiki/Extension_inline) et la [récursion terminale](https://fr.wikipedia.org/wiki/R%C3%A9cursion_terminale) de façon générale (il est possible d'y arriver de certaines façons mais cela entraînerait nécessairement un code moins efficace). Le second problème que cela entraîne est que l'appel récursif aura une autre valeur `this` : -<pre class="brush: js">var global = this; +```js +var global = this; var fonctionTruc = function (recursed) { if (!recursed) { return arguments.callee(true); } @@ -60,51 +67,57 @@ var fonctionTruc = function (recursed) { } } -fonctionTruc();</pre> +fonctionTruc(); +``` -<p>ECMAScript 3 a introduit les expressions de fonctions nommées pour résoudre le problème. On peut désormais utiliser :</p> +ECMAScript 3 a introduit les expressions de fonctions nommées pour résoudre le problème. On peut désormais utiliser : -<pre class="brush: js">[1,2,3,4,5].map(function factorielle (n) { - return !(n > 1) ? 1 : factorielle(n - 1)*n; -});</pre> +```js +[1,2,3,4,5].map(function factorielle (n) { + return !(n > 1) ? 1 : factorielle(n - 1)*n; +}); +``` -<p>Cette méthode possède plusieurs avantages :</p> +Cette méthode possède plusieurs avantages : -<ul> - <li>La fonction peut être appelée comme n'importe quelle autre fonction nommée dans le code</li> - <li>Cela ne crée pas une variable dans la portée extérieure (<a href="http://kangax.github.io/nfe/#example_1_function_expression_identifier_leaks_into_an_enclosing_scope">sauf pour IE 8 et les versions antérieures</a>)</li> - <li>Cela entraîne de meilleures performances que d'accéder aux propriétés de l'objet <code>arguments</code></li> -</ul> +- La fonction peut être appelée comme n'importe quelle autre fonction nommée dans le code +- Cela ne crée pas une variable dans la portée extérieure ([sauf pour IE 8 et les versions antérieures](http://kangax.github.io/nfe/#example_1_function_expression_identifier_leaks_into_an_enclosing_scope)) +- Cela entraîne de meilleures performances que d'accéder aux propriétés de l'objet `arguments` -<p>Une autre fonctionnalité qui a été déprécié est : <code>arguments.callee.caller</code>, ou plus précisément <code>Function.caller</code>. Pourquoi cela ? Parce que ça permet d'avoir accès à tout moment à la fonction appelante la plus loin dans la pile d'appels. Or, comme évoqué ci-avant, cela a un effet de bord considérable : ça rend beaucoup plus complexes voire impossibles certaines optimisations. Ainsi, on ne peut pas garantir qu'une fonction <code>f</code> n'appellera pas une autre fonction inconnue, ce qui signifie qu'on ne peut pas utiliser l'extension inline. En résumé, cela signifie que n'importe quel site d'appel de fonction (<em>call site</em>) qui aurait pu être développé inline très simplement devra subir de nombreux tests :</p> +Une autre fonctionnalité qui a été déprécié est : `arguments.callee.caller`, ou plus précisément `Function.caller`. Pourquoi cela ? Parce que ça permet d'avoir accès à tout moment à la fonction appelante la plus loin dans la pile d'appels. Or, comme évoqué ci-avant, cela a un effet de bord considérable : ça rend beaucoup plus complexes voire impossibles certaines optimisations. Ainsi, on ne peut pas garantir qu'une fonction `f` n'appellera pas une autre fonction inconnue, ce qui signifie qu'on ne peut pas utiliser l'extension inline. En résumé, cela signifie que n'importe quel site d'appel de fonction (_call site_) qui aurait pu être développé inline très simplement devra subir de nombreux tests : -<pre class="brush: js">function f (a, b, c, d, e) { return a ? b * c : d * e; }</pre> +```js +function f (a, b, c, d, e) { return a ? b * c : d * e; } +``` -<p>Si l'interpréteur JavaScript ne peut pas garantir que l'ensemble des arguments fournis ici sont des nombres à l'instant de l'appel de la fonction, il devra insérer des vérifications pour chaque argument avant le code inline, sinon il ne pourra pas développer la fonction inline. On notera que, dans ce cas, un interpréteur intelligent devrait pouvoir réarranger les vérifications à faire afin qu'elles soient optimales et de se débarrasser des valeurs inutiles. Malgré tout, une telle optimisation ne sera pas possible dans d'autres cas, ce qui signifie que le développement inline n'est pas possible.</p> +Si l'interpréteur JavaScript ne peut pas garantir que l'ensemble des arguments fournis ici sont des nombres à l'instant de l'appel de la fonction, il devra insérer des vérifications pour chaque argument avant le code inline, sinon il ne pourra pas développer la fonction inline. On notera que, dans ce cas, un interpréteur intelligent devrait pouvoir réarranger les vérifications à faire afin qu'elles soient optimales et de se débarrasser des valeurs inutiles. Malgré tout, une telle optimisation ne sera pas possible dans d'autres cas, ce qui signifie que le développement inline n'est pas possible. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Utiliser_arguments.callee_pour_une_fonction_anonyme_récursive">Utiliser <code>arguments.callee</code> pour une fonction anonyme récursive</h3> +### Utiliser `arguments.callee` pour une fonction anonyme récursive -<p>Une fonction récursive, par définition, s'appelle elle-même. Elle fait donc généralement référence à elle-même grâce à son nom. Cependant, une fonction anonyme (créée grâce ) une <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_function">expression de fonction</a> ou au constructeur {{jsxref("Function")}}) n'a pas de nom et la seule façon d'y faire référence est donc d'utiliser <code>arguments.callee</code>.</p> +Une fonction récursive, par définition, s'appelle elle-même. Elle fait donc généralement référence à elle-même grâce à son nom. Cependant, une fonction anonyme (créée grâce ) une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_function) ou au constructeur {{jsxref("Function")}}) n'a pas de nom et la seule façon d'y faire référence est donc d'utiliser `arguments.callee`. -<p>L'exemple qui suit illustre une fonction qui définit et renvoie une fonction factorielle. Cet exemple n'a qu'un but démonstratif et ne correspond certainement pas à ce qui serait utilisé en pratique (les expressions de fonctions pouvant être <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_function">nommées</a>).</p> +L'exemple qui suit illustre une fonction qui définit et renvoie une fonction factorielle. Cet exemple n'a qu'un but démonstratif et ne correspond certainement pas à ce qui serait utilisé en pratique (les expressions de fonctions pouvant être [nommées](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_function)). -<pre class="brush: js">function créer() { +```js +function créer() { return function(n) { - if (n <= 1) + if (n <= 1) return 1; return n * arguments.callee(n - 1); }; } -var résultat = create()(5); // renvoie 120 (5 * 4 * 3 * 2 * 1)</pre> +var résultat = create()(5); // renvoie 120 (5 * 4 * 3 * 2 * 1) +``` -<h3 id="Une_utilisation_d'arguments.callee_qui_ne_possède_pas_de_solution_de_remplacement">Une utilisation d'<code>arguments.callee</code> qui ne possède pas de solution de remplacement</h3> +### Une utilisation d'`arguments.callee` qui ne possède pas de solution de remplacement -<p>Malgré tout, dans un cas comme le suivant, il n'existe pas d'équivalent pour <code>arguments.callee</code>, c'est pourquoi sa déprécation pourrait être un bug (voir {{Bug("725398")}}):</p> +Malgré tout, dans un cas comme le suivant, il n'existe pas d'équivalent pour `arguments.callee`, c'est pourquoi sa déprécation pourrait être un bug (voir {{Bug("725398")}}): -<pre class="brush: js">function créerPersonne (sIdentité) { +```js +function créerPersonne (sIdentité) { var oPersonne = new Function("alert(arguments.callee.identité);"); oPersonne.identité = sIdentité; return oPersonne; @@ -112,46 +125,22 @@ var résultat = create()(5); // renvoie 120 (5 * 4 * 3 * 2 * 1)</pre> var jean = créerPersonne("Jean Biche"); -jean();</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Définition initiale. Implémentée avec JavaScript 1.2</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td> - <td>{{Spec2('ES6')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.functions.arguments.callee")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Function")}}</li> -</ul> +jean(); +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.2 | +| {{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.functions.arguments.callee")}} + +## Voir aussi + +- {{jsxref("Function")}} diff --git a/files/fr/web/javascript/reference/functions/arguments/index.md b/files/fr/web/javascript/reference/functions/arguments/index.md index c996b904d3..84b1939b72 100644 --- a/files/fr/web/javascript/reference/functions/arguments/index.md +++ b/files/fr/web/javascript/reference/functions/arguments/index.md @@ -10,238 +10,228 @@ tags: translation_of: Web/JavaScript/Reference/Functions/arguments original_slug: Web/JavaScript/Reference/Fonctions/arguments --- -<div>{{jsSidebar("Fonctions")}}</div> +{{jsSidebar("Fonctions")}} -<p>L'objet <strong><code>arguments</code></strong> est un objet, <strong>semblable</strong> à un tableau, correspondant aux arguments passés à une fonction.</p> +L'objet **`arguments`** est un objet, **semblable** à un tableau, correspondant aux arguments passés à une fonction. -<div class="note"> -<p><strong>Note :</strong> Si vous pouvez utiliser les fonctionnalités ECMAScript 2015/ES6, il est préférable de manipuler les arguments avec <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste">les paramètres du reste</a>.</p> -</div> +> **Note :** Si vous pouvez utiliser les fonctionnalités ECMAScript 2015/ES6, il est préférable de manipuler les arguments avec [les paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste). -<div class="note"> -<p><strong>Note :</strong> Par « objet semblable à un tableau », on indique que l'objet <code>arguments</code> possède une propriété {{jsxref("Fonctions/arguments.length", "length")}} et que ses propriétés sont indexées à partir de 0 mais qu'il ne possède aucune des méthodes natives de {{jsxref("Array")}} telles que {{jsxref("Array.forEach", "forEach()")}} et {{jsxref("Array.map", "map()")}}.</p> -</div> +> **Note :** Par « objet semblable à un tableau », on indique que l'objet `arguments` possède une propriété {{jsxref("Fonctions/arguments.length", "length")}} et que ses propriétés sont indexées à partir de 0 mais qu'il ne possède aucune des méthodes natives de {{jsxref("Array")}} telles que {{jsxref("Array.forEach", "forEach()")}} et {{jsxref("Array.map", "map()")}}. -<div>{{EmbedInteractiveExample("pages/js/functions-arguments.html")}}</div> +{{EmbedInteractiveExample("pages/js/functions-arguments.html")}} +> **Note :** « Variable ayant la fonction pour portée » correspond à la traduction de « Variable of the function scope » qu'il serait incorrect de traduire par « Variable de la portée de la fonction » car la portée de la fonction est la portée dans laquelle on peut appeler la fonction. Une variable locale de la fonction pourrait quant à elle avoir une portée strictement incluse dans le corps de la fonction (variable définie dans un bloc de la fonction même si cette subtilité n'existe pas en Javascript). Toute suggestion pour éviter cette tournure un peu longue sans altérer le sens est la bienvenue. (variable intrinsèque) +## Syntaxe -<div class="note"> -<p><strong>Note :</strong> « Variable ayant la fonction pour portée » correspond à la traduction de « Variable of the function scope » qu'il serait incorrect de traduire par « Variable de la portée de la fonction » car la portée de la fonction est la portée dans laquelle on peut appeler la fonction. Une variable locale de la fonction pourrait quant à elle avoir une portée strictement incluse dans le corps de la fonction (variable définie dans un bloc de la fonction même si cette subtilité n'existe pas en Javascript). Toute suggestion pour éviter cette tournure un peu longue sans altérer le sens est la bienvenue. (variable intrinsèque)</p> -</div> + arguments -<h2 id="Syntaxe">Syntaxe</h2> +## Description -<pre class="syntaxbox">arguments</pre> +L'objet `arguments` est une variable locale (intrinsèque et inhérente aux fonctions) disponible dans toutes les fonctions (qui ne sont pas [des fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es)). -<h2 id="Description">Description</h2> +Vous pouvez accéder aux arguments d'une fonction à l'intérieur de celle-ci en utilisant l'objet `arguments`. Cet objet contient une entrée pour chaque argument passé à la fonction, l'indice de la première entrée commençant à 0. Par exemple, si une fonction est appelée avec trois arguments, on accède à ceux-ci comme suit : -<p>L'objet <code>arguments</code> est une variable locale (intrinsèque et inhérente aux fonctions) disponible dans toutes les fonctions (qui ne sont pas <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es">des fonctions fléchées</a>).</p> - -<p>Vous pouvez accéder aux arguments d'une fonction à l'intérieur de celle-ci en utilisant l'objet <code>arguments</code>. Cet objet contient une entrée pour chaque argument passé à la fonction, l'indice de la première entrée commençant à 0. Par exemple, si une fonction est appelée avec trois arguments, on accède à ceux-ci comme suit :</p> - -<pre class="brush: js">arguments[0] +```js +arguments[0] arguments[1] -arguments[2]</pre> +arguments[2] +``` -<p>Les arguments peuvent aussi être modifiés :</p> +Les arguments peuvent aussi être modifiés : -<pre class="brush: js">arguments[1] = 'nouvelle valeur';</pre> +```js +arguments[1] = 'nouvelle valeur'; +``` -<h3 id="Type_de_l'objet_arguments_et_liens_avec_Array">Type de l'objet <code>arguments</code> et liens avec <code>Array</code></h3> +### Type de l'objet `arguments` et liens avec `Array` -<p>L'objet <code>arguments</code> n'est pas un {{jsxref("Array")}}. Il est similaire à un <code>Array</code>, mais il n'a pas les propriétés d'un <code>Array,</code> exceptée la propriété {{jsxref("Array.length", "length")}}. Par exemple, il n'a pas la méthode {{jsxref("Array.pop", "pop()")}}. Néanmoins, il peut être converti en un vrai objet de type <code>Array</code> :</p> +L'objet `arguments` n'est pas un {{jsxref("Array")}}. Il est similaire à un `Array`, mais il n'a pas les propriétés d'un `Array,` exceptée la propriété {{jsxref("Array.length", "length")}}. Par exemple, il n'a pas la méthode {{jsxref("Array.pop", "pop()")}}. Néanmoins, il peut être converti en un vrai objet de type `Array` : -<pre class="brush: js">console.log(typeof arguments); // 'object' +```js +console.log(typeof arguments); // 'object' var args = Array.prototype.slice.call(arguments); // Avec ECMAScript 2015 / ES6 var args = Array.from(arguments); -</pre> - -<h3 id="Utilisation_de_la_décomposition_avec_les_arguments">Utilisation de la décomposition avec les arguments</h3> +``` -<p>On peut utiliser la méthode {{jsxref("Array.from()")}} ou encore <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition">l'opérateur de décomposition</a> afin de convertir cet objet en un <em>vrai</em> <code>Array</code> :</p> +### Utilisation de la décomposition avec les arguments -<pre class="brush: js">var args = Array.from(arguments); -var args = [...arguments];</pre> +On peut utiliser la méthode {{jsxref("Array.from()")}} ou encore [l'opérateur de décomposition](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition) afin de convertir cet objet en un _vrai_ `Array` : -<div class="warning"> -<p><strong>Attention :</strong> Il est déconseillé d'utiliser <code>slice</code> sur les arguments car cela peut empêcher certaines optimisations des moteurs JavaScript. Pour ce scénario, on peut par exemple construire un nouveau tableau en parcourant l'objet arguments (à ce sujet, voir <a href="https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments">cette page</a> sur les contraintes d'optimisations liées à V8). Pour cet exemple, on pourra utiliser <code>Array.apply</code> :</p> +```js +var args = Array.from(arguments); +var args = [...arguments]; +``` -<pre class="brush: js">var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));</pre> -</div> +> **Attention :** Il est déconseillé d'utiliser `slice` sur les arguments car cela peut empêcher certaines optimisations des moteurs JavaScript. Pour ce scénario, on peut par exemple construire un nouveau tableau en parcourant l'objet arguments (à ce sujet, voir [cette page](https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments) sur les contraintes d'optimisations liées à V8). Pour cet exemple, on pourra utiliser `Array.apply` : +> +> ```js +> var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments)); +> ``` -<p>L'objet <code>arguments</code> est disponible uniquement dans le corps d'une fonction. Tenter d'accéder à l'objet <code>arguments</code> en dehors de la déclaration d'une fonction renvoie une erreur.</p> +L'objet `arguments` est disponible uniquement dans le corps d'une fonction. Tenter d'accéder à l'objet `arguments` en dehors de la déclaration d'une fonction renvoie une erreur. -<p>Vous pouvez utiliser l'objet <code>arguments</code> si vous appelez une fonction avec plus de paramètres que ceux déclarés dans sa signature. Cette technique est utile pour les fonctions qui acceptent un nombre variable d'arguments. Vous pouvez utiliser {{jsxref("Fonctions/arguments/length", "arguments.length")}} pour déterminer le nombre de paramètres passés à la fonction, puis utiliser chaque argument en utilisant l'objet <code>arguments</code>. (Pour déterminer le nombre d'arguments déclarés à la définition de la fonction, il faut utiliser la propriété {{jsxref("Function.length", "length")}}.)</p> +Vous pouvez utiliser l'objet `arguments` si vous appelez une fonction avec plus de paramètres que ceux déclarés dans sa signature. Cette technique est utile pour les fonctions qui acceptent un nombre variable d'arguments. Vous pouvez utiliser {{jsxref("Fonctions/arguments/length", "arguments.length")}} pour déterminer le nombre de paramètres passés à la fonction, puis utiliser chaque argument en utilisant l'objet `arguments`. (Pour déterminer le nombre d'arguments déclarés à la définition de la fonction, il faut utiliser la propriété {{jsxref("Function.length", "length")}}.) -<h3 id="Utiliser_typeof_sur_arguments">Utiliser <code>typeof</code> sur <code>arguments</code></h3> +### Utiliser `typeof` sur `arguments` -<p>L'opérateur {{jsxref("Opérateurs/L_opérateur_typeof","typeof")}} renvoie <code>"object"</code> lorsqu'on l'utilise sur <code>arguments</code></p> +L'opérateur {{jsxref("Opérateurs/L_opérateur_typeof","typeof")}} renvoie `"object"` lorsqu'on l'utilise sur `arguments` -<pre class="brush: js">console.log(typeof arguments); // "object"</pre> +```js +console.log(typeof arguments); // "object" +``` -<p>On peut tout à fait utiliser <code>typeof</code> sur chacun des arguments afin de connaître leur type respectif</p> +On peut tout à fait utiliser `typeof` sur chacun des arguments afin de connaître leur type respectif -<pre class="brush: js">console.log(typeof arguments[0]); // renvoie le type du premier argument</pre> +```js +console.log(typeof arguments[0]); // renvoie le type du premier argument +``` -<h2 id="Propriétés">Propriétés</h2> +## Propriétés -<dl> - <dt>{{jsxref("Fonctions/arguments/callee", "arguments.callee")}} {{Deprecated_inline}}</dt> - <dd>Référence à la fonction en cours d'exécution.</dd> - <dt>{{jsxref("Fonctions/arguments/caller", "arguments.caller")}} {{Obsolete_inline}}</dt> - <dd>Référence à la fonction appelante.</dd> - <dt>{{jsxref("Fonctions/arguments/length", "arguments.length")}}</dt> - <dd>Référence au nombre d'arguments passés à la fonction.</dd> - <dt>{{jsxref("Fonctions/arguments/@@iterator", "arguments[@@iterator]")}}</dt> - <dd>Renvoie un nouvel <a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Itérateurs">itérateur</a> qui contient les valeurs pour chaque indice d'<code>arguments</code>.</dd> -</dl> +- {{jsxref("Fonctions/arguments/callee", "arguments.callee")}} {{Deprecated_inline}} + - : Référence à la fonction en cours d'exécution. +- {{jsxref("Fonctions/arguments/caller", "arguments.caller")}} {{Obsolete_inline}} + - : Référence à la fonction appelante. +- {{jsxref("Fonctions/arguments/length", "arguments.length")}} + - : Référence au nombre d'arguments passés à la fonction. +- {{jsxref("Fonctions/arguments/@@iterator", "arguments[@@iterator]")}} + - : Renvoie un nouvel [itérateur](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Itérateurs) qui contient les valeurs pour chaque indice d'`arguments`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Définir_une_fonction_de_concaténation_d'un_nombre_variable_de_chaînes">Définir une fonction de concaténation d'un nombre variable de chaînes</h3> +### Définir une fonction de concaténation d'un nombre variable de chaînes -<p>Cet exemple définit une fonction qui concatène un nombre variable de chaînes. Le seul argument formel de la fonction est une chaîne spécifiant un séparateur inséré entre les chaînes concaténées. La fonction est définie comme suit :</p> +Cet exemple définit une fonction qui concatène un nombre variable de chaînes. Le seul argument formel de la fonction est une chaîne spécifiant un séparateur inséré entre les chaînes concaténées. La fonction est définie comme suit : -<pre class="brush:js">function myConcat(separateur) { +```js +function myConcat(separateur) { var args = Array.prototype.slice.call(arguments, 1); return args.join(separateur); -}</pre> +} +``` -<p>Vous pouvez passer n'importe quel nombre d'arguments à cette fonction ; elle créera une liste en utilisant chaque argument comme un élément de la liste.</p> +Vous pouvez passer n'importe quel nombre d'arguments à cette fonction ; elle créera une liste en utilisant chaque argument comme un élément de la liste. -<pre class="brush:js">// renvoie "rouge, orange, bleu" +```js +// renvoie "rouge, orange, bleu" myConcat(", ", "rouge", "orange", "bleu"); // renvoie "éléphant ; giraffe ; lion ; guépard" myConcat(" ; ", "elephant", "giraffe", "lion", "guépard"); -</pre> +``` -<h3 id="Définir_une_fonction_de_création_de_listes_HTML">Définir une fonction de création de listes HTML</h3> +### Définir une fonction de création de listes HTML -<p>Cet exemple définit une fonction qui crée des chaînes définissant des listes HTML. Le seul argument formel de la fonction est une chaîne pouvant valoir "<code>u</code>" (unordered), si la liste doit être sans numérotation (avec des puces), ou "<code>o</code>" (ordered), si la liste doit être numérotée. La fonction est définie comme suit :</p> +Cet exemple définit une fonction qui crée des chaînes définissant des listes HTML. Le seul argument formel de la fonction est une chaîne pouvant valoir "`u`" (unordered), si la liste doit être sans numérotation (avec des puces), ou "`o`" (ordered), si la liste doit être numérotée. La fonction est définie comme suit : -<pre class="brush:js">function liste(type) { - var resultat = "<" + type + "l><li>"; +```js +function liste(type) { + var resultat = "<" + type + "l><li>"; var args = Array.prototype.slice.call(arguments, 1); - resultat += args.join("</li><li>"); - resultat += "</li></" + type + "l>"; // end list + resultat += args.join("</li><li>"); + resultat += "</li></" + type + "l>"; // end list return resultat; -}</pre> +} +``` -<p>Vous pouvez passer n'importe quel nombre d'arguments à cette fonction ; elle créera une liste du type indiqué en ajoutant chaque argument comme élément dans la liste. Exemple :</p> +Vous pouvez passer n'importe quel nombre d'arguments à cette fonction ; elle créera une liste du type indiqué en ajoutant chaque argument comme élément dans la liste. Exemple : -<pre class="brush:js">var listeHTML = liste("u", "Un", "Deux", "Trois"); +```js +var listeHTML = liste("u", "Un", "Deux", "Trois"); /* listeHTML vaut : -"<ul><li>Un</li><li>Deux</li><li>Trois</li></ul>" +"<ul><li>Un</li><li>Deux</li><li>Trois</li></ul>" -*/</pre> +*/ +``` -<h3 id="Paramètres_du_reste_paramètres_par_défaut_et_décomposition">Paramètres du reste, paramètres par défaut et décomposition</h3> +### Paramètres du reste, paramètres par défaut et décomposition -<p>L'objet <code>arguments</code> peut être utilisé en combinaison avec <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste">les paramètres du reste</a>, <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments">les paramètres par défaut</a> ou <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition">les paramètres décomposés</a>.</p> +L'objet `arguments` peut être utilisé en combinaison avec [les paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste), [les paramètres par défaut](/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments) ou [les paramètres décomposés](/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition). -<pre class="brush: js">function toto(...args) { +```js +function toto(...args) { return args; } toto(1, 2, 3); // [1, 2, 3] -</pre> +``` -<p>Toutefois, pour les fonctions utilisées en mode non-strict, un<strong> objet <code>arguments</code></strong> n'est fourni à l'intérieur de la fonction uniquement si celle-ci n'utilise pas de <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste">paramètres du reste</a>, pas de <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments">paramètres par défaut</a> ou de <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition">paramètre décomposé</a>. Par exemple, dans la fonction suivante, qui utilise un paramètre par défaut, ce sera 10 qui sera renvoyé (et non 100) :</p> +Toutefois, pour les fonctions utilisées en mode non-strict, un **objet `arguments`** n'est fourni à l'intérieur de la fonction uniquement si celle-ci n'utilise pas de [paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste), pas de [paramètres par défaut](/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments) ou de [paramètre décomposé](/fr/docs/Web/JavaScript/Reference/Opérateurs/Affecter_par_décomposition). Par exemple, dans la fonction suivante, qui utilise un paramètre par défaut, ce sera 10 qui sera renvoyé (et non 100) : -<pre class="brush: js">function truc(a=1) { +```js +function truc(a=1) { arguments[0] = 100; return a; } truc(10); // 10 -</pre> +``` -<p>Si l'objet <code>arguments</code> est modifié dans la fonction, cela modifiera la valeur du paramètre passé. Dans cet exemple où il n'y a ni <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/param%C3%A8tres_du_reste">paramètres du reste</a>, ni <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments">paramètres par défaut</a>, ni <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition">décomposition</a>, le résultat sera 100 :</p> +Si l'objet `arguments` est modifié dans la fonction, cela modifiera la valeur du paramètre passé. Dans cet exemple où il n'y a ni [paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/param%C3%A8tres_du_reste), ni [paramètres par défaut](/fr/docs/Web/JavaScript/Reference/Fonctions/Valeurs_par_défaut_des_arguments), ni [décomposition](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateur_de_d%C3%A9composition), le résultat sera 100 : -<pre class="brush: js">fonction truc(a) { +```js +fonction truc(a) { arguments[0] = 100; return a; } -truc(10); // 100</pre> +truc(10); // 100 +``` -<p>En fait, lorsqu'il n'y a aucun paramètre du reste, paramètre par défaut ou aucune décomposition, les arguments formels feront références aux valeurs de l'objet <code>arguments</code>. Lorsqu'on aura besoin d'accéder à ces valeurs, on accèdera aux valeurs contenues dans <code>arguments</code> et à l'inverse, lorsqu'on modifiera ces valeurs, cela modifiera le contenu d'<code>arguments</code>. Par exemple</p> +En fait, lorsqu'il n'y a aucun paramètre du reste, paramètre par défaut ou aucune décomposition, les arguments formels feront références aux valeurs de l'objet `arguments`. Lorsqu'on aura besoin d'accéder à ces valeurs, on accèdera aux valeurs contenues dans `arguments` et à l'inverse, lorsqu'on modifiera ces valeurs, cela modifiera le contenu d'`arguments`. Par exemple -<pre class="brush: js">function func(a, b) { +```js +function func(a, b) { arguments[0] = 99; arguments[1] = 99; console.log(a + " " +b); } func(1, 2); // 99 99 -</pre> +``` -<p>ou encore :</p> +ou encore : -<pre class="brush: js">function func(a, b) { +```js +function func(a, b) { a = 9; b = 99; console.log(arguments[0] + " " + arguments[1]); } func(3, 4); // 9 99 -</pre> +``` -<p>En revanche, dès qu'on utilise des paramètres du reste, des paramètres par défaut ou la décomposition, c'est le comportement normal qui sera appliqué :</p> +En revanche, dès qu'on utilise des paramètres du reste, des paramètres par défaut ou la décomposition, c'est le comportement normal qui sera appliqué : -<pre class="brush: js">function func(a, b, c = 9) { +```js +function func(a, b, c = 9) { arguments[0] = 99; arguments[1] = 98; console.log(a + " " + b); } func(3, 4); // 3 4 -</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Définition initiale. Implémentée par JavaScript 1.1</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ES2015', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td> - <td>{{Spec2('ES2015')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.functions.arguments")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Function")}}</li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste">Les paramètres du reste</a></li> - <li><a href="https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments">Contraintes d'optimisations sous V8 en relation avec <code>arguments</code></a></li> -</ul> +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée par JavaScript 1.1 | +| {{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES2015', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ES2015')}} | | +| {{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.functions.arguments")}} + +## Voir aussi + +- {{jsxref("Function")}} +- [Les paramètres du reste](/fr/docs/Web/JavaScript/Reference/Fonctions/paramètres_du_reste) +- [Contraintes d'optimisations sous V8 en relation avec `arguments`](https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments) diff --git a/files/fr/web/javascript/reference/functions/arguments/length/index.md b/files/fr/web/javascript/reference/functions/arguments/length/index.md index 495b0e6f20..7deb32f457 100644 --- a/files/fr/web/javascript/reference/functions/arguments/length/index.md +++ b/files/fr/web/javascript/reference/functions/arguments/length/index.md @@ -10,82 +10,56 @@ tags: translation_of: Web/JavaScript/Reference/Functions/arguments/length original_slug: Web/JavaScript/Reference/Fonctions/arguments/length --- -<div>{{jsSideBar("Functions")}}</div> +{{jsSideBar("Functions")}} -<p>La propriété <strong><code>arguments.length</code></strong> contient le nombre d'arguments passés à la fonction.</p> +La propriété **`arguments.length`** contient le nombre d'arguments passés à la fonction. -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox">arguments.length</pre> + arguments.length -<h2 id="Description">Description</h2> +## Description -<p>La propriété <code>arguments.length</code> fournit le nombre d'arguments qui ont été passés à la fonction. Cette quantité peut être inférieure ou supérieure au nombre de paramètres explicitement déclarés dans la définition de la fonction (voir également {{jsxref("Function.length")}}).</p> +La propriété `arguments.length` fournit le nombre d'arguments qui ont été passés à la fonction. Cette quantité peut être inférieure ou supérieure au nombre de paramètres explicitement déclarés dans la définition de la fonction (voir également {{jsxref("Function.length")}}). -<h2 id="Exemple">Exemple</h2> +## Exemple -<h3 id="Utiliser_arguments.length">Utiliser <code>arguments.length</code></h3> +### Utiliser `arguments.length` -<p>Dans cet exemple, on définit une fonction qui permet d'additionner plusieurs nombres.</p> +Dans cet exemple, on définit une fonction qui permet d'additionner plusieurs nombres. -<pre class="brush: js">function somme(x /*, y, z, ...*/) { +```js +function somme(x /*, y, z, ...*/) { x = Number(x); - for (var i = 1; i < arguments.length; i++) { + for (var i = 1; i < arguments.length; i++) { x += Number(arguments[i]); } return x; } -</pre> +``` -<pre class="brush: js">résultat = somme(3, 4, 5); // renvoie 12 +```js +résultat = somme(3, 4, 5); // renvoie 12 résultat = somme(3, 4); // renvoie 7 résultat = somme(103, 104, 105); // renvoie 312 -</pre> - -<div class="note"> -<p><strong>Note :</strong> <code>arguments.length</code> ne doit pas être confondu avec {{jsxref("Function.length")}}.</p> -</div> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ES1')}}</td> - <td>{{Spec2('ES1')}}</td> - <td>Définition initiale. Implémentée par JavaScript 1.1</td> - </tr> - <tr> - <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td> - <td>{{Spec2('ES5.1')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td> - <td>{{Spec2('ES6')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - - -<p>{{Compat("javascript.functions.arguments.length")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Function")}}</li> - <li>{{jsxref("Function.length")}}</li> -</ul> +``` + +> **Note :** `arguments.length` ne doit pas être confondu avec {{jsxref("Function.length")}}. + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée par JavaScript 1.1 | +| {{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.functions.arguments.length")}} + +## Voir aussi + +- {{jsxref("Function")}} +- {{jsxref("Function.length")}} |