зробити <щось> N разів (декларативний синтаксис)

Question 1

Чи є спосіб у Javascript легко написати щось подібне:

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

Будь-яка бібліотека, яка може підтримувати подібний синтаксис, можливо?

Оновлення: для уточнення - я хотів би, something()щоб мене викликали 1,2 та 3 рази відповідно для кожної ітерації елемента масиву

Question 2

Ця відповідь заснована на 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

(раз, потім двічі, потім 3 рази)

Question 3

Просто використовуйте цикл:

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

Question 4

Можлива альтернатива 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 }`)
  });
});

Оновлення:

Взято з fill-arrays-with-undefined

Здається, це більш оптимізований спосіб створення початкового масиву, я також оновив його, щоб використовувати другу функцію відображення параметрів, запропоновану @ felix-eve.

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

Question 5

Оскільки ви згадали про підкреслення:

Припустимо, fце функція, яку ви хочете викликати:

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

зробить трюк. Наприклад, за допомогою f = function (x) { console.log(x); }, ви отримаєте на своїй консолі: 0 0 1 0 1 2

Question 6

З лодашем :

_.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встановлення

Question 7

Створіть масив, і `fill`всі елементи з `undefined`таким `map`методом можуть працювати:

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)

Розгорніть фрагмент

Question 8

Ви також можете зробити те ж саме з деструктуризацією наступним чином

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

або якщо вам потрібен індекс

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

Question 9

Якщо ви не можете використовувати 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;

Question 10

Існує фантастична бібліотека Ramda, яка схожа на Underscore та Lodash, але є потужнішою.

const R = require('ramda');

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

Рамда містить безліч корисних функцій. Див. Документацію Ramda

Question 11

Ви можете використовувати довжину масиву, щоб виконати кількість разів вашого завдання.

var arr = [1,2,3];

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

або

 var arr = [1,2,3];

 do
 {


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

Question 12

ви можете використовувати

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/

Question 13

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

Question 14

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

Question 15

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

Question 16

Просто використовуйте вкладений цикл (можливо, укладений у функцію)

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

Question 17

Ці відповіді хороші та якісні, а 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
});

Ці функції "часу" не дуже корисні для більшості програмних кодів, але мають бути корисними для тестування.

Question 18

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

loop(something, 3)

Question 19

Дана функція 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();

(хоча використання _як сміттєвої змінної, ймовірно, призведе до зменшення чи підкреслення, якщо ви використовуєте її)

Question 20

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

Question 21

Використання Array.fromта .forEach.

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

Розгорніть фрагмент

Question 22

Припускаючи, що ми можемо використовувати якийсь синтаксис ES6, як оператор поширення, ми хочемо зробити щось стільки разів, скільки буде сума всіх чисел у колекції.

У цьому випадку, якщо times дорівнює [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

Цей пост повинен бути корисним, якщо логіка побудови та розповсюдження масиву не очевидна.

Question 23

Впровадження 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 з деякими прикладами тут

Цей пост реалізує рішення, опубліковані: Andreas Bergström , vinyll , Ozay Duman , & SeregPie

зробити <щось> N разів (декларативний синтаксис)

Настав 2017 рік, ви можете використовувати ES6:

або в старому доброму ES5:

Оновлення:

Створіть масив, і fillвсі елементи з undefinedтаким mapметодом можуть працювати:

Використання олдскульного (зворотного) циклу:

РЕДАГУВАТИ

Array.from (ES6)

Створіть масив, і `fill`всі елементи з `undefined`таким `map`методом можуть працювати: