在 Javascript 中嵌套许多函数调用（Unix 管道）的好方法

Question

我一直在寻找一种很好地进行嵌套函数调用的方法，以避免出现以下情况：

var result = function1(function2(function3()));

或者类似的东西：

var result = function3();
result = function2(result);
result = function1(result);

像 Unix 管道这样的东西会很好：

var result = function3() | function2() | function1();

来源：https://www.npmjs.com/package/babel-plugin-operator-overload

当然|是按位或运算，这个例子是抽象的。

有没有人知道使用 ES5、ES6 或 ES7 实现这种效果的任何方法，无需转译？

编辑

感谢 T.J Crowder、torazaburo 和 Bergi，你们在回答中添加了独特、有用和有趣的信息。

Answer 1

没有辅助函数

我最初认为您的问题是在 没有任何辅助函数的情况下执行此操作，但您随后的评论表明情况并非如此。如果辅助函数在范围内，则跳过。

无需添加任何辅助函数，您就可以使用 ES6 Promise：

Promise.resolve()
    .then(function3)
    .then(function2)
    .then(function1)
    .then(result => {
  console.log("result is " + result);
});

它并不比它更漂亮

var result = function1(function2(function3()));

...但至少被调用的函数是按照它们被调用的顺序列出的，并且 promises 在多种方式上都非常灵活。

例如：Live copy on Babel's REPL

function function1(arg) {
  console.log("function1 called with " + arg);
  return "result1";
}
function function2(arg) {
  console.log("function2 called with " + arg);
  return "result2";
}
function function3() {
  console.log("function3 called");
  return "result3";
}

Promise.resolve()
    .then(function3)
    .then(function2)
    .then(function1)
    .then(result => {
  console.log("result is " + result);
});

输出：

调用函数3 用 result3 调用的 function2 使用结果 2 调用的函数 1 结果是结果1

---

带有辅助函数

你的评论：

function pipe(){
    var str = 'Promise.resolve()';
    for(var i = 0; i < arguments.length; i++){
        str += '.then(arguments[' + i + '])'
    }
    eval(str);
}

 pipe(c, b, a, result => { console.log("result is " + result); });

我知道管道是 fs 库中的一个东西，所以函数名不是很好。除此之外，这还有什么明显的问题吗？

如果你想为此抛出一个辅助函数，则根本不需要eval。对于 non-promise-ified 函数，只需：

function pipe(first, ...more) {
  return more.reduce((r, f) => f(r), first());
}

和

let result = pipe(function3, function2, function1);

Live copy on Babel's REPL

如果您想使用 promise-ified 函数或混合函数来执行此操作，那么：

function pipe(...functions) {
  return functions.reduce((p, f) => p.then(f), Promise.resolve());
}

那么你可以按照你展示的方式来称呼它：

pipe(function3, function2, function1, result => {
    // ...
});

...但是这样做会忽略错误。由于pipe返回最后一个promise，你可以使用所有promise good

pipe(function3, function2, function1, result => {
    // ...
}).catch(failure => {
    // ...
});

或

pipe(function3, function2, function1)
    .then(result => {
        // ...
    })
    .catch(failure => {
        // ...
    });

这是一个混合简单函数和返回承诺的函数的完整示例：Live copy on Babel's REPL

function pipe(...functions) {
    return functions.reduce((p, f) => p.then(f), Promise.resolve());
}
function function1(arg) {
    console.log("function1 called with " + arg);
    return "result1";
}
function function2(arg) {
    console.log("function2 called with " + arg);
    return new Promise(resolve => {
        setTimeout(() => {
            resolve("result2");
        }, 100);
    });
}
function function3() {
    console.log("function3 called");
    return "result3";
}

pipe(function3, function2, function1)
    .then(result => {
        console.log("Final result is " + result);
    })
    .catch(failure => {
        console.log("Failed with " + failure);
    });

输出：

调用函数3 用 result3 调用的 function2 使用结果 2 调用的函数 1 最终结果是 result1

Answer 2

您只是在编写函数。使用许多库中提供的compose 函数，或者编写自己的函数，并将其用作：

compose(function1, function2, function3) ()

换句话说，您的“管道”运算符可以被认为是一个“逗号”，用于在 compose 调用中分隔参数。

这是一个真正简单的 compose：

function compose(...fns) {
  var lastFunc = fns.pop();
  return function() { 
    return fns.reduceRight(result, fn) {
      return fn(result);
    }, lastFunc(...arguments));
  };
}

Answer 3

您正在寻找的是一个pipe 函数，它基本上是众所周知的compose 翻转：

var result = pipe(function3, function2, function1)();

它不是内置的（也没有计划用于任何即将到来的 ES 修订版），但在许多库中可用，例如 Ramda；你可以自己简单地实现它：

function pipe(g, ...fs) {
    if (!arguments.length) return x => x;
    if (!fs.length) return g;
    const f = pipe(...fs);
    return x => f(g(x));
}

---

如果您正在寻找新的语法，an ES7 proposal 可以为该语言带来一些流水线糖。是not settled yet 它到底是什么样子的：

method3()::method2()::method1()
method3()->method2()->method1()
function3()->function2()->function1()