web-dev-qa-db-fra.com

Méthode la plus simple pour créer un tableau d'entiers de 1..20 en JavaScript

Quelle serait la meilleure façon de créer ce tableau:

var x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
         11, 12, 13, 14, 15, 16, 17, 18, 19, 20];

Par exemple, une boucle for:

var x = [];
for (var i=1;i<=20;i++) {
  x.Push(i);
}

Ou une boucle while:

var x = [], i = 1, endInt = 20;
while (i <= endInt) {
  x.Push(i);
  i++;
}

Y a-t-il d'autres exemples qui seraient moins précis - autrement dit - moins de code? Je pense à des choses comme en Ruby où le code équivalent serait aussi simple que 1..20. Je ne connais pas cette syntaxe en JavaScript, mais je me demande s’il existe des moyens plus courts de faire la même chose.

MISE À JOUR: Je ne pensais pas supprimer les points-virgules ou var pour les réponses à la question, mais je dois admettre que la question implique cela. Je suis plus curieux à propos des algorithmes que du rasage des octets. Désolé si je n'étais pas clair! En outre, en faire une fonction est assez simple, claquez simplement function range(start, end) { /* guts here */ } et vous y êtes. La question est de savoir s'il existe de nouvelles approches du "tripes". 

javascriptalgorithm
38
artlung

Cela peut être fait avec les fonctionnalités de l'ES6, actuellement uniquement supportées par Firefox Thou. J'ai trouvé un tableau de compatibilité ici: http://kangax.github.io/compat-table/es6/

Array.from(new Array(20), (x,i) => i+1)

Si vous voulez avoir une autre gamme alors je suppose que vous pourriez faire

Array.from(new Array(5), (x,i) => i+5)

Ce qui serait alors [5,6,7,8,9]

20
CapK

Vous pouvez le faire avec une boucle while où le Push a lieu dans la condition.Array.Push renvoie la longueur du tableau, qui se trouve être identique à la valeur dans ce cas. Donc, vous pouvez faire ce qui suit:

x = []; //normally would use var here
i = 1;  //normally would use var here
while(x.Push(i++)<20){}

//at this point, x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

Version condensée (31 caractères)

x=[];i=1;while(x.Push(i++)<20);

Exemple jsFiddle

15
EndangeredMassa

while-- est le chemin à parcourir

var a=[],b=10;while(b--)a[b]=b+1

retourne [1,2,3,4,5,6,7,8,9,10]

expliqué avec start & length

var array=[],length=20,start=5;while(length--)array[length]=length+start

retours [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24] 

veux la gamme?

expliqué avec start & end

var array=[],end=30,start=25,a=end-start+1;while(a--)array[a]=end--

retourne [25, 26, 27, 28, 29, 30]

pour --

for(var a=[],b=20;b>0;b--,a[b]=b+1)

pour ++

for(var a=[],b=0;b<20;b++,a[b]=b+1)

POURQUOI est-ce la voie à suivre?

  1. while - est prolly la boucle la plus rapide;

  2. le réglage direct est plus rapide que Push & concat;

  3. [] est également plus rapide que le nouveau tableau (10);

  4. ce n'est pas beaucoup plus long que tous les autres

techniques d'économie d'octets:

  1. utiliser les arguments en tant que placholder pour les variables de fonction
  2. n'utilisez pas new Array (), Push (), concat () si vous n'en avez pas besoin
  3. placez "() {} ;," uniquement lorsque vous en avez besoin.
  4. utilisez a, b, c, d ... dans des fonctions courtes.

donc, si vous voulez une fonction pour cette

avec début, fin (plage)

function range(a,b,c,d){d=[];c=b-a+1;while(c--)d[c]=b--;return d}

alors maintenant gamme (3,7) retourne [3,4,5,6,7]

vous économisez des octets de nombreuses façons ici et cette fonction est également très rapide car elle n’utilise pas concat, Push, new Array et c’est fait avec le temps -

3
cocco

Vous pouvez toujours créer une fonction ... 

function createNumArray(a, b) {
   var arr = [], 
       i = a;

    while((arr[arr.length] = i) < b) {i++}
    return arr;
}

Ce qui vous permet d'écrire un code succinct plus tard, tel que ...

var arr = createNumArray(1, 20);
1
MillsJROSS

Si vous cherchez à éliminer les personnages de toute façon possible sans vous soucier de la lisibilité, voici le mieux que je puisse faire:

var x=[],i=0
while(i<20)
  x[i]=i+++1

Pas beaucoup mieux que le vôtre cependant.

Modifier: 

En fait, cela fonctionne mieux et élimine quelques personnages:

var x=[],i=0
while(i<20)
  x[i]=++i

Edit 2:

Et voici mon entrée pour une fonction générale "plage" dans le plus petit nombre de caractères:

function range(s,e){var x=[];while(s<e+1)x.Push(s++);return x}

Encore une fois, n'écrivez pas le code de cette façon. :)

1
rob

Je suppose que c'est le chemin le plus court:

var i=0, arr = [];
while (i++<20){
  arr.Push(i);
}

ou s'associer sur le code 'pervers' dans EndangeredMassa

var i,arr; while (i=i||1, (arr=arr||[]).Push(i++)<20){}
1
KooiInc

J'étendrais le prototype d'Array pour simplifier l'accès:

Array.prototype.range = function(start, end) {
    if (!this.length) {
        while (end >= start) {
            this.Push(start++);
        }
    } else {
        throw "You can only call 'range' on an empty array";
    }
    return this;
};

var array = [].range(1, 20);

Bien que ce qui précède soit le plus proche auquel je puisse penser en ce qui concerne le sucre syntaxique que vous recherchez, vous pouvez essayer CoffeeScript . 

Il supporte la notation que vous recherchez.

CoffeeScript:

test = [1..20]

alert test

Render to JavaScript:

var test;
test = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
alert(test);

Vous pouvez essayer des exemples en direct sur leur site et voir la conversion effectuée au fur et à mesure que vous tapez.

Cliquez simplement sur le lien TRY COFFEESCRIPT en haut et vous obtiendrez une console où vous pourrez tester du code.

0
user113716

À ma connaissance, la possibilité d'utiliser la boucle for, comme vous l'avez mentionné, est la plus concise.

C'est,

var x = [];
for (var i=1;i<=20;i++) {
  x.Push(i);
}
0
Hasan Fahim
var i = 0;
var x = [];
while (i++ < 20) x.Push(i);

JSFiddle

0
YetAnotherUser