Est-il un nombre max d'arguments des fonctions JavaScript peut accepter?

Je sais que des fonctions JavaScript peut accepter "tout" nombre d'arguments.

function f(){};
f(1,2,3,4 /*...*/);

Mais je me demandais si il n'y a effectivement une limite au nombre de "tout" peut être?

E. g., disons que j'ai la main un million d'arguments pour f(). Cela fonctionnerait-il? Ou serait l'interprète de quille sur?

Je devine que le maximum soit (un) la mise en œuvre spécifique ou (b) (2^32)-1, depuis le arguments objet est semblable au tableau.

Je ne la vois pas mentionnées dans la spécification du langage, mais je ne pourrais pas être de la connexion de certains points.

J'espère vraiment que c'est purement de la curiosité, non pas parce que vous prévoyez de faire quelque chose avec cela.
Aussi, TOUTE grande séquence de données comme cela devrait être passé comme un seul argument qui est un tableau, et non pas en tant que distincts des arguments si une copie n'a pas besoin d'être à la vaste ensemble de données juste pour appeler la fonction. Ce doit être un exercice académique, pas quelque chose qui pourrait être rencontrés avec les bonnes pratiques de développement.
Oui, juste par curiosité 🙂
n'oubliez pas Function.prototype.apply. stackoverflow.com/questions/1379553/...
Je sais que sur .apply(), mais c'est faire une copie du tableau d'entrée trop. Le point est que toute l'interface qui s'attend à accepter un très grand nombre d'arguments ne devrait pas être déclaré pour les obliger à être passé sous la normale arguments. Beaucoup plus efficace pour passer un tableau donc pas de copie des données est nécessaire.
Ce n'est pas une question théorique! Même si vous n'avez jamais écrire explicitement une telle fonction, si vous utilisez l'ES 2015 la propagation de l'opérateur et des fonctions comme Math.max ou Array.prototype.concat(...arrayOfArrays) (pour aplatir un tableau de tableaux), vous pouvez obtenir à cette limite de façon dynamique, sans avoir écrit un monstre de la fonction. Les frais généraux mentionnés par jfriend00 n'est pas toujours question - la clarté de code est plus important que quelques octets de mémoire ou de cycles de PROCESSEUR, et de la propagation de la syntaxe peut parfois être le meilleur choix en la matière. Rechercher des alternatives pour "aplatir tableau" de mon code court...
Mon commentaire est à partir de Mars 2014. ES5015 n'a pas été publié jusqu'en juin 2015.
Je comprends que, et j'ai fait le commentaire maintenant parce que c'est pertinent. DONC, les réponses et les commentaires ne sont pas seulement pour les personnes qui posté le 🙂
Les aplatir tableau de tableaux de cas est là que j'ai rencontré ce problème aussi!

InformationsquelleAutor GladstoneKeep | 2014-03-30

javascript

77

Bien qu'il n'y a rien de spécifique à la limitation de la théorique nombre maximal d'arguments dans la spec (comme thefortheye's réponse souligne). Il y a bien sûr pratique limites. Ces limites sont entièrement dépendant de l'implémentation et le plus probable, sera également dépendre exactement sur comment vous êtes à l'appel de la fonction.

J'ai créé ce violon comme une expérience.
```
function testArgs() {
    console.log(arguments.length);
}

var argLen = 0;
for (var i = 1; i < 32; i++) {
    argLen = (argLen << 1) + 1;
    testArgs.apply(null, new Array(argLen));
}
```
Voici mes résultats:
- Chrome 33.0.1750.154 m: Le dernier test réussi, a été 65535 arguments. Après qu'il a échoué avec:
  
  Uncaught RangeError: le Maximum de la pile d'appels de taille dépassait
- Firefox 27.0.1: Le dernier test réussi, a été 262143 arguments. Après qu'il a échoué avec:
  
  RangeError: tableau d'arguments transmis à la Fonction.le prototype.appliquer est trop grand
- Internet Explorer 11: Le dernier test réussi, a été 131071 arguments. Après qu'il a échoué avec:
  
  RangeError: SCRIPT28: manque d'espace de pile
- Opera 12.17: Le dernier test réussi, a été 1048576 arguments. Après qu'il a échoué avec:
  
  D'Erreur: La Fonction.le prototype.s'appliquent: argArray est trop grand
Bien sûr, il peut y avoir d'autres facteurs en jeu ici, et vous pouvez avoir des résultats différents.

Et voici un suppléant de violon créé à l'aide de eval. Encore une fois, vous pouvez obtenir des résultats différents.
- Chrome 33.0.1750.154 m: Le dernier test réussi, a été 32767 arguments. Après qu'il a échoué avec:
  
  Uncaught SyntaxError: Trop d'arguments dans l'appel de fonction (uniquement 32766 autorisé)
  
  ^{celui-ci est particulièrement intéressant parce que Chrome semble elle-même être confus quant à la façon dont de nombreux arguments sont effectivement autorisés.}
- Firefox 27.0.1: Le dernier test réussi, a été 32767 arguments. Après qu'il a échoué avec:
  
  script trop grand
- Internet Explorer 11: Le dernier test réussi, a été 32767 arguments. Après qu'il a échoué avec:
  
  RangeError: SCRIPT7: de mémoire
- Opera 12.17: Le dernier test réussi, a été 4194303 arguments. Après qu'il a échoué avec:
  
  De mémoire; script terminé.
- Ce qui est excellent. Bien que si vous utilisez apply et de l'envoi des arguments comme un Array, l'théorique max par la spec serait 4,294,967,295 éléments peu importe ce que les limites pratiques sont (?).
- Votre exemple est de tester le max de .apply() plus que les arguments de la fonction ignoré, comme montré dans la question. Ils ne sont pas nécessairement les mêmes. Voici une démo où j'ai créé une fonction à partir d'une chaîne à l'aide de la Function constructeur. La fonction appelle votre testArgs() fonction, passant de 100 000 arguments. Le simple fait de créer cette fonction échoue avec SyntaxError: too many function arguments
- Vous êtes correct. Il ya beaucoup de différents facteurs qui peuvent limiter le nombre maximum, et les différentes méthodes pour appeler elle peut donner des résultats différents. Je suppose que je devrait mettre l'accent sur la première phrase un peu plus.
- Ouais, tout dépend de ce que l'OP a à l'esprit. Je ne peux pas imaginer de frappe de 100 000 arguments à une fonction, donc .apply() semble plus probable. Mais alors il ne mentionne pas .apply(), donc peut-être qu'il a l'intention de faire une evaling.
- Correct. Mes tests sont sur la découverte de la approximatives pratique limites dans un navigateur donné.
- Voici une version pour les tartines: jsfiddle.net/uutv3bjv
InformationsquelleAutor p.s.w.g
21

ECMAScript 5.1, partie de 8,8

La Liste type est utilisé pour expliquer l'évaluation des listes d'arguments (voir 11.2.4) dans de nouvelles expressions, dans les appels de fonction, et dans d'autres algorithmes d'où une simple liste de valeurs est nécessaire....Ces séquences peuvent être de n'importe quelle longueur.

Donc il n'y a pas de limite dans la norme. Bien sûr, si votre code fonctionne dans le monde réel, pas dans les normes-terre, il y a évidemment certains limite (par exemple le nombre de particules dans l'univers).

Il y a deux façons de passer des paramètres à une fonction.
- ", Littéralement": f(a, b, c)
- À appliquer(): f.apply(null, [a, b, c])
Cette dernière méthode est le scénario plus réaliste pour les grandes listes d'arguments.

Aller à ce JSFiddle à voir les limites de chacune de ces pour votre navigateur actuel.

J'ai essayé un peu de navigateurs moi-même:
```
           | apply() | literal
 ----------------------------
Chrome 14  | 131155  |  32767
Chrome 35  | 126213  |  65535
Firefox 30 | 500001  |  65535
IE 9       | 254335  |  65533
IE 10      | 253667  |  65533
IE 11      | 252447  |  65533
Opera 22   | 126063  |  65535
Safari 4   | 524215  | 524205
Safari 7   |  65537  | 522159
```
J'ai vu des différences dans le nombre de ces numéros sur des machines différentes, donc je crois qu'il y a d'autres facteurs en jeu, outre le navigateur (l'OS?).

C'est une vraie question, pas certains de trivia. Un exemple réel:

Google Fermeture de la Bibliothèque défini la fonction suivante.
```
goog.crypt.byteArrayToString = function(array) {
  return String.fromCharCode.apply(null, array);
};
```
Cela a fonctionné seulement si la longueur de la chaîne est dans le navigateur de limite pour le nombre d'arguments peuvent être passés avec Function.prototype.apply.

La fonction a été plus tard patché, faisant la fonction de beaucoup plus compliqué.

Pour info, il y a un Webkit problème déposé en Mars 2012, qui traite de l'argument de la limite.

InformationsquelleAutor Paul Draper
6

Selon ECMA Script 5.1 Spécification Standard pour List,

La Liste type est utilisé pour expliquer l'évaluation des listes d'arguments (voir 11.2.4) dans de nouvelles expressions, dans les appels de fonction, et dans d'autres algorithmes d'où une simple liste de valeurs est nécessaire. Les valeurs de la Liste type sont simplement des séquences ordonnées de valeurs. Ces séquences peuvent être de n'importe quelle longueur.

Ainsi, la norme n'ont pas de limitations sur le nombre d'arguments et limitée que par la mémoire.

InformationsquelleAutor thefourtheye
2

> à partir de Ordinateur Conneries

Autant que je suis concerné, la limite est "assez grand"!
- "la limite est "assez grand'!" À moins qu'il ne l'est pas. bugs.webkit.org/show_bug.cgi?id=80797
InformationsquelleAutor Niet the Dark Absol
1

C'est purement dépend de combien puissant est le client.

Parce que le navigateur va perdre sa mémoire, si tu vas en passer des millions d'arguments.

Chaque variable contient de la mémoire. Afin que les navigateurs n'auront aucun problème à l'allocation de chaque variable de la mémoire, jusqu'à ce qu'il n'a pas de mémoire pour exécuter sur.

InformationsquelleAutor Amit Joki

Ici est de savoir comment je le vérifie.

let args = [];

while(true){
    try{
        (() => {})(...args);
        args.push(0);
    }catch(e){
        console.log(e.message);
        console.log(`Number of arguments: ${args.length}`);
        break;
    }
}

InformationsquelleAutor nikksan

0

Selon le MDN, la Fonction JavaScript de la section, le montant maximum de paramètres d'une fonction peut accepter est Deux cent cinquante cinq.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions#Defining_functions

param The name of an argument to be passed to the function. A function can have up to 255 arguments.
- Que l'article a depuis été retiré. C'était peut-être incorrect
InformationsquelleAutor Ernesto Hegi

Vous devez vous connecter pour publier un commentaire.