突圍封閉解釋給了unitiated

Question

我已經得到了這一點，它的工作原理：

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可言。

Answer 1

在你的第一個例子要指定內部功能屬性「myFunction的」。

在你第二示例要分配外部函數的屬性「myfunction2」。

這導致不同的行爲，因爲與第一實施例使用一個立即調用函數表達式，其中作爲第二示例將名爲「myFunction2」到「myFunction1」聲明的功能。爲了調用內部函數，你實際上必須做這樣的事情。

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

或

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

Answer 2

如果我理解你，myObject.myFunction1 = myFunction2();應該工作。

可是，我真的沒有看到使用該模式進行一個簡單的getter和setter任何優勢。你「關閉」變量是來自下的getter/setter內只訪問，並且函數什麼都不做不是簡單地設置其值（不轉換它）。我的意思是，可以直接在您的對象上使用常規屬性，而不是功能來完成相同的操作。

---

現在我更關注一個事實，即您正在尋找更好的方式來解釋閉包。您可以爲您的變量和函數使用有意義，準確的名稱，並添加註釋。這裏有一個建議，根據您的代碼：

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()); 

Answer 3

我想這是我在尋找：

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); 

Answer 4

你只是尋找解釋如閉包的最簡單的方法：

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!" 

那很可能是因爲它得到一樣簡單，我認爲:-)

Answer 5

不，等等。我認爲這是我正在尋找的。這可能真的是這樣：

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);