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

최신 정보:

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

이것은 초기 배열을 만드는 더 최적화 된 방법 인 것 같습니다. 또한 @ felix-eve가 제안한 두 번째 매개 변수 맵 기능을 사용하도록 업데이트했습니다.

Array.from({ length: 3 }, (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], (item) => {
   doSomeThing(item);
});

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

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

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

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

참조 링크 에 대한 lodash설치

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

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

// run 5 times:
Array(5).fill().map((item, i)=>{ 
   console.log(i) // print index
})

위의 내용을 좀 더 "허용"하고 싶다면 현재 내 의견 기반 솔루션은 다음과 같습니다.

const iterate = times => callback => Array(times).fill().map((n,i) => callback(i))

iterate(3)(console.log)

구식 (역방향) 루프 사용 :

// run 5 times:
for( let i=5; i--; )
   console.log(i) 

또는 선언적 "while" :

const times = count => callback => { while(count--) callback(count) }

times(3)(console.log)

다음과 같이 디스트 럭처링으로 동일한 작업을 수행 할 수도 있습니다.

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

또는 색인이 필요한 경우

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

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;

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

const R = require('ramda');

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

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

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

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

중첩 된 루프를 사용하십시오 (함수로 묶일 수도 있음).

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

이 답변은 모두 훌륭하고 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
});

이러한 '시간'기능은 대부분의 응용 프로그램 코드에 그다지 유용하지 않지만 테스트에는 유용해야합니다.

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

loop(something, 3)

주어진 함수 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();

( _정크 변수로 사용하면 사용하는 경우 lodash 또는 밑줄이 흐려질 수 있습니다.)

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

사용 Array.from하고 .forEach.

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

스프레드 연산자와 같은 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

이 게시물은 배열을 구성하고 확산하는 논리가 명확하지 않은 경우 유용 합니다.

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에 대한 링크 는 여기 에서 찾을 수 있습니다.

이 게시물은 Andreas Bergström , vinyll , Ozay Duman , & SeregPie가 게시 한 솔루션을 구현합니다.