하다

하다 N 회 (선언적 구문)

---

Javascript에 다음과 같이 쉽게 작성할 수있는 방법이 있습니까?

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

유사한 구문을 지원할 수있는 라이브러리가 있습니까?

업데이트 : 명확히하기 위해- something()각 배열 요소 반복에 대해 각각 1,2 및 3 번 호출하고 싶습니다.

---

이 답변은 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()
  })
}))

두 경우 모두 아웃 파우 트는

아웃 파우 트는

something

something
something

something
something
something

(1 회, 2 회, 3 회)

---

루프를 사용하십시오.

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

---

가능한 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 }`)
  });
});

최신 정보:

정의되지 않은 채우기 배열 에서 가져옴

이것은 초기 어레이를 생성하는 더 최적화 된 방법 인 것 같습니다.

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

---

밑줄을 언급 한 이후 :

f호출하려는 함수가 다음과 같다고 가정 합니다.

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

트릭을 할 것입니다. 예를 들어를 사용 f = function (x) { console.log(x); }하면 콘솔이 표시됩니다.0 0 1 0 1 2

---

lodash 를 사용 하여이 작업을 수행 할 수 있습니다 .

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

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

또는 무언가를 N 번 하고 싶다면 :

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

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

이 링크 를 참조 하여 lodash설치하십시오.

---

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;

---

이렇게 방법으로 배열 및 fill모든 항목을 만들 수 있습니다.undefinedmap

Array.fill IE를 지원하지 않습니다

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

---

구식 reveres 루프 사용 :

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

---

배열의 길이를 사용하여 작업을 여러 번 실행할 수 있습니다.

var arr = [1,2,3];

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

또는

 var arr = [1,2,3];

 do
 {


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

---

당신이 사용할 수있는

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/

---

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

---

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

---

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

---

Underscore 및 Lodash와 유사하지만 더 강력한 Ramda라는 환상적인 라이브러리가 있습니다.

const R = require('ramda');

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

Ramda에는 유용한 기능이 많이 포함되어 있습니다. Ramda 문서 참조

---

Just use a nested loop (maybe enclosed in a function)

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

Then just call it like this:

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

---

These answers are all good and well and IMO @Andreas is the best, but many times in JS we have to do things asynchronously, in that case, async has you covered:

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

These 'times' features arent very useful for most application code, but should be useful for testing.

---

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

loop(something, 3)

---

Array.from (ES6)

function doSomthing() {
    ...
}

Use it like so:

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

Or

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

Or

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

---

Using Array.from and .forEach.

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

---

Assuming we can use some ES6 syntax like the spread operator, we'll want to do something as many times as the sum of all numbers in the collection.

In this case if times is equal to [1,2,3], the total number of times will be 6, i.e. 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

This post should be helpful if the logic behind constructing and spreading an array isn't apparent.

---

Given a function something:

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

And a new method times added to the Array prototype:

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

This code:

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

Outputs this:

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

Which I think answers your updated question (5 years later) but I wonder how useful it is to have this work on an array? Wouldn't the effect be the same as calling [6].times(something), which in turn could be written as:

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

(although the use of _ as a junk variable will probably clobber lodash or underscore if you're using it)

참고URL : https://stackoverflow.com/questions/10993824/do-something-n-times-declarative-syntax