函数式编程对象Maybe

Maybe被用来避免空值判断，将可能为空的值用Maybe容器包裹，目的还是打造一条没有分支可以顺序执行的方法链。

 

假设我们有一串方法：

const getList = R.path(['obj','value']);
const formatProp = R.map(R.evolve({name:R.pipe(R.trim,R.toUpper)}));
const sortList = R.sortBy(R.prop('name'));
组合起来处理一个对象
const getSortListByData = R.compose(
    sortList,
    formatProp,
    getList
);
const result = getSortListByData({
    obj:{
        value:[
            {name:'王1',mobile:'19999999999'},
            {name:'王2',mobile:'19999999999'},
            {name:'王3',mobile:'19999999999'}
        ]
    }
});

 

假使后端传给我们的对象为空或少了value字段,那么该方法会报错，除非在每一个子方法中加入空判断。

我们用Maybe来改写一下--只是将方法的返回值包裹在了maybe对象中

const getList = R.pipe(R.path(['obj','value']),Maybe);
const formatProp = R.pipe(R.map(R.evolve({name:R.pipe(R.trim,R.toUpper)})),Maybe);
const sortList = R.pipe(R.sortBy(R.prop('name')),Maybe);
//注意要换成composeK，composeK是用来组合，返回值是容器对象，的方法链，
//不过这不重要，记住使用了返回值被maybe或either包裹的方法，就用composeK就好了
const getSortListByData = R.composeK(
    sortList,
    formatProp,
    getList
);
const result = getSortListByData(undefined);//直接传入undefined也不会报错
console.log(result.getOrElse('失败'));

 

还有种情况，你不想修改原方法了，但又想利用maybe的好处，那可以用maybe的map方法

const getList = R.path(['obj','value']);
const formatProp = R.map(R.evolve({name:R.pipe(R.trim,R.toUpper)}));
const sortList = R.sortBy(R.prop('name'));

const result = Maybe(undefined).map(getList).map(formatProp).map(sortList);
console.log(result.getOrElse('失败'));

 

另一种方法是，写一个高阶函数，来使得普通函数返回Maybe对象

const highMaybe = Fn=> R.pipe(Fn,Maybe);

const getList = R.path(['obj','value']);
const formatProp = R.map(R.evolve({name:R.pipe(R.trim,R.toUpper)}));
const sortList = R.sortBy(R.prop('name'));
const getSortListByData = R.composeK(
        highMaybe(sortList),
        highMaybe(formatProp),
        highMaybe(getList)
);
const result = getSortListByData(undefined);
console.log(result.getOrElse('失败'));

 

(以上代码都经过测试，直接可用。）下一节想讲一下validate。