Comment initialiser la longueur d'un tableau en JavaScript?


542

La plupart des didacticiels que j'ai lus sur les tableaux en JavaScript (y compris w3schools et devguru ) suggèrent que vous pouvez initialiser un tableau avec une certaine longueur en passant un entier au constructeur Array en utilisant la var test = new Array(4);syntaxe.

Après avoir utilisé cette syntaxe généreusement dans mes fichiers js, j'ai exécuté l'un des fichiers via jsLint , et cela a paniqué:

Erreur: problème à la ligne 1, caractère 22: «)» attendu et à la place «4».
var test = nouveau tableau (4);
Problème à la ligne 1, caractère 23: attendu ";" et a vu à la place ')'.
var test = nouveau tableau (4);
Problème à la ligne 1, caractère 23: attend un identifiant et voit à la place ')'.

Après avoir lu l'explication de jsLint sur son comportement , il semble que jsLint n'aime pas vraiment la new Array()syntaxe, et préfère plutôt []lors de la déclaration des tableaux.

J'ai donc quelques questions:

D'abord pourquoi? Suis-je en train de courir un risque en utilisant la new Array()syntaxe à la place? Existe-t-il des incompatibilités de navigateur dont je devrais être conscient?

Et deuxièmement, si je passe à la syntaxe entre crochets, existe-t-il un moyen de déclarer un tableau et de définir sa longueur sur une seule ligne, ou dois-je faire quelque chose comme ceci:

var test = [];
test.length = 4;

js standards conseillent également contre l' utilisationnew Array()en général, mais il estaccord avectaille spécification. Je pense que tout se résume à la cohérence du code dans tout le contexte.
cregox

Pour ceux qui cherchent à préallouer des structures de tableaux plus rigides, il existe des tableaux typés . Notez que les avantages de performance peuvent varier
rovyko

Réponses:


397
  1. Pourquoi voulez-vous initialiser la longueur? Théoriquement, cela n'est pas nécessaire. Cela peut même entraîner un comportement déroutant, car tous les tests qui utilisent le lengthpour savoir si un tableau est vide ou non signaleront que le tableau n'est pas vide.
    Certains tests montrent que la définition de la longueur initiale des grands tableaux peut être plus efficace si le tableau est rempli par la suite, mais le gain de performances (le cas échéant) semble différer d'un navigateur à l'autre.

  2. jsLint n'aime pas new Array()parce que le constructeur est ambigu.

    new Array(4);

    crée un tableau vide de longueur 4. Mais

    new Array('4');

    crée un tableau contenant la valeur '4' .

Concernant votre commentaire: Dans JS, vous n'avez pas besoin d'initialiser la longueur du tableau. Il se développe dynamiquement. Vous pouvez simplement stocker la longueur dans une variable, par exemple

var data = [];
var length = 5; // user defined length

for(var i = 0; i < length; i++) {
    data.push(createSomeObject());
}

13
Le nombre d'objets dans le tableau est défini par l'utilisateur, donc je laissais l'utilisateur choisir un nombre, puis j'initialisais le tableau avec autant d'emplacements. Ensuite, je lance une forboucle qui itère sur la longueur du tableau et le remplit. Je suppose qu'il y aurait d'autres façons de le faire en JavaScript, donc la vraie réponse à "Pourquoi est-ce que je veux faire ça?" est "En raison des vieilles habitudes qui se sont formées lors de la programmation dans d'autres langues." :)
Michael Martin-Smucker

4
@mlms Laissez simplement la boucle for parcourir le nombre défini par l'utilisateur au lieu d'avoir à définir la longueur du tableau, puis parcourez-le. Cela n'a-t-il pas plus de sens pour vous?
Šime Vidas

151
<blockquote> Pourquoi voulez-vous initialiser la longueur? Théoriquement, cela n'est pas nécessaire. Et tous les tests qui utilisent la longueur pour savoir si un tableau est vide ou non échoueront. </blockquote> Hum, les performances peut-être? Il est plus rapide de définir un élément préexistant d'un tableau que de l'ajouter à la volée.
codehead

45
"le temps d'abandonner les vieilles habitudes de programmation" est vraiment inutile. les langues correctement structurées surpasseront toujours ecmascript mombo jambo
user151496

10
@codehead: en réponse à cette citation: "Il est plus rapide de définir un élément préexistant d'un tableau que de l'ajouter à la volée.": remarque qui new Array(10)ne crée pas un tableau avec 10 éléments non définis. Il crée simplement un tableau vide d'une longueur de 10. Voir cette réponse pour la vérité désagréable: stackoverflow.com/questions/18947892/…
Milimetric

599
  • Array(5) vous donne un tableau de longueur 5 mais sans valeur, vous ne pouvez donc pas le parcourir.

  • Array.apply(null, Array(5)).map(function () {}) vous donne un tableau de longueur 5 et non défini comme des valeurs, maintenant il peut être itéré.

  • Array.apply(null, Array(5)).map(function (x, i) { return i; }) vous donne un tableau de longueur 5 et de valeurs 0,1,2,3,4.

  • Array(5).forEach(alert)ne fait rien, Array.apply(null, Array(5)).forEach(alert)vous donne 5 alertes

  • ES6nous donne Array.frommaintenant vous pouvez également utiliserArray.from(Array(5)).forEach(alert)

  • Si vous souhaitez initialiser avec une certaine valeur, celles-ci sont bonnes à savoir ...
    Array.from('abcde'), Array.from('x'.repeat(5))
    ouArray.from({length: 5}, (v, i) => i) // gives [0, 1, 2, 3, 4]


11
C'est ce que je cherchais. Je voulais appliquer une carte sur une séquence logique; cela devrait le faire. Je vous remercie!
jedd.ahyoung

3
pourquoi Array.apply () lui donne une valeur non définie?
wdanxna

5
@wdanxna quand Arrayreçoit plusieurs arguments, il itère sur l' argumentsobjet et applique explicitement chaque valeur au nouveau tableau. Lorsque vous appelez Array.applyavec un tableau ou un objet avec une propriété de longueur Arrayva utiliser la longueur pour définir explicitement chaque valeur du nouveau tableau. C'est pourquoi Array(5)donne un tableau de 5 élisions, alors qu'il Array.apply(null, Array(5))donne un tableau de 5 non définis. Pour plus d'informations, consultez cette réponse.
KylePlusPlus

2
y a-t-il une différence entre Array (5) et nouveau Array (5)?
Petr Hurtak

2
Le Array.apply(null, Array(5)) peut également s'écrire Array.apply(null, {length: 5}). Il n'y a vraiment pas beaucoup de différence, mais ce dernier est clairement clair que l'intention est de créer un tableau de length 5, et non un tableau contenant5
AlexMorley-Finch

272

Avec ES2015,.fill() vous pouvez maintenant simplement faire:

// `n` is the size you want to initialize your array
// `0` is what the array will be filled with (can be any other value)
Array(n).fill(0)

Ce qui est beaucoup plus concis que Array.apply(0, new Array(n)).map(i => value)

Il est possible de laisser tomber le 0dans .fill()et exécuter sans arguments, qui remplira le tableau avec undefined. ( Cependant, cela échouera dans Typescript )


1
@AralRoca Vous pouvez toujours utiliser le Polyfill fourni sur la page MDN, ou envisager d'utiliser Modernizr .
AP.

4
Oui, veuillez l'essayer avant de commenter
AP.

1
@GarretWilson et @Christian C'est dans la spécification . When Array is called as a function rather than as a constructor, it also creates and initializes a new Array object. Thus the function call Array(…) is equivalent to the object creation expression new Array(…) with the same arguments
AP.

1
@AP., Le zéro est redondant. FaireArray(n).fill()
Pacerier

2
@Pacerier Je ne pense pas que le 0 soit redondant. Selon la définition du type es6, il s'agit de la signature de la fonction: fill (valeur: T, start ?: number, end ?: number): this; Par conséquent, la valeur de remplissage ne semble pas facultative. La compilation dactylographiée échouera car l'appel de fonction est écrit ci-dessus.
Micha Schwab

152
[...Array(6)].map(x => 0);
// [0, 0, 0, 0, 0, 0]

OU

Array(6).fill(0);
// [0, 0, 0, 0, 0, 0]

Remarque: vous ne pouvez pas boucler des emplacements vides, c.-à-d. Array(4).forEach(() => …)


OU

( sûr dactylographié )

Array(6).fill(null).map((_, i) => i);
// [0, 1, 2, 3, 4, 5]

OU

Méthode classique utilisant une fonction (fonctionne dans n'importe quel navigateur)

function NewArray(size) {
    var x = [];
    for (var i = 0; i < size; ++i) {
        x[i] = i;
        return x;
    }
}

var a = NewArray(10);
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Création de tableaux imbriqués

Lorsque vous créez un tableau 2D avec fillintuitivement, vous devez créer de nouvelles instances. Mais ce qui va réellement se passer, c'est que le même tableau sera stocké comme référence.

var a = Array(3).fill([6]);
// [  [6], [6], [6]  ]

a[0].push(9);
// [  [6, 9], [6, 9], [6, 9]  ]

Solution

var a = [...Array(3)].map(x => []);

a[0].push(4, 2);
// [  [4, 2], [], []  ]

Un tableau 3x2 ressemblera donc à ceci:

[...Array(3)].map(x => Array(2).fill(0));
// [  [0, 0], [0, 0], [0, 0]  ]

Tableau à N dimensions

function NArray(...dimensions) {
    var index = 0;
    function NArrayRec(dims) {
        var first = dims[0], next = dims.slice().splice(1); 
        if(dims.length > 1) 
            return Array(dims[0]).fill(null).map((x, i) => NArrayRec(next ));
        return Array(dims[0]).fill(null).map((x, i) => (index++));
    }
    return NArrayRec(dimensions);
}

var arr = NArray(3, 2, 4);
// [   [  [ 0,  1,  2,  3 ] , [  4,  5,  6,  7]  ],
//     [  [ 8,  9,  10, 11] , [ 12, 13, 14, 15]  ],
//     [  [ 16, 17, 18, 19] , [ 20, 21, 22, 23]  ]   ]

Initialiser un échiquier

var Chessboard = [...Array(8)].map((x, j) => {
    return Array(8).fill(null).map((y, i) => {
        return `${String.fromCharCode(65 + i)}${8 - j}`;
    });
});

// [ [A8, B8, C8, D8, E8, F8, G8, H8],
//   [A7, B7, C7, D7, E7, F7, G7, H7],
//   [A6, B6, C6, D6, E6, F6, G6, H6],
//   [A5, B5, C5, D5, E5, F5, G5, H5],
//   [A4, B4, C4, D4, E4, F4, G4, H4],
//   [A3, B3, C3, D3, E3, F3, G3, H3],
//   [A2, B2, C2, D2, E2, F2, G2, H2],
//   [A1, B1, C1, D1, E1, F1, G1, H1] ]

1
a[0].push(9); // [ [6, 9], [6], [6] ] devrait être a[0].push(9); // [ [6, 9], [6, 9], [6, 9] ] parce que chaque tableau imbriqué est stocké comme référence, donc la mutation d'un tableau affecte le reste. Vous l'avez peut-être
mal saisi,

@Alex_Zhong tru qui, merci, a perdu cela dans un montage
Vlad

68

Le plus court:

[...Array(1000)]

11
Surévalué, mais une mise en garde, vous ne devez absolument pas commencer une ligne dans JS avec un [sans utiliser un ;car il tentera de déréférencer la ligne ci-dessus. Donc, un moyen sûr d'utiliser cette ligne de manière prévisible dans n'importe quelle partie du code serait:;[...Array(1000)]//.whateverOpsNeeded()
AP.

pas vraiment. essayez dans les outils de développement. [...Array(5)].map((item, index) => ({ index })) essayez aussi ceci:[...Array(5)]; console.log('hello');
Michael Mammoliti

2
Essayez de l'utiliser dans un fichier js multi-lignes. Si votre première ligne est const a = 'a'et la ligne suivante [...Array(5)].//irrelevent. À votre avis, à quoi résoudrait la première ligne? Ce serait ce const a = 'a'[...Array(5)]qui se traduirait par:Uncaught SyntaxError: Unexpected token ...
AP.

7
C'est vrai, mais dans ce cas, je dirais que le problème est ailleurs, les points-virgules et les peluches sont importants de nos jours.
Michael Mammoliti

8
@AP cet exemple est exactement la raison pour laquelle de nombreux guides de style exigent de terminer chaque instruction par un point-virgule. const a = 'a'sera une erreur Lint dans ce cas. Quoi qu'il en soit, cela n'a vraiment rien à voir avec cette réponse.
graup

41

ES6 présente Array.fromce qui vous permet de créer un à Arraypartir de n'importe quel objet "semblable à un tableau" ou itérable :

Array.from({length: 10}, (x, i) => i);
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Dans ce cas, {length: 10}représente la définition minimale d'un objet "de type tableau" : un objet vide avec juste une lengthpropriété définie.

Array.from permet à un deuxième argument de mapper sur le tableau résultant.


2
@dain Je pense que [... Array (10)] est mieux stackoverflow.com/a/47929322/4137472
Alexander Shutau

1
Pourquoi mieux? L'utilisation du constructeur Array est déconseillée, et certains linter pourraient également se plaindre
Cristian Traìna

26

Cela initialisera la propriété length à 4:

var x = [,,,,];

3
C'est malin. Il n'a pas la flexibilité du constructeur, car vous ne pouvez pas utiliser une variable pour définir la longueur, mais il répond à ma question telle que je l'ai formulée à l'origine, donc +1.
Michael Martin-Smucker

12
Imaginez que pour 300 articles, les performances comptent vraiment!
Marco Luglio

9
Il n'y a probablement pas beaucoup de gain de performances lors de la préallocation d'une baie avec une si petite taille. La différence de performances sera mieux perçue lors de la création de baies plus grandes. Et dans ces cas, les initialiser avec des virgules serait un peu écrasant.
Marco Luglio

6
Je pense que cela donnera des résultats différents dans différents navigateurs en raison de la virgule finale, parfois 4 et parfois 5, voir stackoverflow.com/questions/7246618/…
jperelli

1
Et alors var size = 42; var myArray = eval("["+",".repeat(size)+"]");? (Pas si grave;)
xoxox

15

Je suis surpris qu'aucune solution fonctionnelle n'ait été suggérée pour vous permettre de définir la longueur sur une seule ligne. Ce qui suit est basé sur UnderscoreJS:

var test = _.map(_.range(4), function () { return undefined; });
console.log(test.length);

Pour les raisons mentionnées ci-dessus, j'éviterais de le faire à moins que je veuille initialiser le tableau à une valeur spécifique. Il est intéressant de noter qu'il existe d'autres bibliothèques qui implémentent la gamme, notamment Lo-dash et Lazy, qui peuvent avoir des caractéristiques de performances différentes.


Le soulignement de la magie noire n'est vraiment pas nécessaire ici. Les dépendances sont comme le sucre, cela semble doux au début, mais avant de le savoir, vous souffrez de diabète.
Romain Vincent

9

S'il vous plaît, les gens n'abandonnent pas encore leurs anciennes habitudes. Il y a une grande différence de vitesse entre allouer une fois la mémoire puis travailler avec les entrées de ce tableau (comme dans l'ancien) et l'allouer plusieurs fois au fur et à mesure qu'un tableau grandit (ce qui est inévitablement ce que le système fait sous le capot avec d'autres méthodes suggérées) .

Rien de tout cela n'a d'importance bien sûr, jusqu'à ce que vous vouliez faire quelque chose de cool avec des tableaux plus grands. Ensuite, c'est le cas.

Étant donné qu'il ne semble toujours pas y avoir d'option dans JS pour définir la capacité initiale d'une baie, j'utilise ce qui suit ...

var newArrayWithSize = function(size) {
  this.standard = this.standard||[];
  for (var add = size-this.standard.length; add>0; add--) {
   this.standard.push(undefined);// or whatever
  }
  return this.standard.slice(0,size);
}

Il y a des compromis à faire:

  • Cette méthode prend autant de temps que les autres pour le premier appel à la fonction, mais très peu de temps pour les appels ultérieurs (à moins de demander un tableau plus grand).
  • La standardbaie réserve en permanence autant d'espace que la plus grande baie que vous ayez demandée.

Mais si cela correspond à ce que vous faites, il peut y avoir un gain. Le timing informel met

for (var n=10000;n>0;n--) {var b = newArrayWithSize(10000);b[0]=0;}

à assez rapide (environ 50 ms pour le 10000 étant donné qu'avec n = 1000000 il a fallu environ 5 secondes), et

for (var n=10000;n>0;n--) {
  var b = [];for (var add=10000;add>0;add--) {
    b.push(undefined);
  }
}

à bien plus d'une minute (environ 90 secondes pour le 10000 sur la même console chromée, soit environ 2000 fois plus lentement). Ce ne sera pas seulement l'allocation, mais aussi les 10000 push, pour la boucle, etc.


si chaque fois que vous atteignez la fin du tableau, vous le dupliquez, la complexité de l'insertion de n valeurs est toujours O (n) donc il n'y a pas de différence de complexité (mais elle est plus lente).
Tomer Wolberg

Bien attrapé @TomerWolberg, j'ai changé ma formulation. Il s'agit de savoir si la méthode push est plus complexe que l'initialisation / copie d'un membre individuel par tranche. AFAIK qu'ils sont tous les deux à temps constant, à tout le moins ils pourraient l'être, j'ai donc utilisé le mot «vitesse» à la place.
wils

8

(c'était probablement mieux comme commentaire, mais c'est devenu trop long)

Donc, après avoir lu ceci, j'étais curieux de savoir si la pré-allocation était en fait plus rapide, car en théorie elle devrait l'être. Cependant, ce blog a donné quelques conseils le déconseillant http://www.html5rocks.com/en/tutorials/speed/v8/ .

Donc, toujours incertain, je l'ai mis à l'épreuve. Et il s'avère que cela semble en fait plus lent.

var time = Date.now();
var temp = [];
for(var i=0;i<100000;i++){
    temp[i]=i;
}
console.log(Date.now()-time);


var time = Date.now();
var temp2 = new Array(100000);
for(var i=0;i<100000;i++){
    temp2[i] = i;
}
console.log(Date.now()-time); 

Ce code donne les résultats suivants après quelques exécutions occasionnelles:

$ node main.js 
9
16
$ node main.js 
8
14
$ node main.js 
7
20
$ node main.js 
9
14
$ node main.js 
9
19

3
Intéressant, cela semblait inattendu, j'ai donc fait un test JSPerf . Les résultats Chrome correspondent à vos tests Node, mais Firefox et IE sont légèrement plus rapides lorsque vous pré-allouez de l'espace pour la baie.
Michael Martin-Smucker

1
@ MichaelMartin-Smucker Attendez ... cela signifie-t-il que le V8 n'est pas réellement entièrement optimisé et parfait?!?!? : P
Zeb McCorkle

1
@ MichaelMartin-Smucker - Je viens d'exécuter votre jsperf dans la version 42.0.2311.90 de Chrome (pour être précis - Test dans Chrome 42.0.2311.90 32 bits sur Windows Server 2008 R2 / 7 64 bits) et le tableau de taille dynamique était 69% plus lent .
Yellen

1
Idem. (J'ai écrit le test de nœud d'origine) En chrome 42.0.2311.90 sur les fenêtres de taille dynamique était 81% plus lent :). Mais nos tests originaux remontaient à plus d'un an maintenant. Le temps continue de glisser, de glisser ....
j03m

1
Fascinant ... à partir des résultats sur jsperf, il semble que pré-alloué a obtenu un énorme coup de pouce dans Chrome 38. L'avenir!
Michael Martin-Smucker

8
var arr=[];
arr[5]=0;
alert("length="+arr.length); // gives 6

2
Oui, cependant console.log (arr) donne que [5: 0]c'est un tableau clairsemé et probablement pas ce que l'on veut.
dreftymac

7

Voici une autre solution

var arr = Array.apply( null, { length: 4 } );
arr;  // [undefined, undefined, undefined, undefined] (in Chrome)
arr.length; // 4

Le premier argument de apply()est une liaison de cet objet, dont nous ne nous soucions pas ici, nous le définissons donc null.

Array.apply(..)appelle la Array(..)fonction et répartit la { length: 3 }valeur de l' objet comme arguments.


Je ne comprends pas pourquoi cette réponse a obtenu un downvote. C'est en fait un joli hack. Cela signifie que vous ne pouvez pas utiliser new Array(n)pour initialiser un tableau comme celui-ci new Array(n).map(function(notUsed,index){...}), mais avec cette approche, comme @zangw l'a mentionné, vous pouvez le faire. +1 de moi.
Victor.Palyvoda

3

Le constructeur du tableau a une syntaxe ambiguë , et JSLint fait juste mal à vos sentiments après tout.

En outre, votre exemple de code est cassé, la deuxième varinstruction soulèvera un SyntaxError. Vous définissez la propriété lengthdu tableau test, il n'y a donc pas besoin d'un autre var.

En ce qui concerne vos options, array.lengthc'est la seule "propre". La question est, pourquoi avez-vous besoin de définir la taille en premier lieu? Essayez de refactoriser votre code pour vous débarrasser de cette dépendance.


Woops, bon œil sur cette seconde var test. C'était une copie et un collage bâclés de ma part.
Michael Martin-Smucker

@IvoWetzel, vous souhaitez définir la taille pour améliorer les performances. Les tableaux JS sont des tableaux dynamiques . Si vous ne définissez pas la taille (ou plutôt sa capacité), JS allouera un tableau de taille par défaut. Si vous ajoutez ensuite plus d'éléments que ce qui peut en contenir, il devra agrandir le tableau, ce qui signifie qu'il allouera en interne un nouveau tableau, puis copiera tous les éléments.
Domi

3

En supposant que la longueur du tableau est constante. En Javascript, voici ce que nous faisons:

const intialArray = new Array(specify the value);


2

Comme expliqué ci-dessus, l'utilisation new Array(size)est quelque peu dangereuse. Au lieu de l'utiliser directement, placez-le dans une "fonction de création de tableau". Vous pouvez facilement vous assurer que cette fonction est exempte de bogues et vous évitez le danger d'appeler new Array(size)directement. Vous pouvez également lui donner une valeur initiale par défaut facultative. Cette createArrayfonction fait exactement cela:

function createArray(size, defaultVal) {
    var arr = new Array(size);
    if (arguments.length == 2) {
        // optional default value
        for (int i = 0; i < size; ++i) {
            arr[i] = defaultVal;
        }
    }
    return arr;
}

1

Dans la plupart des réponses, il est recommandé au filltableau car sinon "vous ne pouvez pas le parcourir" , mais ce n'est pas vrai. Vous pouvez parcourir un tableau vide, mais pas avec forEach. Les boucles while, for of et i fonctionnent parfaitement.

const count = Array(5);

Ne marche pas.

console.log('---for each loop:---');
count.forEach((empty, index) => {
    console.log(`counting ${index}`);
});

Ces travaux:

console.log('---for of loop:---');
for (let [index, empty] of count.entries()) {
  console.log(`counting for of loop ${index}`);
}

console.log('---for i loop:---');
for (let i = 0, il = count.length; i < il; ++i) {
  console.log(`counting for i loop ${i}`);
}

console.log('---while loop:---');
let index = 0;
while (index < count.length) { 
  console.log(`counting while loop ${index}`); 
  index++; 
}

Vérifiez ce violon avec les exemples ci-dessus.

Les angulaires *ngForfonctionnent également très bien avec un tableau vide:

<li *ngFor="let empty of count; let i = index" [ngClass]="
  <span>Counting with *ngFor {{i}}</span>
</li>

-1

Vous pouvez définir la longueur du tableau à l'aide de array.length = youValue

Ce serait donc

var myArray = [];
myArray.length = yourValue;

-3

La raison pour laquelle vous ne devez pas utiliser new Arrayest illustrée par ce code:

var Array = function () {};

var x = new Array(4);

alert(x.length);  // undefined...

Un autre code pourrait perturber la variable Array. Je sais que c'est un peu tiré par les cheveux que n'importe qui écrive un tel code, mais quand même ...

De plus, comme l'a dit Felix King, l'interface est un peu incohérente et pourrait entraîner des bogues très difficiles à localiser.

Si vous vouliez un tableau de longueur = x, rempli d'indéfini (comme le new Array(x)ferait), vous pouvez le faire:

var x = 4;
var myArray = [];
myArray[x - 1] = undefined;

alert(myArray.length); // 4

48
Selon ce raisonnement, vous ne devriez pas utiliser alertet undefined, car un autre code pourrait les déranger. Le deuxième exemple est moins lisible new Array(4)et ne donne pas le même résultat: jsfiddle.net/73fKd
Alexey Lebedev

25
Cette réponse est bizarre
Marco Demaio

6
Vous ne pouvez pas éviter que les gens s'amusent avec des objets globaux en JavaScript; ne faites tout simplement pas cela ou n'utilisez pas de cadres où les gens font cela.
Richard Connamacher

Dans le chrome repl actuellement: j = new Array (4); j.length; // résultats en 4
Parris
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.