在 JavaScript 中循环 x 次的典型方式是：
for (var i = 0; i < x; i++)
doStuff(i);
但是我不想使用 ++ 操作符或任何可变变量。那么在 ES6 中，有没有其他的方法可以循环 x 次？我喜欢 Ruby 的机制：
但是我不想使用 ++ 操作符或任何可变变量。那么在 ES6 中，有没有其他的方法可以循环 x 次？我喜欢 Ruby 的机制：
x.times do |i|
do_stuff(i)
end
在JavaScript / ES6中有类似的东西吗？ 我可以通过一些技巧来创建自己的生成器：
function* times(x) {
for (var i = 0; i < x; i++)
yield i;
}
for (var i of times(5)) {
console.log(i);
}
i++，至少它已经不显眼了，但我希望在ES6中有一个更好的机制。虽然我不会教授这种方法（或在我的代码中使用），但这是一种无需改变变量且不需要ES6的codegolf-worthy解决方案：
Array.apply(null, {length: 10}).forEach(function(_, i){
doStuff(i);
})
实际上这更像是一个有趣的概念验证，而不是一个有用的答案。
Array.apply(null, {length: 10})不能直接用Array(10)吗？ - Pavlo如果你愿意使用一个库，也可以使用 lodash 的 _.times 或者 underscore 的 _.times：
_.times(x, i => {
return doStuff(i)
})
x.times.map { |i|
doStuff(i)
}
repeat通常是一个无限递归函数。要使用它，我们需要惰性求值或延续传递样式。
const repeat = f => x => [x, () => repeat(f) (f(x))];
const take = n => ([x, f]) => n === 0 ? x : take(n - 1) (f());
console.log(
take(8) (repeat(x => x * 2) (1)) // 256
);我使用thunk（一个没有参数的函数）在Javascript中实现了延迟求值。
const repeat = f => x => [x, k => k(repeat(f) (f(x)))];
const take = n => ([x, k]) => n === 0 ? x : k(take(n - 1));
console.log(
take(8) (repeat(x => x * 2) (1)) // 256
);k => k(...)。请注意，CPS 将应用程序反转，即 take(8) (repeat...) 变成了 k(take(8)) (...)，其中 k 是部分应用的 repeat。repeat）与终止条件（take）分离，我们获得了灵活性 - 关注点的划分到苦尽甘来 :Dtimes方法的机制。但是你可以通过使用递归来避免突变：let times = (i, cb, l = i) => {
if (i === 0) return;
cb(l - i);
times(i - 1, cb, l);
}
times(5, i => doStuff(i));
Array.from(Array(max-min+1), (_, index) => index+min)。此解决方案的优点
缺点 - 变异。只是内部使用，我不在意，但可能有其他人会关心。
示例和代码
times(5, 3) // 15 (3+3+3+3+3)
times(5, (i) => Math.pow(2,i) ) // 31 (1+2+4+8+16)
times(5, '<br/>') // <br/><br/><br/><br/><br/>
times(3, (i, count) => { // name[0], name[1], name[2]
let n = 'name[' + i + ']'
if (i < count-1)
n += ', '
return n
})
function times(count, callbackOrScalar) {
let type = typeof callbackOrScalar
let sum
if (type === 'number') sum = 0
else if (type === 'string') sum = ''
for (let j = 0; j < count; j++) {
if (type === 'function') {
const callback = callbackOrScalar
const result = callback(j, count)
if (typeof result === 'number' || typeof result === 'string')
sum = sum === undefined ? result : sum + result
}
else if (type === 'number' || type === 'string') {
const scalar = callbackOrScalar
sum = sum === undefined ? scalar : sum + scalar
}
}
return sum
}
[...Array(30).keys()]
我只是想把这个放在这里。如果你正在寻找一个紧凑的函数，而不使用数组，并且对可变性/不可变性没有问题：
var g =x=>{/*your code goes here*/x-1>0?g(x-1):null};
在我看来，这个问题最正确的答案（有争议）似乎被Sasha Kondrashov的评论埋没了，而且也是最简洁的，只使用了两个字符：“no”。没有任何功能上的替代方案可以像Ruby语法那样好用。我们可能希望有一个，但实际上并没有。
虽然问题中没有明确说明，但我认为解决“循环N次”的问题的任何解决方案都不应该分配内存，至少不是与N成比例的内存。这个标准将排除大多数“本地于JavaScript”的答案。
其他答案展示了像Ruby中的实现一样的解决方案，这很好，但问题明确要求一个本地的JavaScript解决方案。而且问题中已经有一个非常不错的手动解决方案，可以说是所有解决方案中最易读的之一。
For me, this is the easiest answer to understand for many levels of developers
const times = (n, callback) => {
while (n) {
callback();
n--;
}
}
times(10, ()=> console.log('hello'))n 的值？ - Kelsey Hannan