什么都不做的数组方法

Question

I like functional programming, it keeps my code, especially scopes, cleaner.

I found myself having a pretty heavy Array manipulation in my code, like this:

this.myArray = someArray
    .slice(0, n)
    .map(someFunction)
    // more manipulation;

if (condition) {
    this.myArray = this.myArray.reverse();
}

this.myArray = this.myArray
    .reduce(anotherFunction, [])
    // even more manipulation

Is there some built-in way to join the if to my functional chain? Something like:

this.myArray = someArray
    .slice(0, n)
    .map(someFunction)
    // ... more manipulation
    [condition ? 'reverse' : 'void']()
    .reduce(anotherFunction, [])
    // ... even more manipulation

The void() method doesn't exist. Is there an alternative? Is it popular approach to merge multiple calls to a single chain, even if that means calling methods that do nothing?

I know I can add my own method to Array:

Array.prototype.void = function () {
    return this;
}

But that's not the point. Is there any standard/built-in way to achieve the same effect?

Answer 1

As neutral function, you could take

• Array#concat , which returns a new array with old items, or

• Array#slice , which returns as well a new array.

Answer 2

Is it popular approach to merge multiple calls to a single chain, even if that means calling methods that do nothing?

No. The usual approach is to split the chain, similar to how you wrote it in your first snippet, when there is an optional step. You wouldn't however repeatedly assign to this.myArray , you would use constant temporary variables:

const array1 = someArray.slice(0, n).map(someFunction) // more manipulation;
const array2 = condition ? array1.reverse() : array1;
this.myArray = array2.reduce(anotherFunction, []) // even more manipulation

That said, in functional programming that uses functions, not methods, you sometimes do find the approach of having a configurable chain. They don't need a void method on the object, they just use the identity function.

Example in Haskell:

let maybeReverse = if condition then reverse else identity
let myArray = fold anotherFunction [] $ maybeReverse $ map someFunction $ take n someArray

Example in JavaScript (where you don't have as many useful builtins and need to write them yourself):

const fold = (fn, acc, arr) => arr.reduce(fn, acc);
const reverse = arr => arr.reverse(); // add .slice() to make pure
const identity = x => x;
const map = (fn, arr) => arr.map(fn);
const take = (n, arr) => arr.slice(0, n);

const maybeReverse = condition ? reverse : identity;
const myArray = fold(anotherFunction, [], maybeReverse(map(someFunction, take(n, someArray)))));

---

Btw, in your particular example I wouldn't use reverse at all, but rather conditionally switch between reduce and reduceRight :-)

Answer 3

Another option is to switch reduce() with reduceRight() which wouldn't add an extra step at all for the case shown

this.myArray = someArray
    .slice(0, n)
    .map(someFunction)   
    [condition ? 'reduce' : 'reduceRight'](anotherFunction, [])