<something>をN回実行します（宣言構文）

Question 1

JavaScriptにこのようなものを簡単に書く方法はありますか：

[1,2,3].times do {
  something();
}

同様の構文をサポートする可能性のあるライブラリはありますか？

更新：明確にするために- something()各配列要素の反復ごとにそれぞれ1、2、3回呼び出されたい

Question 2

この回答はArray.forEach、ライブラリを使用せず、ネイティブバニラのみに基づいています。

基本的にsomething()3回呼び出すには、次を使用します。

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

次の機能を検討します。

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

発信者は

something
something
something

この質問を完了するために、something()それぞれ1、2、3回電話をかける方法を次に示します。

2017年です。ES6を使用できます。

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

または古き良きES5では：

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

どちらの場合も、outpoutは

発信者は

something

something
something

something
something
something

（1回、2回、3回）

Question 3

ループを使うだけです：

var times = 10;
for(var i=0; i < times; i++){
    doSomething();
}

Question 4

ES6の代替案。

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

また、「それぞれ1、2、3回呼び出されるようにする」場合も同様です。

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

更新：

fill -arrays-with-undefinedから取得

これは、初期配列を作成するためのより最適化された方法のようです。@ felix-eveによって提案された2番目のパラメーターマップ関数を使用するように更新しました。

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

Question 5

アンダースコアについて言及したので：

想定するのfは、呼び出す関数です。

_.each([1,2,3], function (n) { _.times(n, f) });

トリックを行います。たとえばf = function (x) { console.log(x); }、を使用すると、コンソールが表示されます。 0 0 1 0 1 2

Question 6

lodash：

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

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

または、N回何かをしたい場合：

const N = 10;
_.times(N, () => {
   doSomeThing();
});

//Or shorter:
_.times(N, doSomeThing);

インストールについては、このリンクを参照してくださいlodash

Question 7

配列とso メソッド`fill`を`undefined`使用してすべてのアイテムを作成すると、機能`map`する可能性があります。

Array.fill IEのサポートがない

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

スニペットを展開

古い学校のリヴァーズループを使用する：

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

スニペットを展開

Question 8

次のように分解して同じことを行うこともできます

[...Array(3)].forEach( _ => console.log('do something'));

またはインデックスが必要な場合

[...Array(3)].forEach(( _, index) => console.log('do something'));

Question 9

Underscorejsを使用できない場合は、自分で実装できます。NumberおよびStringプロトタイプに新しいメソッドをアタッチすると、次のようになります（ES6矢印関数を使用）。

// With String
"5".times( (i) => console.log("number "+i) );

// With number variable
var five = 5;
five.times( (i) => console.log("number "+i) );

// With number literal (parentheses required)
(5).times( (i) => console.log("number "+i) );

（任意の名前の）関数式を作成し、それにアクセスしたい（プロトタイプの）任意のプロパティ名に割り当てる必要があります。

var timesFunction = function(callback) {
  if (typeof callback !== "function" ) {
    throw new TypeError("Callback is not a function");
  } else if( isNaN(parseInt(Number(this.valueOf()))) ) {
    throw new TypeError("Object is not a valid number");
  }
  for (var i = 0; i < Number(this.valueOf()); i++) {
    callback(i);
  }
};

String.prototype.times = timesFunction;
Number.prototype.times = timesFunction;

Question 10

ラムダと呼ばれる素晴らしいライブラリがあります。これは、アンダースコアやロダッシュに似ていますが、より強力です。

const R = require('ramda');

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

Ramdaには便利な機能がたくさん含まれています。Ramdaのドキュメントを参照

Question 11

配列の長さを使用して、タスクを何度も実行できます。

var arr = [1,2,3];

for(var i=0; i < arr.length; i++){
    doSomething();
}

または

 var arr = [1,2,3];

 do
 {


 }
 while (i++ < arr.length);

Question 12

あなたは使うことができます

Array.forEach

例：

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

またはjQueryで

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

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

Question 13

times = function () {
    var length = arguments.length;
    for (var i = 0; i < length ; i++) {
        for (var j = 0; j < arguments[i]; j++) {
            dosomthing();
        }
    }
}

次のように呼び出すことができます。

times(3,4);
times(1,2,3,4);
times(1,3,5,7,9);

Question 14

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

そして

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

または（https://stackoverflow.com/a/20066663/275501経由）

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

Question 15

var times = [1,2,3];

for(var i = 0; i < times.length;  i++) {
  for(var j = 0; j < times[i];j++) {
     // do something
  }
}

jQueryの使用 .each()

$([1,2,3]).each(function(i, val) {
  for(var j = 0; j < val;j++) {
     // do something
  }
});

または

var x = [1,2,3];

$(x).each(function(i, val) {
  for(var j = 0; j < val;j++) {
     // do something
  }
});

編集

あなたは純粋なJSで以下のようにすることができます：

var times = [1,2,3];
times.forEach(function(i) {
   // do something
});

Question 16

ネストされたループを使用するだけです（おそらく関数で囲まれています）

function times( fct, times ) {
  for( var i=0; i<times.length; ++i ) {
    for( var j=0; j<times[i]; ++j ) {
      fct();
    }
  }
}

次に、次のように呼び出します。

times( doSomething, [1,2,3] );

Question 17

これらの答えはすべてうまくいっており、IMO @Andreasが最高ですが、JSでは何度も非同期で行う必要があります。その場合、非同期で対応できます。

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
});

これらの「時間」機能は、ほとんどのアプリケーションコードに非常に役立ちますが、テストには役立つはずです。

Question 18

const loop (fn, times) => {
  if (!times) { return }
  fn()
  loop(fn, times - 1)
}

loop(something, 3)

Question 19

与えられた関数something：

function something() { console.log("did something") }

そしてtimes、Arrayプロトタイプに追加された新しいメソッド：

Array.prototype.times = function(f){
  for(v of this) 
    for(var _ of Array(v))
      f();
}

このコード：

[1,2,3].times(something)

これを出力します：

did something
did something
did something
did something
did something
did something

更新された質問（5年後）に答えると思いますが、これを配列で機能させるとどれほど便利なのでしょうか。効果はを呼び出すのと同じではありません[6].times(something)。

for(_ of Array(6)) something();

（ただし、_ジャンク変数として使用すると、おそらくロダッシュまたはアンダースコアが使用されます）

Question 20

Array.from（ES6）

function doSomthing() {
    ...
}

次のように使用します。

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

または

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

または

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

Question 21

とを使用Array.fromし.forEachます。

let length = 5;
Array.from({length}).forEach((v, i) => {
  console.log(`#${i}`);
});

スニペットを展開

Question 22

スプレッド演算子のようないくつかのES6構文を使用できると仮定すると、コレクション内のすべての数値の合計と同じ回数だけ何かを実行する必要があります。

この場合、時間が等しい場合[1,2,3]、合計回数は6回、つまり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

この投稿は、配列の構築と展開の背後にあるロジックが明らかでない場合に役立ちます。

Question 23

TypeScript実装：

実装方法String.timesとNumber.times、タイプセーフでで動作する方法に興味のある方はthisArg、こちらをご覧ください。

declare global {
    interface Number {
        times: (callbackFn: (iteration: number) => void, thisArg?: any) => void;
    }
    interface String {
        times: (callbackFn: (iteration: number) => void, thisArg?: any) => void;
    }
}

Number.prototype.times = function (callbackFn, thisArg) {
    const num = this.valueOf()
    if (typeof callbackFn !== "function" ) {
        throw new TypeError("callbackFn is not a function")
    }
    if (num < 0) {
        throw new RangeError('Must not be negative')
    }
    if (!isFinite(num)) {
        throw new RangeError('Must be Finite')
    }
    if (isNaN(num)) {
        throw new RangeError('Must not be NaN')
    }

    [...Array(num)].forEach((_, i) => callbackFn.bind(thisArg, i + 1)())
    // Other elegant solutions
    // new Array<null>(num).fill(null).forEach(() => {})
    // Array.from({length: num}).forEach(() => {})
}

String.prototype.times = function (callbackFn, thisArg) {
    let num = parseInt(this.valueOf())
    if (typeof callbackFn !== "function" ) {
        throw new TypeError("callbackFn is not a function")
    }
    if (num < 0) {
        throw new RangeError('Must not be negative')
    }
    if (!isFinite(num)) {
        throw new RangeError('Must be Finite')
    }
    // num is NaN if `this` is an empty string 
    if (isNaN(num)) {
        num = 0
    }

    [...Array(num)].forEach((_, i) => callbackFn.bind(thisArg, i + 1)())
    // Other elegant solutions
    // new Array<null>(num).fill(null).forEach(() => {})
    // Array.from({length: num}).forEach(() => {})
}

いくつかの例を含むTypeScript Playgroundへのリンクはここにあります

投稿者：この記事を実装ソリューションアンドレアスベルイストローム、vinyll、Ozay豆満江、＆SeregPie

<something>をN回実行します（宣言構文）

2017年です。ES6を使用できます。

または古き良きES5では：

更新：

配列とso メソッドfillをundefined使用してすべてのアイテムを作成すると、機能mapする可能性があります。

古い学校のリヴァーズループを使用する：

編集

Array.from（ES6）

配列とso メソッド`fill`を`undefined`使用してすべてのアイテムを作成すると、機能`map`する可能性があります。