Czy istnieje mechanizm pętli x razy w ES6 (ECMAScript 6) bez zmiennych mutacyjnych?

Używając ES2015 operator spreadu:

[...Array(n)].map()

const res = [...Array(10)].map((_, i) => {
  return i * 10;
});

// as a one liner
const res = [...Array(10)].map((_, i) => i * 10);

Lub jeśli nie potrzebujesz wyniku:

[...Array(10)].forEach((_, i) => {
  console.log(i);
});

// as a one liner
[...Array(10)].forEach((_, i) => console.log(i));

Zwróć uwagę, że jeśli potrzebujesz tylko powtarzanego ciągu, możesz użyć String.prototyp.powtórz .

console.log("0".repeat(10))
// 0000000000

for (let i of Array(100).keys()) {
    console.log(i)
}

Myślę, że najlepszym rozwiązaniem jest użycie let:

for (let i=0; i<100; i++) …

, która utworzy nową (zmienną) i zmienną dla każdej oceny ciała i zapewni, że i jest zmieniana tylko w wyrażeniu przyrostowym w składni tej pętli, a nie gdziekolwiek indziej.

Mógłbym oszukać i stworzyć własny generator. Przynajmniej {[6] } jest poza zasięgiem wzroku:)

You should be fine with

function* times(n) {
  for (let i = 0; i < x; i++)
    yield i;
}
for (const i of times(5))
  console.log(i);

Ale nie chcę używać operatora ++ ani mieć w ogóle zmiennych mutowalnych.

Wtedy jedynym wyborem jest użycie rekurencji. Można zdefiniować tę funkcję generatora również bez mutowalnego i:

function* range(i, n) {
  if (i >= n) return;
  yield i;
  return yield* range(i+1, n);
}
times = (n) => range(0, n);

Ale wydaje mi się to przesadą i może mieć problemy z wydajnością (ponieważ eliminacja ogona jest niedostępne dla return yield*).

Odpowiedź: 09 Grudnia 2015

osobiście znalazłem zaakceptowaną odpowiedź zarówno zwięzłą (dobrą), jak i zwięzłą (złą). Doceniam to stwierdzenie może być subiektywne, więc proszę przeczytać tę odpowiedź i zobaczyć, czy zgadzasz się lub nie

Przykład podany w pytaniu był podobny do Rubiego:

x.times do |i|
  do_stuff(i)
end

Wyrażenie tego w JS używając poniższego kodu pozwoli na:

times(x)(doStuff(i));

Oto kod:

let times = (n) => {
  return (f) => {
    Array(n).fill().map((_, i) => f(i));
  };
};

To jest to!

Prosty przykład sposób użycia:

let cheer = () => console.log('Hip hip hooray!');

times(3)(cheer);

//Hip hip hooray!
//Hip hip hooray!
//Hip hip hooray!

Alternatywnie, zgodnie z przykładami zaakceptowanej odpowiedzi:

let doStuff = (i) => console.log(i, ' hi'),
  once = times(1),
  twice = times(2),
  thrice = times(3);

once(doStuff);
//0 ' hi'

twice(doStuff);
//0 ' hi'
//1 ' hi'

thrice(doStuff);
//0 ' hi'
//1 ' hi'
//2 ' hi'

Uwaga boczna-definiowanie funkcji zakresu

Podobne / powiązane pytanie, które używa zasadniczo bardzo podobnych konstrukcji kodu, może być, czy istnieje wygodna funkcja Range W (core) JavaScript, coś podobnego do funkcji range underscore ' a.

Utworzyć tablicę z N liczbami, zaczynając od x

Podkreślenie

_.range(x, x + n)

ES2015

kilka alternatyw:

Array(n).fill().map((_, i) => x + i)

Array.from(Array(n), (_, i) => x + i)

Demo używając n = 10, x = 1:

> Array(10).fill().map((_, i) => i + 1)
// [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

> Array.from(Array(10), (_, i) => i + 1)
// [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

W szybkim teście uruchomiłem, przy czym każde z powyższych uruchomiło się milion razy za pomocą naszego rozwiązania i funkcji doStuff, poprzedniego podejścia(Array (N).fill()) okazał się nieco szybszy.

Myślę, że to dość proste:

[...Array(3).keys()]

Lub

Array(3).fill()

const times = 4;
new Array(times).fill().map(() => console.log('test'));

Ten fragment będzie console.log test 4 razy.

Nie coś, czego bym nauczył (lub kiedykolwiek używał w moim kodzie), ale oto rozwiązanie godne codegolf bez mutacji zmiennej, bez potrzeby ES6:

Array.apply(null, {length: 10}).forEach(function(_, i){
    doStuff(i);
})

Array(100).fill().map((_,i)=> console.log(i) );

Ta wersja spełnia wymagania OP dotyczące niezmienności. Rozważ również użycie reduce zamiast map w zależności od przypadku użycia.

Jest to również opcja, jeśli nie masz nic przeciwko małej mutacji w swoim prototypie.

Number.prototype.times = function(f) {
   return Array(this.valueOf()).fill().map((_,i)=>f(i));
};

Teraz możemy to zrobić

((3).times(i=>console.log(i)));

+1 do arcseldona za sugestię .fill.

Afaik, w ES6 nie ma mechanizmu podobnego do metody Ruby times. Ale można uniknąć mutacji używając rekurencji:

let times = (i, cb, l = i) => {
  if (i === 0) return;

  cb(l - i);
  times(i - 1, cb, l);
}

times(5, i => doStuff(i));

Demo: http://jsbin.com/koyecovano/1/edit?js, console

W paradygmacie funkcjonalnym repeat jest zwykle nieskończoną funkcją rekurencyjną. Aby go użyć, potrzebujemy albo leniwej oceny, albo kontynuowania stylu przechodzenia.

Leniwe powtarzanie funkcji

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

Używam thunk (funkcji bez argumentów) do osiągnięcia leniwej oceny w Javascript.

Powtórzenie funkcji z kontynuacją stylu przejścia

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

Podsumowanie

Oddzielając powtórzenie (repeat) od warunku zakończenia (take) uzyskujemy elastyczność-rozdzielenie trosk aż do jego gorzkiego końca: d

Jeśli chcesz skorzystać z biblioteki, jest też lodash _.times lub podkreślenie _.times:

_.times(x, i => {
   return doStuff(i)
})

Zwróć uwagę, że zwraca tablicę wyników, więc jest bardziej podobny do tego ruby:

x.times.map { |i|
  doStuff(i)
}

Adresowanie aspektu funkcjonalnego:

function times(n, f) {
    var _f = function (f) {
        var i;
        for (i = 0; i < n; i++) {
            f(i);
        }
    };
    return typeof f === 'function' && _f(f) || _f;
}
times(6)(function (v) {
    console.log('in parts: ' + v);
});
times(6, function (v) {
    console.log('complete: ' + v);
});

Generatory? Rekurencja? Dlaczego tak nienawidzisz mutacji? ;-)

Jeśli jest akceptowalny tak długo, jak go "ukrywamy", to po prostu akceptujemy użycie operatora jednoargumentowego i możemy zachować rzeczy proste :

Number.prototype.times = function(f) { let n=0 ; while(this.valueOf() > n) f(n++) }

Tak jak w ruby:

> (3).times(console.log)
0
1
2

Zalety tego rozwiązania

• ]}
• wartość zwracana może być użyta jako suma lub po prostu zignorowana
• prosta wersja es6, również link do Wersja maszynopisu kodu

Wady - Mutacja. Bycie wewnętrznym tylko mnie to nie obchodzi, może inni też nie.

Przykłady i Kod

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
}

TypeScipt wersja
https://codepen.io/whitneyland/pen/aVjaaE?editors=0011