将匿名函数作为参数传递给预设的参数值

Question

我偶然遇到了这个问题，不确定我的'popAndGo'函数是如何工作的。

function Calculator(){ 
    var stack = []; 

    var popAndGo = function(performer){ 
    var firstPop = stack.pop(); 
    var secondPop = stack.pop(); 
    var result = performer(firstPop, secondPop); 
    stack.push(result); 
    }; 

    this.push = function(num){ 
    stack.push(num); 
    }; 
    this.value = function(){ 
    return stack[stack.length -1]; 
    }; 
    this.plus = function(){ 
    popAndGo(function(first, second){ 
     return first + second; 
    }); 
    }; 
} 

我正在练习让我的代码遵循DRY实践，并创建了这个popAndGo函数。它采用一个匿名函数，并在收集两个参数（检查加号函数）后调用该函数。

我不确定这些参数是如何工作的。我通常理解参数，它们基本上是您最终通过函数的实际参数的占位符。

但是在this.plus的情况下，我传递了一个具有两个参数的匿名函数。他们如何代替表演者（firstPop，secondPop）？我想象它的工作原理如下：

var popAndGo = function(performer){ 
    var firstPop = stack.pop(); 
    var secondPop = stack.pop(); 
    var result = performer(firstPop, secondPop); 
    stack.push(result); 
    }; 

    this.plus = function(){ 
    popAndGo(function(first, second){ 
     return first + second; 
    }); 
    }; 
} 

// CHECK the parameters on this popAndGo, this is how I picture this working. 

var popAndGo = function(function(first, second){ 
    var firstPop = stack.pop(); 
    var secondPop = stack.pop(); 
    var result = function(first, second); 
    stack.push(result); 
    }; 

这些值不匹配。如果任何人都可以解释如何将这个函数传入我的popAndGo函数并且与这些值相匹配，那么它会清除我所遇到的很多混乱，谢谢！

测试用例我写这个代码：

// See http://en.wikipedia.org/wiki/Reverse_Polish_notation 
describe("Calculator using reverse polish notation", function() { 
    var calculator; 

    beforeEach(function(){ 
    calculator = new Calculator(); 
    }); 

    it("adds two numbers", function() { 
    calculator.push(2); 
    calculator.push(3); 
    calculator.plus(); 
    expect(calculator.value()).toEqual(5); 
    }); 

    it("adds three numbers", function() { 
    calculator.push(2); 
    calculator.push(3); 
    calculator.push(4); 
    calculator.plus(); 
    expect(calculator.value()).toEqual(7); 
    calculator.plus(); 
    expect(calculator.value()).toEqual(9); 
    }); 
} 

有更多的测试和更多的功能，我不得不为它编写。在每一个函数中，我都从堆栈中弹出两个值，然后再推回总值。我想写一个功能，我这样做，所以我没有不断重复自己。

Answer 1

this.plus = function(){ 
    popAndGo(function(first, second){ 
     return first + second; 
    }); 
}; 

您作为参数传递给popAndGo的函数是具有两个参数的匿名函数。该匿名函数绑定到popAndGo中的参数performer。

当调用performer与firstPop和secondPop这些值获取绑定的参数在匿名函数first和second。匿名函数的主体得到执行返回参数的总和。

Answer 2

，我可能会写这样

function Calculator(initialNum) { 

    var result = 0; 

    // private api 
    function set(num) { 
    return result = num || 0; 
    } 

    function add(num) { 
    return set(result + num); 
    } 

    function subtract(num) { 
    return set(result - num); 
    } 

    function divide(num) { 
    if (num === 0) throw new Error("Cannot divide by zero"); 
    return set(result/num); 
    } 

    function multiply(num) { 
    return set(result * num); 
    } 

    function value() { 
    return result; 
    } 

    function clear() { 
    return set(0); 
    } 

    // exports; public api 
    this.add  = add; 
    this.subtract = subtract; 
    this.divide = divide; 
    this.multiply = multiply; 
    this.value = value; 
    this.clear = clear; 

    // "magic" api 
    this.valueOf = value; 

    // init 
    set(initialNum); 
} 

使用

var a = new Calculator; // 0 
a.add(5);    // 5 
a.add(10);    // 15 
a.divide(5);   // 3 
a.multiply(3);   // 9 

计算器可以相互合作过

var b = new Calculator(3); // 3 
b.add(3);    // 6 
b.multiply(a);   // 54 
b.clear();    // 0 
+a;      // 9 

Answer 3

也许你会更好地显现这样说：

var popAndGo = function(){ 
    var performer = function(first, second){ 
     return first + second; 
    }; 
    var firstPop = stack.pop(); 
    var secondPop = stack.pop(); 
    var result = performer(firstPop, secondPop); 
    stack.push(result); 
}; 

或者简化，

var popAndGo = function(){ 
    var firstPop = stack.pop(); 
    var secondPop = stack.pop(); 
    var result = firstPop + secondPop; 
    stack.push(result); 
};