Question

我想知道如果我在其他函数 bar（）中调用函数 foo（）或者返回函数 something（）内部功能 test（）。有什么区别，哪种方法更好用？

var foo = function() { console.log(2+3); } var bar = function() { foo(); } bar(); var test = function() { var something = function() { console.log(5+7); } return something(); } test();

Answer 1

您的代码与散文所说的不符。

在这两种情况下，您都可以调用该函数。在第二种情况下，您返回它的返回值。

由于你没有对外部函数的返回值做任何事情，所以在这种情况下根本没有实际的区别。

如果你确实对返回值做了一些事情，那么区别在于，在第二种情况下，你实际上会有一个返回值来执行某些操作。

Answer 2

感谢答案，但这并不是我想知道的。这段代码怎么样：

    var foo = function()
    {
        var x = 2, y=3;
        return x+y;
    }

    var bar = function()
    {
        console.log(foo());
    }
    bar();

    ////        
    var test = function()
    {

        var something = function(a,b)
        {
            console.log(a*b);
        }
        return something(3,4);

    }
    test();

    ////
    var outer = function()
    {
        var inner = function(c,d)
        {
            return c-d;
        }
        console.log(inner(10,8));
    }
    outer();

    ////
    var outside = function()
    {
        var inside = function(e,f)
        {
            var divide = e/f;
            return divide;
        }
        var sum = inside(12,2) + 10;
        console.log(sum);           
    }
    outside();

    ////
    var access = function(age) {
            var limit = 8;
            return function(age, limit) {
                return age > limit;   
            }
    };
    console.log(access(50));

上一个功能 access（）最接近我的目标。整件事让我感到困惑，因为我看了一门名为“JavaScript。理解怪异部分”的课程。它很棒，但我不太了解这个函数式编程，它涉及在其他函数之间传递变量以及从其他函数返回它们。在那个课程中，有一些课程，其中有很少的功能，每个都返回一些东西，下一个功能需要它，做某事并返回其他东西。我是关于函数 checkPastLimitSimplified（）。它接受从其他函数返回的参数并返回它自己的函数。它是如何工作的？

function mapForEach(arr, fn) {

    var newArr = [];
    for (var i=0; i < arr.length; i++) {
        newArr.push(
            fn(arr[i])   
        )
    };

    return newArr;
}

var arr1 = [1,2,3];
console.log(arr1);


var arr2 = mapForEach(arr1, function(item) {
   return item * 2; 
});
console.log(arr2);


var arr3 = mapForEach(arr1, function(item) {
   return item > 2; 
});
console.log(arr3);


var checkPastLimit = function(limiter, item) {
    return item > limiter;   
}
var arr4 = mapForEach(arr1, checkPastLimit.bind(this, 1));
console.log(arr4);


var checkPastLimitSimplified = function(limiter) {
    return function(limiter, item) {
        return item > limiter;   
    }.bind(this, limiter); 
};

var arr5 = mapForEach(arr1, checkPastLimitSimplified(1));
console.log(arr5);

最后，是否有一个关于JavaScript中使用的函数式编程的好教程或书籍？

Answer 3

在你的情况下，没有太大的区别，当从foo调用bar时，你不会返回任何内容，只需调用foo即会打印2 + 3 1}}到控制台。

第二种情况，即返回调用something的结果，返回undefined，因为它只是console.log语句，您将返回所述语句的结果，但是log方法返回undefined，即test将返回的值。{/ p>

更常见的方法是返回一个可以从那里调用的函数。 E.g：

var test = function() { var something = function() { console.log(5+7); } return something; } var somethingFn = test();

test现在将返回您现在可以调用的函数something，就像任何其他函数一样：somethingFn() - ＆gt;打印12

Answer 4

虽然你表达的不同于你所写的问题不同，但我试着回答这两种情况。如果代码是您想要说的：它是可访问性差异。在此范围内可以访问所有foo，bar和test，但something不可访问。因此，您将something函数限制为函数test。这是唯一的区别。

var foo = function()
{
    console.log(2+3);
}

var bar = function()
{
    foo();
}
bar(); // will print 5 to the console

var test = function()
{
    var something = function()
    {
        console.log(5+7);
    }
    return something(); // Assuming you return the return value of a function call (not the function itself)
}
test(); // will print 12 to the console

如果您所写的内容是您要问的内容：您通过调用函数返回函数。

var test = function()
{
    var something = function()
    {
        console.log(5+7);
    }
    return something; // this is a function that can be called later
}
var aFnToBeCalled = test();  // returns a function that is called. Nothing printed to the console yet.
aFnToBeCalled(); // prints 12 to the console.

虽然在这个例子中没有反映出来，但这是隐藏一些为返回函数提供内存的信息的好模式。这称为closure：

var test = function()
{
    var numberOfTimesSomethingIsCalled = 0;
    var something = function()
    {
        ++numberOfTimesSomethingIsCalled; // numberOfTimesSomethingIsCalled is in the closure of something
        console.log(numberOfTimesSomethingIsCalled);
    }
    return something; // this is a function that can be called later
}

a = test();
b = test();

a(); // will print 1
a(); // will print 2
a(); // will print 3
b(); // will print 1
a(); // will print 4

其他函数内部的invoke和return函数之间的区别

4 个答案: