web-dev-qa-db-de.com

mach etwas <N> mal (deklarative Syntax)

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

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

Jede Bibliothek, die möglicherweise eine ähnliche Syntax unterstützt?

Update: zur Klarstellung - Ich möchte, dass something() für jede Elementelement-Iteration 1,2- bzw. 3-mal aufgerufen wird

53
BreakPhreak

Diese Antwort basiert auf Array.forEach, ohne jegliche Bibliothek, nur native Vanilla .

Um grundsätzlich something() dreimal aufzurufen, verwenden Sie:

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

unter Berücksichtigung der folgenden Funktion:

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

Der Outpout wird sein 

something
something
something

Um diese Fragen zu beantworten, rufen Sie something() 1, 2 bzw. 3 mal auf:

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 der Ausgang ausgegeben

Der Outpout wird sein 

something

something
something

something
something
something

(einmal, dann zweimal, dann dreimal)

27
vinyll

Verwenden Sie einfach eine Schleife:

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

Mögliche ES6-Alternative.

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

Und wenn Sie möchten, dass es "1,2- bzw. 3-mal" genannt wird.

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

Aktualisieren:

Aus Abfüll-Arrays-mit-undefined

Dies scheint eine optimierte Methode zum Erstellen des ursprünglichen Arrays zu sein. 

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

Da du Underscore erwähnt hast:

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

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

wird den Trick tun. Mit f = function (x) { console.log(x); } erhalten Sie beispielsweise auf Ihrer Konsole: 0 0 1 0 1 2

19
ggozad

Wir können lodash verwenden, um diese Arbeit auszuführen:

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

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

Oder wenn Sie etwas N-mal tun wollen:

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

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

Referenz dieser Link für lodash Installation

12
Tho

Wenn Sie Underscorejs nicht verwenden können, können Sie es selbst implementieren. Durch das Anhängen neuer Methoden an die Number und String-Prototypen können Sie dies folgendermaßen tun (mit ES6-Pfeilfunktionen):

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

Sie müssen lediglich einen Funktionsausdruck (gleich welchen Namens) erstellen und diesem beliebigen Eigenschaftennamen (auf den Prototypen) zuweisen, auf den Sie als folgenden zugreifen möchten:

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

Erstellen Sie ein Array und fill alle Elemente mit undefined so/ map könnte funktionieren:

Array.fill hat keine IE - Unterstützung

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


Old-School-Reveres-Schleife verwenden:

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

4
vsync
times = function () {
    var length = arguments.length;
    for (var i = 0; i < length ; i++) {
        for (var j = 0; j < arguments[i]; j++) {
            dosomthing();
        }
    }
}

Man kann es so nennen:

times(3,4);
times(1,2,3,4);
times(1,3,5,7,9);
1
XU3352

sie können verwenden

Array.forEach

beispiel:

function logArrayElements(element, index, array) {  
    console.log("a[" + index + "] = " + element);  
}  
[2, 5, 9].forEach(logArrayElements)

oder mit jQuery

$.each([52, 97], function(index, value) { 
  alert(index + ': ' + value); 
});

http://api.jquery.com/jQuery.each/

1
Machu

Es gibt eine fantastische Bibliothek namens Ramda, die Underscore und Lodash ähnelt, aber mächtiger ist. 

const R = require('ramda');

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

Ramda enthält viele nützliche Funktionen. Siehe Ramda-Dokumentation

1
Jan Bodnar
// calls doSomething 42 times
Array( 42 ).join( "x" ).split( "" ).forEach( doSomething );

und 

// creates 42 somethings
var somethings = Array( 42 ).join( "x" ).split( "" ).map( () => buildSomething(); );

oder (über https://stackoverflow.com/a/20066663/275501 )

Array.apply(null, {length: 42}).forEach( doSomething );
1
goofballLogic
var times = [1,2,3];

for(var i = 0; i < times.length;  i++) {
  for(var j = 0; j < times[i];j++) {
     // do something
  }
}

JQuery verwenden .each()

$([1,2,3]).each(function(i, val) {
  for(var j = 0; j < val;j++) {
     // do something
  }
});

OR

var x = [1,2,3];

$(x).each(function(i, val) {
  for(var j = 0; j < val;j++) {
     // do something
  }
});

BEARBEITEN

Mit Pure JS können Sie das wie folgt machen:

var times = [1,2,3];
times.forEach(function(i) {
   // do something
});
1
thecodeparadox

Sie können die Länge des Arrays verwenden, um die Anzahl der Aufgaben Ihrer Task auszuführen.

var arr = [1,2,3];

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

oder

 var arr = [1,2,3];

 do
 {


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

Verwenden Sie einfach eine verschachtelte Schleife (möglicherweise in eine Funktion eingeschlossen)

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

Dann nennen Sie es einfach so:

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

Angenommen, wir können wie der Spread-Operator eine gewisse ES6-Syntax verwenden, so wollen wir etwas so oft wie die Summe aller Zahlen in der Auflistung.

Wenn times gleich [1,2,3] ist, beträgt die Gesamtanzahl der Male 6, d. H. 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

Dieser Beitrag sollte hilfreich sein, wenn die Logik beim Erstellen und Verbreiten eines Arrays nicht offensichtlich ist.

0
IliasT

Diese Antworten sind alle gut und gut und IMO @Andreas ist die beste, aber in JS müssen wir die Dinge oft asynchron erledigen. In diesem Fall hat async Sie behandelt:

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

Diese "Zeiten" -Funktionen sind für die meisten Anwendungscodes sehr nützlich, sollten aber zum Testen nützlich sein.

0
Alexander Mills

Array.from (ES6)

function doSomthing() {
    ...
}

Verwenden Sie es wie folgt:

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

Oder

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

Oder

// array start counting from 1
Array.from({ length }, (v, i) => ++i).forEach(doSomthing);
0
Lior Elrom
const loop (fn, times) => {
  if (!times) { return }
  fn()
  loop(fn, times - 1)
}

loop(something, 3)
0
Goro

Verwenden Sie Array.from und .forEach.

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

0
SeregPie