tun N mal (deklarative Syntax)

Lesezeit: 4 Minuten

Benutzer-Avatar
BreakPhreak

Gibt es eine Möglichkeit in Javascript so etwas einfach zu schreiben:

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

Irgendeine Bibliothek, die vielleicht eine ähnliche Syntax unterstützt?

Aktualisieren: zu klären – ich möchte something() 1, 2 bzw. 3 Mal für jede Array-Element-Iteration aufgerufen werden

  • Ich würde sagen, es gibt kein solches Feature in JS, und es ist eines der Top 5 fehlenden Features. Es ist vor allem zum Testen von Software sehr nützlich.

    – Alexander Mills

    18. Januar 2017 um 20:01 Uhr

Benutzer-Avatar
Ahren

Verwenden Sie einfach eine for Schleife:

var times = 10;

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

  • Danke! Ich möchte von einer deklarativen Syntax profitieren (genau wie Jasmine usw.)

    – BreakPhreak

    12. Juni 2012 um 9:28 Uhr

  • Richtig, aber eine funktionale for-Schleife deklarative Syntax wäre auch viel besser

    – Alexander Mills

    18. Januar 2017 um 19:59 Uhr


  • Ja, bitte, ich habe es satt, grundlos zu deklarativem Scheiß aufgezwungen zu werden. Es ist ein großartiges Werkzeug, das Sie verwenden können, wenn Sie es brauchen, aber ein Werkzeug, kein heiliges Mandat.

    – Mihai

    11. November 2021 um 10:50 Uhr

  • Oder verwenden Sie eine while(times--) wenn Sie es in weniger Tastenanschlägen wollen!

    – Positivität

    20. Januar um 17:07 Uhr

Benutzer-Avatar
nverba

Mögliche ES6-Alternative.

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

Und wenn Sie möchten, dass es “jeweils 1, 2 und 3 Mal aufgerufen wird”.

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

Aktualisieren:

Genommen von füllen-arrays-mit-undefiniert

Dies scheint eine optimiertere Methode zum Erstellen des anfänglichen Arrays zu sein. Ich habe dies auch aktualisiert, um die zweite von @felix-eve vorgeschlagene Parameterzuordnungsfunktion zu verwenden.

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

  • Ich sollte dies einschränken, indem ich sage, dass dies in Ordnung ist, wenn Sie nur schnell etwas skripten, aber die Leistung ist schrecklich, also verwenden Sie es wahrscheinlich überhaupt nicht für intensive Rekursion oder in der Produktion.

    – nverba

    21. Januar 2017 um 9:44 Uhr

  • Wenn Sie sich für ES6 entscheiden, können Sie map() anstelle von forEach() verwenden

    – AndyFord

    22. Februar 2017 um 12:11 Uhr

  • Wenn Knappheit das Ziel ist (und eigentlich, auch wenn dies nicht der Fall ist), übergeben Sie die Funktion, anstatt sie aufzurufen: Array.from(Array(3)).forEach(something)

    – kvsm

    9. Juli 2018 um 0:39 Uhr

  • Funktioniert auch mit Reaction-Expression-Rendering.

    – Josh Sharkey

    8. Dezember 2018 um 21:38 Uhr

  • Array.from() hat einen optionalen zweiten Parameter mapFn, wodurch Sie eine Zuordnungsfunktion für jedes Element des Arrays ausführen können, sodass forEach nicht verwendet werden muss. Sie können einfach Folgendes tun: Array.from({length: 3}, () => somthing() )

    – Felix Eva

    22. November 2019 um 9:42 Uhr


Benutzer-Avatar
Vinyll

Diese Antwort basiert auf Array.forEachohne Bibliothek, nur nativ Vanille.

Um im Grunde anzurufen something() 3 mal verwenden:

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

unter Berücksichtigung folgender Funktion:

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

Die Ausgabe wird sein:

something
something
something

Um diese Fragen zu vervollständigen, finden Sie hier eine Möglichkeit, einen Anruf zu tätigen something() Jeweils 1, 2 und 3 Mal:

Es ist 2017, Sie können ES6 verwenden:

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

oder im guten alten ES5:

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

In beiden Fällen wird die Ausgabe sein

Die Ausgabe wird sein:

something

something
something

something
something
something

(einmal, dann zweimal, dann 3 mal)

  • Das ist falsch, weil es diesen Teil der Frage nicht erfüllt: ‘Ich möchte, dass etwas() 1, 2 und 3 Mal aufgerufen wird’. Verwenden Sie diesen Code something nur 3 mal angerufen wird, sollte es 6 mal angerufen werden.

    – Ian Newson

    31. August 2016 um 11:45 Uhr

  • Dann denke ich, dass es als ausgewählt wurde beste Antwort da es ein guter sauberer Start sein kann.

    – Vinyll

    20. Januar 2017 um 23:33 Uhr

  • Könntest du auch verwenden [...Array(i)] oder Array(i).fill()abhängig von Ihren Anforderungen an die tatsächlichen Indizes.

    – Guido Boumann

    15. Februar 2018 um 11:06 Uhr

  • Wenn Sie an den übergebenen Argumenten nicht interessiert sind, verwenden Sie .forEach(something)

    – kvsm

    9. Juli 2018 um 0:44 Uhr

Benutzer-Avatar
vsync

Der einfachste Weg ist per Destrukturieren des Arrays,

was automatisch setzt undefined für jeden Artikel, wenn der Wert des Artikels nicht festgelegt wurde:

[...Array(5)].map((item, i) => console.log(item, i))

Alternativ erstellen Sie ein Array und fill alle Artikel mit undefined vor Gebrauch map:

👉 Lesen Sie den detaillierten Grund warum map überspringt nie definierte Array-Elemente

⚠️ Array.fill hat kein IE Unterstützung

Array(5).fill().map((item, i) => console.log(item, i))

Wenn Sie das oben genannte mehr machen möchten “deklarativ”meine derzeit meinungsbasierte Lösung wäre:

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

iterate(3)(console.log)

Verwenden der (umgekehrten) Schleife der alten Schule:

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

Oder als Deklaration “während”:

const run = (cb, ...args) => count => { while(count--) cb(...args) }

// executes the callback with whatever arguments, 3 times
run(console.log, 1,2,3)(3)

Benutzer-Avatar
Tho

Mit Lodash:

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

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

Oder wenn Sie möchten mache etwas N mal:

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

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

Benutzer-Avatar
ggozad

Da Sie den Unterstrich erwähnen:

Vorausgesetzt f ist die Funktion, die Sie aufrufen möchten:

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

wird den Trick machen. Zum Beispiel mit f = function (x) { console.log(x); }erhalten Sie auf Ihrer Konsole:
0 0 1 0 1 2

Sie können dasselbe auch mit der Destrukturierung wie folgt tun

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

oder wenn Sie einen Index benötigen

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

1257210cookie-checktun N mal (deklarative Syntax)

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy