Is there a mechanism to loop x times in ES6 ECMAScript 6 without mutable variables

Question

The typical way to loop x times in JavaScript is   for  var i   0  i  lt  x  i      doStuff i     But I don t want to use the    operator or have any mutable variables at all  So is there a way  in ES6  to loop x times another way  I love Ruby s mechanism   x times do  i    do stuff i  end   Anything similar in JavaScript ES6  I could kind of cheat and make my own generator   function  times x      for  var i   0  i  lt  x  i        yield i     for  var i of times 5       console log i       Of course I m still using i    At least it s out of sight     but I m hoping there s a better mechanism in ES6

User · Answer

Generators  Recursion  Why so much hatin  on mutatin    -   If it is acceptable as long as we  hide  it  then just accept the use of a unary operator and we can keep things simple   Number prototype times   function f    let n 0   while this valueOf    gt  n  f n        Just like in ruby    gt   3  times console log  0 1 2

User · Answer

Using the ES2015 Spread operator      Array n   map   const res       Array 10   map     i    gt      return i   10          as a one liner const res       Array 10   map     i    gt  i   10    Or if you don t need the result      Array 10   forEach     i    gt      console log i           as a one liner     Array 10   forEach     i    gt  console log i     Or using the ES2015 Array from operator  Array from      const res   Array from Array 10   map     i    gt      return i   10          as a one liner const res   Array from Array 10   map     i    gt  i   10     Note that if you just need a string repeated you can use  String prototype repeat  console log  quot 0 quot  repeat 10      0000000000

User · Answer

for  let i of Array 100  keys          console log i

User · Answer

const times   4  new Array times  fill   map      gt  console log  test       This snippet will console log test 4 times

User · Answer

Afaik  there is no mechanism in ES6 similar to Ruby s times method  But you can avoid mutation by using recursion   let times    i  cb  l   i    gt      if  i     0  return     cb l - i     times i - 1  cb  l      times 5  i   gt  doStuff i      Demo  http   jsbin com koyecovano 1 edit js console

User · Answer

Array 100  fill   map    i   gt  console log i       This version satisifies the OP s requirement for immutability  Also consider using reduce instead of map  depending on your use case   This is also an option if you don t mind a little mutation in your prototype   Number prototype times   function f       return Array this valueOf    fill   map    i   gt f i         Now we can do this    3  times i  gt console log i        1 to arcseldon for the  fill suggestion

User · Answer

Answer  09 December 2015   Personally  I found the accepted answer both concise  good  and terse  bad   Appreciate this statement might be subjective  so please read this answer and see if you agree or disagree  The example given in the question was something like Ruby s   x times do  i    do stuff i  end   Expressing this in JS using below would permit   times x  doStuff i      Here is the code   let times    n    gt      return  f    gt        Array n  fill   map     i    gt  f i              That s it   Simple example usage   let cheer        gt  console log  Hip hip hooray      times 3  cheer      Hip hip hooray    Hip hip hooray    Hip hip hooray    Alternatively  following the examples of the accepted answer   let doStuff    i    gt  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    Side note - Defining a range function  A similar   related question  that uses fundamentally very similar code constructs  might be is there a convenient Range function in  core  JavaScript  something similar to underscore s range function   Create an array with n numbers  starting from x  Underscore    range x  x   n    ES2015  Couple of alternatives   Array n  fill   map     i    gt  x   i   Array from Array n       i    gt  x   i    Demo using n   10  x   1    gt  Array 10  fill   map     i    gt  i   1       1  2  3  4  5  6  7  8  9  10     gt  Array from Array 10       i    gt  i   1       1  2  3  4  5  6  7  8  9  10     In a quick test I ran  with each of the above running a million times each using our solution and doStuff function  the former approach  Array n  fill    proved slightly faster

User · Answer

If you re willing to use a library  there s also lodash   times or underscore   times     times x  i   gt       return doStuff i       Note this returns an array of the results  so it s really more like this ruby   x times map    i    doStuff i

User · Answer

I am late to the party  but since this question turns up often in search results  I would just like to add a solution that I consider to be the best in terms of readability while not being long  which is ideal for any codebase IMO   It mutates  but I d make that tradeoff for KISS principles   let times   5 while  times--       console log times     logs 4  3  2  1  0

User · Answer

I think the best solution is to use let  for  let i 0  i lt 100  i         That will create a new  mutable  i variable for each body evaluation and assures that the i is only changed in the increment expression in that loop syntax  not from anywhere else   I could kind of cheat and make my own generator  At least i   is out of sight     That should be enough  imo  Even in pure languages  all operations  or at least  their interpreters  are built from primitives that use mutation  As long as it is properly scoped  I cannot see what is wrong with that  You should be fine with function  times n      for  let i   0  i  lt  n  i        yield i    for  const i of times 5       console log i       But I don t want to use the    operator or have any mutable variables at all   Then your only choice is to use recursion  You can define that generator function without a mutable i as well  function  range i  n      if  i  gt   n  return    yield i    return yield  range i 1  n     times    n    gt  range 0  n    But that seems overkill to me and might have performance problems  as tail call elimination is not available for return yield

User · Answer

The simplest way I can think of for creating list array within range Array from Array max-min 1       index    gt  index min

User · Answer

addressing the functional aspect   function times n  f        var  f   function  f            var i          for  i   0  i  lt  n  i                  f i                        return typeof f      function   amp  amp   f f      f    times 6  function  v        console log  in parts      v       times 6  function  v        console log  complete      v

User · Answer

In the functional paradigm repeat is usually an infinite recursive function  To use it we need either lazy evaluation or continuation passing style   Lazy evaluated function repetition   x000D   x000D  const repeat   f   gt  x   gt   x       gt  repeat f   f x     x000D  const take   n   gt    x  f     gt  n     0   x   take n - 1   f     x000D   x000D  console log  x000D    take 8   repeat x   gt  x   2   1      256 x000D     x000D   x000D   x000D    I use a thunk  a function without arguments  to achieve lazy evaluation in Javascript   Function repetition with continuation passing style   x000D   x000D  const repeat   f   gt  x   gt   x  k   gt  k repeat f   f x      x000D  const take   n   gt    x  k     gt  n     0   x   k take n - 1    x000D   x000D  console log  x000D    take 8   repeat x   gt  x   2   1      256 x000D     x000D   x000D   x000D    CPS is a little scary at first  However  it always follows the same pattern  The last argument is the continuation  a function   which invokes its own body  k   gt  k       Please note that CPS turns the application inside out  i e  take 8   repeat     becomes k take 8         where k is the partially applied repeat   Conclusion  By separating the repetition  repeat  from the termination condition  take  we gain flexibility - separation of concerns up to its bitter end  D

User · Answer

I wrapped  Tieme s answer with a helper function   In TypeScript   export const mapN    lt T   any   gt  count  number  fn      args  any      gt  T   T     gt      Array count   map     i    gt  fn      Now you can run   const arr  string     mapN 3       gt   something      returns   something    something    something

User · Answer

I think it is pretty simple       Array 3  keys      or  Array 3  fill

User · Answer

Not something I would teach  or ever use in my code   but here s a codegolf-worthy solution without mutating a variable  no need for ES6   Array apply null   length  10   forEach function    i       doStuff i        More of an interesting proof-of-concept thing than a useful answer  really

User · Answer

I am just going to put this here  If you are looking for a compact function  without using Arrays and you have no issue with mutability immutability    var g  x  gt    your code goes here  x-1 gt 0 g x-1  null

User · Answer

Advantages of this solution   Simplest to read   use  imo  Return value can be used as a sum  or just ignored Plain es6 version  also link to TypeScript version of the code   Disadvantages  - Mutation  Being internal only I don t care  maybe some others will not either   Examples and Code    times 5  3                           15     3 3 3 3 3   times 5   i    gt  Math pow 2 i         31     1 2 4 8 16   times 5    lt br  gt                        lt br  gt  lt br  gt  lt br  gt  lt br  gt  lt br  gt   times 3   i  count    gt                name 0   name 1   name 2      let n    name     i           if  i  lt  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  lt  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 version https   codepen io whitneyland pen aVjaaE editors 0011

User · Answer

I made this  function repeat func  times        for  var i 0  i lt times  i              func i            Usage  repeat function i        console log  quot Hello  World  -  quot  i      5      Returns  Hello  World  - 0 Hello  World  - 1 Hello  World  - 2 Hello  World  - 3 Hello  World  - 4     The i variable returns the amount of times it has looped - useful if you need to preload an x amount of images

User · Answer

OK   The code below is written using ES6 syntaxes but could just as easily be written in ES5 or even less  ES6 is not a requirement to create a  mechanism to loop x times     If you don t need the iterator in the callback  this is the most simple implementation   x000D   x000D  const times   x   gt  f   gt    x000D    if  x  gt  0    x000D      f   x000D      times  x - 1   f  x000D      x000D    x000D   x000D     use it x000D  times  3        gt  console log  hi    x000D   x000D     or define intermediate functions for reuse x000D  let twice   times  2  x000D   x000D     twice the power   x000D  twice       gt  console log  double vision    x000D   x000D   x000D    If you do need the iterator  you can use a named inner function with a counter parameter to iterate for you   x000D   x000D  const times   n   gt  f   gt    x000D    let iter   i   gt    x000D      if  i     n  return x000D      f  i  x000D      iter  i   1  x000D      x000D    return iter  0  x000D    x000D   x000D  times  3   i   gt  console log i   hi    x000D   x000D   x000D         Stop reading here if you don t like learning more things       But something should feel off about those      single branch if statements are ugly  mdash  what happens on the other branch nbsp   multiple statements expressions in the function bodies  mdash  are procedure concerns being mixed nbsp   implicitly returned undefined  mdash  indication of impure  side-effecting function    Isn t there a better way     There is  Let s first revisit our initial implementation     times    Int -   void -  void  -  void const times   x    f        if  x   0        f                    has to be side-effecting function     times  x - 1   f         Sure  it s simple  but notice how we just call f   and don t do anything with it  This really limits the type of function we can repeat multiple times  Even if we have the iterator available  f i  isn t much more versatile   What if we start with a better kind of function repetition procedure   Maybe something that makes better use of input and output   Generic function repetition   x000D   x000D     repeat    forall a  Int - gt   a - gt  a  - gt  a - gt  a x000D  const repeat   n   gt  f   gt  x   gt    x000D    if  n  gt  0  x000D      return repeat  n - 1   f   f  x   x000D    else x000D      return x x000D    x000D   x000D     power    Int - gt  Int - gt  Int x000D  const power   base   gt  exp   gt    x000D       repeat  lt exp gt  times   lt base gt     lt x gt   starting with 1 x000D    return repeat  exp   x   gt  base   x   1  x000D    x000D   x000D  console log power  2   8   x000D       gt  256 x000D   x000D   x000D    Above  we defined a generic repeat function which takes an additional input which is used to start the repeated application of a single function      repeat 3 times  the function f  starting with x     var result   repeat  3   f   x      is the same as     var result   f f f x        Implementing times with repeat  Well this is easy now  almost all of the work is already done    x000D   x000D     repeat    forall a  Int - gt   a - gt  a  - gt  a - gt  a x000D  const repeat   n   gt  f   gt  x   gt    x000D    if  n  gt  0  x000D      return repeat  n - 1   f   f  x   x000D    else x000D      return x x000D    x000D   x000D     times    Int - gt   Int - gt  Int  - gt  Int  x000D  const times   n  gt  f  gt  x000D    repeat  n   i   gt   f i   i   1    0  x000D   x000D     use it x000D  times  3   i   gt  console log i   hi    x000D   x000D   x000D    Since our function takes i as an input and returns i   1  this effectively works as our iterator which we pass to f each time   We ve fixed our bullet list of issues too   No more ugly single branch if statements Single-expression bodies indicate nicely separated concerns No more useless  implicitly returned undefined     JavaScript comma operator  the  In case you re having trouble seeing how the last example is working  it depends on your awareness of one of JavaScript s oldest battle axes  the comma operator     in short  it evaluates expressions from left to right and returns the value of the last evaluated expression   expr1    a  expr2    b  expr3    c     c   In our above example  I m using   i   gt   f i   i   1     which is just a succinct way of writing   i   gt    f i   return i   1        Tail Call Optimisation  As sexy as the recursive implementations are  at this point it would be irresponsible for me to recommend them given that no JavaScript VM I can think of supports proper tail call elimination     babel used to transpile it  but it s been in  broken  will reimplement  status for well over a year   repeat  1e6   someFunc   x       gt  RangeError  Maximum call stack size exceeded   As such  we should revisit our implementation of repeat to make it stack-safe   The code below does use mutable variables n and x but note that all mutations are localized to the repeat function     no state changes  mutations  are visible from outside of the function   x000D   x000D     repeat    Int - gt   a - gt  a  - gt   a - gt  a  x000D  const repeat   n   gt  f   gt  x   gt  x000D      x000D      let m   0  acc   x x000D      while  m  lt  n  x000D         m   m   1  acc   f  acc   x000D      return acc x000D      x000D   x000D     inc    Int - gt  Int x000D  const inc   x   gt  x000D    x   1 x000D   x000D  console log  repeat  1e8   inc   0   x000D     100000000 x000D   x000D   x000D    This is going to have a lot of you saying  but that s not functional        I know  just relax  We can implement a Clojure-style loop recur interface for constant-space looping using pure expressions  none of that while stuff   Here we abstract while away with our loop function     it looks for a special recur type to keep the loop running  When a non-recur type is encountered  the loop is finished and the result of the computation is returned   x000D   x000D  const recur       args    gt  x000D       type  recur  args    x000D     x000D  const loop   f   gt  x000D      x000D      let acc   f    x000D      while  acc type     recur  x000D        acc   f     acc args  x000D      return acc x000D      x000D   x000D  const repeat    n   gt  f   gt  x   gt  x000D    loop   n    n  acc   x    gt  x000D      n     0 x000D          acc x000D          recur  n - 1  f  acc    x000D         x000D  const inc   x   gt  x000D    x   1 x000D   x000D  const fibonacci    n   gt  x000D    loop   n    n  a   0  b   1    gt  x000D      n     0 x000D          a x000D          recur  n - 1  b  a   b   x000D         x000D  console log  repeat  1e7   inc   0      10000000 x000D  console log  fibonacci  100             354224848179262000000 x000D   x000D   x000D

User · Answer

Here is another good alternative   Array from   length  3   map         Preferably  as  Dave Morse pointed out in the comments  you can also get rid of the map call  by using the second parameter of the Array from function like so   Array from   length  3         gt

[javascript] Is there a mechanism to loop x times in ES6 (ECMAScript 6) without mutable variables?

Examples related to javascript

Examples related to generator

Examples related to ecmascript-6

Examples related to ecmascript-harmony