JavaScript函数式编程之管道分支，消除if/else的一种方式

以下代码会用到函数组合函数compose，只要知道compose是干什么的就足够了，如果好奇具体的实现，可以看《JavaScript函数式编程之函数组合函数compose和pipe的实现》

管道是函数式编程中经常使用的，很多时候我们需要按照条件判断进行组合函数的选择，简单的说就是从原来的一条管道变成两条管道，根据判断选择进入哪一条。

这里的关键在于，我们如何判断上一个函数的返回值应该进入哪一条管道？

let step1 = x => x ? 1 : 2;
let step2 = x => x === 1 ? 3 : 4;
let step3 = x => x === 3 ? 5 : 6;
let getResult = compose(step3, step2, step1)
let result = getResult(1);

这是最直接的方法，每一步根据返回值单独判断，如果step1的返回值发生了变化，下一步的判断也需要跟着修改，这种写法显然不好。那我们能不能在返回值的基础上加上一个标识，专门用来做判断？我们很自然的就会想到对象。

let step1 = x => {
  if (x) {
    return {
      value: 1,
      identity: 'channelOne'
    }
  } else {
    return {
      value: 2,
      identity: 'channelTwo'
    }
  }
}
let step2 = x => {
  if (x.identity === 'channelOne') {
    return x.value = 3;
  } else {
    return x.value = 4;
  }
}
let step3 = x => {
  if (x.identity === 'channelOne') {
    return x.value = 5;
  } else {
    return x.value = 6;
  }    
}
let getResult = compose(step3, step2, step1);
let result = getResult(1);

是不是好了很多？不过这依然要继续改进。当我们需要使用forin等方式遍历对象时，identity会被遍历出来，一般情况下我们都希望它不会被遍历，那就还需要把这个属性定义为不可枚举的。
修改step1并简化代码：

let step1 = x => {
  if (x) {
    let obj = {value: 1};
    Object.defineProperty(obj, 'identity', {
      enumerable: false,
      value: 'channelOne'
    });
    return obj;
  } else {
    let obj = {value: 2};
    Object.defineProperty(obj, 'identity', {
      enumerable: false,
      value: 'channelTwo'
    });
    return obj;
  }
}
let selectChannel = (fn1, fn2) => val => val.identity === 'channelOne' ? fn1(val) : fn2(val);
let getResult = compose(
  selectChannel(
    x => Object.defineProperty(x, 'value', {value: 5}),
    x => Object.defineProperty(x, 'value', {value: 6})
  ),
  selectChannel(
    x => Object.defineProperty(x, 'value', {value: 3}),
    x => Object.defineProperty(x, 'value', {value: 4})
  ),
  step1
);
let result = getResult(1);

在selectChannel中，函数会根据传进来的对象的标识选择执行。至此，功能基本上实现了，可依然不够好，代码不够简洁优雅，重用也可以继续改进。

用构造函数做标识

let channelOne = function(x) { this.value = x; };
channelOne.of = x => new channelOne(x);
let channelTwo = function(x) { this.value = x; };
channelTwo.of = x => new channelTwo(x);
let step1 = x => x ? channelOne.of(1) : channelTwo.of(2);
let selectChannel = (fn1, fn2) => val => val.constructor === channelOne ? fn1(val) : fn2(val);
let getResult = compose(
  selectChannel(x => channelOne.of(5), x => channelTwo.of(6)),
  selectChannel(x => channelOne.of(3), x => channelTwo.of(4)),
  step1
);
let result = getResult(1);

太棒了！
看到这里，有么有惊喜的发现，if/else不见了？肯定会有人觉得我是一个换汤不换药的奸商。虽然if/else不见了，可是我用了三元运算符，这在本质上有什么区别？
答案是，没区别，他们都是条件判断，这是不可避免的。
我们不妨暂时把关注的焦点放在三元运算符与if/else的区别上面来。我们什么时候会使用三元运算符？是条件判断很简单的时候，简单到只需要一个表达式，而不是复杂的操作。虽然三元运算符也可以用逗号隔开表达式从而进行多个操作，可我们这个时候更愿意使用if/else。
说到这里就已经很明显了，这种构造函数做标识的方式，把复杂的条件判断分解了，分解到在做判断的时候只需要选择方向，相关的操作可以扔到后面。

在《JavaScript函数式编程中的错误处理，强壮代码》文章中所用的思路与本篇一样，只不过在《JavaScript函数式编程中的错误处理，强壮代码》中可以认为是以null和undefined作为标识，而本篇单独创造了标识。本篇中的方法更加的通用，因为null和undefined也可能是我们需要使用的值。

使用本篇的方法重写《JavaScript函数式编程中的错误处理，强壮代码》中的代码

let channelError = function(x) { this.value = x; };
channelError.of = x => new channelError(x);
let channelSuccess = function(x) { this.value = x; };
channelSuccess.of = x => new channelSuccess(x);
let security= fn => val => val.constructor === channelError? val : fn(val);
let validate1 = x => x ? channelSuccess.of(x) : channelError.of('validate1 is not passed!');
let validate2 = x => x.value ? x : channelError.of('validate2 is not passed!');
let handleError = x => {
  if (x.constructor === channelError) alert(x.value);
};
let postData = () => axios.post(...);
let getResult = compose(
  handleError,
  security(postData),
  security(validate2),
  security(validate1)
);

参考资料：

JS函数式编程指南

我在github https://github.com/zhuanyongx...