Javascript 打破僵局，向公众解释

我得到了这个，它是有效的：

myObject.myFunction = (function() {
    var closure = 0;

    return function(value) {
        if (arguments.length) {
            closure = value;
        } else {
            return closure;
        }
    }
})();

它同时充当getter和setter，因此调用myFunction（3.14）将设置闭包，调用myFunction（）将获得闭包的值

问：我能把它分成一个更冗长的例子吗（不要显得可笑）？我想做的是这样的：

myObject.myFunction1 = myFunction2;
myObject.myFunction1();

function myFunction2() {
    var closure = 0;

    return function(value) {
        if (arguments.length) {
            closure = value;
        } else {
            return closure;
        }
    }
}

我只是尝试将JavaScript分解成尽可能小的块，以便我的学生能够集中精力

编辑1：

---

哦，等等：我根本不需要myFunction2。

在第一个示例中，您将内部函数指定给属性“myFunction”

在第二个示例中，将外部函数指定给属性“myfunction2”

这会导致不同的行为，因为第一个示例使用立即调用的函数表达式，而第二个示例将一个名为“myFunction2”的声明函数指定给“myFunction1”。为了调用内部函数，实际上必须执行类似的操作

myObject.myFunction1 = myFunction2;
var myFunction3 = myObject.myFunction1();
myFunction3();

或

---

在第一个示例中，将内部函数指定给属性“myFunction”

在第二个示例中，将外部函数指定给属性“myfunction2”

这会导致不同的行为，因为第一个示例使用立即调用的函数表达式，而第二个示例将一个名为“myFunction2”的声明函数指定给“myFunction1”。为了调用内部函数，实际上必须执行类似的操作

myObject.myFunction1 = myFunction2;
var myFunction3 = myObject.myFunction1();
myFunction3();

或

---

如果我理解你的意思，

myObject.myFunction1=myFunction2（）应该可以工作

然而，我真的不认为将该模式用于简单的getter和setter有什么好处。您只能从getter/setter内部访问“closure”变量，函数只需设置它的值（不转换它）。我的意思是，直接在对象上使用正则属性，而不是函数，也可以实现同样的效果


现在，我更加关注这样一个事实：您正在寻找一种更好的方法来解释闭包。您可以为变量和函数使用有意义、准确的名称，并添加注释。根据您的代码，这里有一个建议：

function createClosure() {
    // Only the function returned below can see the secret
    var secret = 0;
    return function(value) {
        // If anything was passed, change secret (returns undefined)
        if (arguments.length) {
            secret = value;
        // Nothing was passed, return secret
        } else {
            return secret;
        }

    }
}

// Create a function that enables access to the secret
var closure = createClosure();

// Use it to read the secret
console.log('the closure holds the secret: ' + closure());

// Use it to change the secret
closure(10);

// Read it again to check
console.log('the secret now holds ' + closure());

如果我理解你的意思，
myObject.myFunction1=myFunction2（）应该可以工作

然而，我真的不认为将该模式用于简单的getter和setter有什么好处。您只能从getter/setter内部访问“closure”变量，函数只需设置它的值（不转换它）。我的意思是，直接在对象上使用正则属性，而不是函数，也可以实现同样的效果


现在，我更加关注这样一个事实：您正在寻找一种更好的方法来解释闭包。您可以为变量和函数使用有意义、准确的名称，并添加注释。根据您的代码，这里有一个建议：

function createClosure() {
    // Only the function returned below can see the secret
    var secret = 0;
    return function(value) {
        // If anything was passed, change secret (returns undefined)
        if (arguments.length) {
            secret = value;
        // Nothing was passed, return secret
        } else {
            return secret;
        }

    }
}

// Create a function that enables access to the secret
var closure = createClosure();

// Use it to read the secret
console.log('the closure holds the secret: ' + closure());

// Use it to change the secret
closure(10);

// Read it again to check
console.log('the secret now holds ' + closure());

我想这就是我想要的：

function ConjunctionJunction() {
    var myClosure = 0;

    return function(myValue) {
        if (arguments.length) {
            myClosure = myValue;
        } else {
            return myClosure;
        }
    }
};
myObject = new Object();
myObject.myFunction = ConjunctionJunction(); // This creates a function and assigns it to the variable myObject.myFunction
myObject.myFunction(3.14); // This calls the newly created function as a setter
var x = myObject.myFunction(); // This calls it as a getter, which returns a value.
log(x);

我想这就是我想要的：

function ConjunctionJunction() {
    var myClosure = 0;

    return function(myValue) {
        if (arguments.length) {
            myClosure = myValue;
        } else {
            return myClosure;
        }
    }
};
myObject = new Object();
myObject.myFunction = ConjunctionJunction(); // This creates a function and assigns it to the variable myObject.myFunction
myObject.myFunction(3.14); // This calls the newly created function as a setter
var x = myObject.myFunction(); // This calls it as a getter, which returns a value.
log(x);

您是否正在寻找最简单的方法来解释闭包，如：

function closure() {
    var privateData = "I'm hidden!";

    return {
        get: function () {
            return privateData;
        },
        set: function (arg) {
            privateData = arg;
        }
    };
}

var privateDataAccess = closure();

console.log(typeof (privateData)); // logs undefined -- privateData is out of scope
console.log(privateDataAccess.get()); // logs "I'm hidden!"
privateDataAccess.set("Now you changed me!");
console.log(privateDataAccess.get()); // logs "Now you changed me!"

这可能是最简单的了，我想：-）
你只是在寻找最简单的方法来解释闭包，比如：

function closure() {
    var privateData = "I'm hidden!";

    return {
        get: function () {
            return privateData;
        },
        set: function (arg) {
            privateData = arg;
        }
    };
}

var privateDataAccess = closure();

console.log(typeof (privateData)); // logs undefined -- privateData is out of scope
console.log(privateDataAccess.get()); // logs "I'm hidden!"
privateDataAccess.set("Now you changed me!");
console.log(privateDataAccess.get()); // logs "Now you changed me!"

我想这很简单：-）
不，等等。我想这就是我要找的。可能真的是这样：

myObject = new Object();

;(function($, window, undefined) {
    var Variables = {};

    myObject.myFunction = function(argValue) {
        if (arguments.length) {
            Variables.myValue = argValue;
        } else {
            return Variables.myValue;
        }
    }
})(jQuery, window);


myObject.myFunction(3.14);
var x = myObject.myFunction();
log(x);

不，等等。我想这就是我要找的。可能真的是这样：

myObject = new Object();

;(function($, window, undefined) {
    var Variables = {};

    myObject.myFunction = function(argValue) {
        if (arguments.length) {
            Variables.myValue = argValue;
        } else {
            return Variables.myValue;
        }
    }
})(jQuery, window);


myObject.myFunction(3.14);
var x = myObject.myFunction();
log(x);

我不能完全理解这里的实际问题是什么。是的，我有这个问题。在我提出的解决方案中，当我调用myObject.myFunction1（）时，它返回一个函数。所以我真的应该说myFunction3=myObject.myFunction1（），你是说
myObject.myFunction1=myFunction2（）？“那应该行。”菲利普，我现在后悔投票结束了你的问题。投票重新打开，并在我的答案中添加了第二部分，希望这将比第一部分对您的帮助更大。我不太明白这里的实际问题是什么。是的，我对此有问题。在我建议的解决方案中，当我调用myObject.myFunction1（）时，它返回一个函数。所以我真的应该说myFunction3=myObject.myFunction1（），你是说
myObject.myFunction1=myFunction2（）？“那应该行。”菲利普，我现在后悔投票结束了你的问题。投票重新打开，并在我的答案中添加了第二部分，希望这比第一部分对您的帮助更大。我只是不喜欢get和set的语法。我想我已经决定使用jQuery类型的语法，其中不传入参数意味着它是getter，传入参数意味着它是setter。是的，我明白了。jQuery方法使API的用户端更易于理解和使用。也许你可以把它和你的例子结合起来，作为一个简单的例子来说明API的另一面（幕后）发生了什么。我想我已经决定使用jQuery类型的语法，其中不传入参数意味着它是getter，传入参数意味着它是setter。是的，我明白了。jQuery方法使API的用户端更易于理解和使用。也许你可以把这个和你的例子结合起来，作为一个简单的例子，来说明API的另一面（幕后）发生了什么。我以为你是在试图从语法上简化你的例子来关注闭包？我以为你是在试图从语法上简化你的例子来关注闭包？