Cycle function in Javascript

Question

I new to Javascript and I am looking for a cycle function. Here's Clojure's implementation I am trying to find a cycle function that infinitely loops/recurses through values of an array. I was hoping to find something like this in the underscore library, but I could not find anything suitable. Ideally I would like to use something like this:

 _.head(_.cycle([1,2,3]), 100)

This function would return an array of 100 elements:

[1,2,3,1,2,3,1,2,3,1,2,3,...]

Is there a function like this I can use in Javascript? Here's my feable attempt, but I can't seem to get it to work:

arr = [1,2,3,4,5,6,7,8,9];

var cycle = function(arr) {
  arr.forEach(function(d, i) {
    if (d === arr.length)
      return d
      d == 0
    else {return d}
  });
};

cycle(arr);

Answer 1

You could do something like:

var cycle = function(array, count) {
    var output = [];

    for (var i = 0; i < count; i++) {
        output.push(array[i % array.length]);
    }

    return output;
}

Answer 2

An implementation of Clojure's cycle :

function cycle(input) {
    return function (times) {
        var i = 0, output = [];
        while (i < times) {
            output.push(input[i++ % input.length]);
        }
        return output;
    };
}

Usage examples :

var chars = cycle(['a', 'b']);
chars(0) // []
chars(1) // ["a"]
chars(3) // ["a", "b", "a"]
cycle([1, 2])(3) // [1, 2, 1]

An implementation of Clojure's take :

function take(length, input) {
    return typeof input === 'function'
        ? input(length)
        : input.slice(0, length);
}

Usage examples :

take(3, [1, 2, 3, 4])  // [1, 2, 3]
take(3, cycle([1, 2])) // [1, 2, 1]

Both implementations probably do not fit exactly Clojure's versions.

Answer 3

The problem with trying to emulate purely functional in JavaScript is eagerness: JavaScript doesn't have lazy evaluation and hence you can't produce infinite arrays in JavaScript. You need to define a lazy list in JavaScript. This is how I usually do it:

function cons(head, tail) {
    return cont({
        head: head,
        tail: tail
    });
}

function cont(a) {
    return function (k) {
        return k(a);
    };
}

The cons function is similar to the cons function in LISP or the : constructor in Haskell. It takes an element and a list and returns a new list with the element inserted at the beginning of the list. The cont function creates a continuation (really useful for reifying thunks to emulate lazy evaluation).

Creating a list using cons is very simple:

var list = cons(1, cons(2, cons(3, cons(4, cons(5, null)))));

var array = [1, 2, 3, 4, 5];

The above list and array are equivalent. We can create two function to convert arrays to lists and vice-versa:

function toList(array) {
    var list = null, length = array.length;
    while (length) list = cons(array[--length], list);
    return list;
}

function toArray(list) {
    var array = [];

    while (list) {
        list = list(id);
        array = array.concat(list.head);
        list = list.tail;
    }

    return array;
}

function id(x) {
    return x;
}

Now that we have a method of implementing lazy lists in JavaScript let's create the cycle function:

function cycle(list) {
    list = list(id);
    var head = list.head;
    var tail = join(list.tail, cons(head, null));

    return function (k) {
        return k({
            head: head,
            tail: cycle(tail)
        });
    };
}

function join(xs, ys) {
    if (xs) {
        xs = xs(id);
        return cons(xs.head, join(xs.tail, ys));
    } else return ys;
}

Now you can create an infinite list as follows:

var list = cycle(toList([1,2,3]));

Let's create a take function to get the first 100 elements of the list:

function take(n, xs) {
    if (n > 0) {
        xs = xs(id);
        return cons(xs.head, take(n - 1, xs.tail));
    } else return null;
}

We can now easily get an array of 100 elements with [1,2,3] repeating:

var array = toArray(take(100, list));

Let's see if it works as expected: http://jsfiddle.net/TR9Ma/

To summarize, lazy functional programming in JavaScript is not as much fun as it is in purely functional languages like Haskell. However with a little bit of effort you can make it work.

Answer 4

This function should work. You can put the mod operation to good use here.

var cycle = function(input, n) {
    var output = [];
    for (var i = 0; i < n; i++) {
        var j = i % input.length;
        output.push(input[j]);
    }
    return output;
}

Here's a working fiddle: http://jsfiddle.net/K6UhS/1/

Also, I wouldn't introduce a whole library just for this function!

Answer 5

Here is a slightly more compact version:

function cycle(arr, count) {
    for (var i = 0, out = []; i < count; i++) {
        out.push(arr[i % arr.length]);
    }

    return out;
}

And a JSFiddle (outputs the results to the console): http://jsfiddle.net/2F9hY/1/

Basically just loops through count number of times, getting the i % arr.length item and adding it to the array.

Answer 6

The wu library includes a cycle function which does this:

wu.cycle([ 1, 2, 3 ]).take(10).toArray() // [ 1, 2, 3, 1, 2, 3, 1, 2, 3, 1 ]

If you don't need support for iterators/streams/infinite lists, and just want a function that cycles through an array's values, lei-cycle provides a much more lightweight solution:

const Cycle = require('lei-cycle')

let c = Cycle([ 1, 2, 3 ])

console.log(c()) // 1
console.log(c()) // 2
console.log(c()) // 3
console.log(c()) // 1
// ...

Answer 7

function cycle(array) {
    let result = [...array]
    result[Symbol.iterator] = function* () {
        while (true)
            yield* this.values()
    }
    return result
}

Answer 8

class Cycle {
  constructor(array) {
    this.array = array;
  }
  
  next () {
    var x = this.array.shift();
    this.array.push(x);
    return x;
  }
}

const cycle = new Cycle(['a','b','c']);

console.log(cycle.next()); // returns "a"
console.log(cycle.next()); // returns "b"
console.log(cycle.next()); // returns "c"
console.log(cycle.next()); // returns "a"
console.log(cycle.next()); // returns "b"
...