do <quelque chose> N fois (syntaxe déclarative)

Cette réponse est fondée sur Array.forEach, sans bibliothèque, il suffit de native la vanille.

Essentiellement appel something() 3 fois, utilisez:

[1,2,3].forEach(function(i) {
  something();
});

compte tenu de la fonction suivante:

function something(){ console.log('something') }

L'outpout sera

something
something
something

---

Pour compléter cette question, voici une façon de faire appel something() 1, 2 et 3 fois respectivement:

C'est 2017, vous pouvez utiliser ES6:

[1,2,3].forEach(i => Array(i).fill(i).forEach(_ => {
  something()
}))

ou dans le bon vieux ES5:

[1,2,3].forEach(function(i) {
  Array(i).fill(i).forEach(function() {
    something()
  })
}))

Dans les deux cas, l'outpout sera

L'outpout sera

something

something
something

something
something
something

(une fois, puis deux, puis 3 fois)

Possible ES6 alternative.

Array.from(Array(3)).forEach((x, i) => {
  something();
});

Et, si vous le voulez "pour être appelé 1,2 et 3 fois respectivement".

Array.from(Array(3)).forEach((x, i) => {
  Array.from(Array(i+1)).forEach((x, i2) => {
    console.log(`Something ${ i } ${ i2 }`)
  });
});

Mise à jour:

Prises de remplissage-tableaux-avec-undefined

Ce qui semble être un plus, de façon à optimiser de la création de la table initiale.

Array.from({ length: 3 }).forEach((x, i) => {
  something();
});

Nous pouvons utiliser lodash à faire ce travail par:

_.each([1, 2, 3], function(item) {
   doSomeThing(item);
});

//Or:
_.each([1, 2, 3], doSomeThing);

Ou si vous voulez faire quelque chose de N fois:

var n = 10;
_.times(n, function() {
   doSomeThing();
});

//Or: 
_.times(n, doSomeThing);

Référence ce lien pour lodash installation

Créer un Tableau et de remplissage tous les articles avec undefined donc map méthode de travail:

Array.fill n'a pas d'IE de soutien

JS:

Array(5).fill().map(()=>{ 
   //Do this 5 times:
   console.log(111) 
})

---

À l'aide de la vieille école vénère la boucle:

JS:

for( let i=5; i--; ){
   //Do this 5 times:
   console.log(222) 
}

vous pouvez utiliser

Tableau.forEach

exemple:

function logArrayElements(element, index, array) {  
    console.log("a[" + index + "] = " + element);  
}  
[2, 5, 9].forEach(logArrayElements)

ou avec jQuery

$.each([52, 97], function(index, value) { 
  alert(index + ': ' + value); 
});

http://api.jquery.com/jQuery.each/

//calls doSomething 42 times
Array( 42 ).join( "x" ).split( "" ).forEach( doSomething );

et

//creates 42 somethings
var somethings = Array( 42 ).join( "x" ).split( "" ).map( () => buildSomething(); );

(ou via https://stackoverflow.com/a/20066663/275501 )

Array.apply(null, {length: 42}).forEach( doSomething );

Il ya une fantastique bibliothèque appelée Ramda, qui est similaire à un trait de Soulignement et Lodash, mais est de plus en plus puissants.

const R = require('ramda');

R.call(R.times(() => {
    console.log('do something')
}), 5);

Ramda contient beaucoup de fonctions utiles. Voir Ramda documentation

Ces réponses sont toutes bonnes et bien et de l'OMI @Andreas est le meilleur, mais de nombreuses fois en JS que nous avons à faire les choses de manière asynchrone, dans ce cas, async vous a couvert:

http://caolan.github.io/async/docs.html#times

const async = require('async');

async.times(5, function(n, next) {
    createUser(n, function(err, user) {
        next(err, user);
    });
}, function(err, users) {
    //we should now have 5 users
});

Ces "temps" caractéristiques arent très utile pour la plupart le code de l'application, mais devrait être utile pour les tests.

Tableau.à partir de (ES6)

function doSomthing() {
    ...
}

L'utiliser comme ceci:

Array.from(Array(length).keys()).forEach(doSomthing);

Ou

Array.from({ length }, (v, i) => i).forEach(doSomthing);

Ou

//array start counting from 1
Array.from({ length }, (v, i) => ++i).forEach(doSomthing);

En supposant que nous pouvons utiliser de l'ES6 syntaxe comme la propagation de l'opérateur, nous voulons faire quelque chose autant de fois que la somme de tous les numéros de la collection.

Dans ce cas, si le temps est égal à [1,2,3], le nombre total de fois sera la 6, c'est à dire 1+2+3.

/**
 * @param {number[]} times
 * @param {cb} function
 */
function doTimes(times, cb) {
  //Get the sum of all the times
  const totalTimes = times.reduce((acc, time) => acc + time);
  //Call the callback as many times as the sum
  [...Array(totalTimes)].map(cb);
}

doTimes([1,2,3], () => console.log('something'));
//=> Prints 'something' 6 times

Ce poste devrait être utile si la logique qui sous-tend la construction et la diffusion d'un tableau n'est pas évident.