CODEWITHSUNDEEP
javascriptfunctional-programming
Randomblue
Randomblue

Reputation: 116283

Functional approach to basic array construction

This is my code, acting upon myArray:

var myArray = [];
var i;

for(i = 0; i < 20; i += 1) {
   myArray.push(Math.random());
}

Is there a functional equivalent of the above that does without the dummy variable i?

Favorite answers:

Upvotes: 4

Views: 475

Answers (5)

KooiInc
KooiInc

Reputation: 122906

You could try:

var myArray = String(Array(20)).split(',')
               .map( () => Math.random() );

Or extend the Array prototype with something like:

Array.prototype.vector = function(n,fn){
  fn = fn || function(){return '0';};
  while (n--){
    this.push(fn());
  }
  return this;
}
// usage
var myArray = [].vector(20, () => Math.random());

Or try something funny:

var myArray = function a(n,fn){
  return n ? a(n-1,fn).concat(fn()) : [];
}(20, () => Math.random())

Or use Array.from (ES>=2015)

Array.from({length: 20}).map(() => Math.random())

Upvotes: 0

Bergi
Bergi

Reputation: 664548

With JavaScript 1.7, you can use Array comprehensions for this task:

var myArray = [Math.random() for each (i in range(0, 20))];

However, with ES5.1 you can just use the Array constructor to generate an array of arbitrary length, and then map it to random numbers. Only drawback is that map() does not work with uninitialised values, so I first generate an Array of empty strings by using join and split:

var myArray = new Array(20).join(" ").split(" ").map(Math.random);

Ugly, but short. A maybe better (but less understandable) idea from Creating range in JavaScript - strange syntax:

var myArray = Array.apply(null, {length: 20}).map(Math.random);

Starting with @FelixKlings comment, one could also use this one-liner without the i loop variable:

for (var myArray=[]; myArray.push(Math.random()) < 20;);
// much better:
for (var myArray=[]; myArray.length < 20;) myArray.push(Math.random());

Upvotes: 3

blueiur
blueiur

Reputation: 1507

how about this?

it's functionale style and it's very concise.

var makeRandomArray = function(n){
    if (n == 0) return [];
    return [Math.random()].concat(makeRandomArray(n-1));
};

console.log(makeRandomArray(20))

http://jsfiddle.net/YQqGP/

​

Upvotes: 1

Aadit M Shah
Aadit M Shah

Reputation: 74204

Are you looking for something as follows:

function makeArray(length, def) {
    var array = [];
    var funct = typeof def === "function";
    while (array.push(funct ? def() : def) < length);
    return array;
}

Then you can create arrays as follows:

var array = makeArray(100); // an array of 100 elements
var zero = makeArray(5, 0); // an array of 5 `0`s

In your case you may do something like:

var myArray = makeArray(20, Math.random);

See the following fiddle: http://jsfiddle.net/WxtkF/3/

Upvotes: 1

Aadaam
Aadaam

Reputation: 3739

Not in ES5, there's no real functional equivalent to it, as you have to have something which has an amount of 20 to apply map to...

var my20ElementArray = [0,1,2,3,4,5,6,7,8,9,10];
var myArray = my20ElementArray.map(Math.random);

You could create an xrange-like function what is in Python but that would just hide this "unused" variable inside a function.

Upvotes: 4

Related Questions