隱藏在Javascript中的數據

Question

在Java編程語言中，專用關鍵字用於數據隱藏 - 標記爲專用的字段或方法在類或子類之外不可見。

javascript是如何實現的？

Answer 1

在JavaScript中標準的方法是使用模塊模式如下所示..

var testModule = (function() { 

    var myPrivateVar = 0; 

    var myPrivateMethod = function (someText) { 
     console.log(someText); 
    }; 

    return { 

     myPublicVar: "foo", 

     myPublicFunction: function (bar) { 
      myPrivateVar++; 
      myPrivateMethod(bar); 
     } 

    }; 
})(); 

用法：在上面的代碼被返回的對象，其包含一個變量（myPublicVar）和功能（myPublicFunction）。在此函數內部，您可以訪問內部變量（myPrivateVar）和內部函數（myPrivateMethod），但不能從外部訪問。

var mod = new testModule(); 
mod.myPublicFunction(param); 

Answer 2

這一切都是通過範圍界定來實現的。

var MYCLASS = function(){ 

    var priv_var = 0; //private var 

    this.addToVar = function(){ 
     priv_var++; 
    } 

    this.showVar = function(){ 
     return priv_var; 
    } 

} 

var mc = new MYCLASS; 

mc.addTovar(); 
alert(mc.showVar()); //"1" 

Answer 3

"use strict"; 

var Person = function (fName, lName) { 

    var firstName = fName || "AN", lastName = lName || "Other"; 

    var fullName = function() { 
     return firstName + ' ' + lastName; 
    }; 

    return { 
     setName: function (fName, lName) { 
      firstName = fName; 
      lastName = lName; 
     }, 

     getFullName: function() { 
      return fullName(); 
     } 
    }; 

} 

var p = new Person("Your", "name"); 

console.log(p.getFullName()); 

Answer 4

下面是一個簡單的API，你可能會喜歡。它有三個功能：Key（一個構造函數），KeepSecret，FetchSecret。

你可以做的是將一個具有祕密守護者的對象作爲一個屬性。然後對象可以「隨身攜帶」數據，但是訪問對象但不知道密鑰的代碼無法訪問隱藏的數據。

/** 
* Example usage: 
* 
* Create a key 
* 
var mykey = Key(); 

* 
* Keep a secret 
* 
var mykeeper = KeepSecret(mykey, 42); 

* 
* Fetch the secret 
* 
var answer = FetchSecret(mykey, mykeeper); 

* 
* 'answer' will then contain 42 
*/ 

(function(Namespace, Code) { return Code(Namespace); })(
    /* Choose the namespace for Key, KeepSecret, FetchSecret */ 
    this, 

    function(Namespace) { 

/* 
* Simply so that we can use "Key" as both a type-name 
* and a parameter-name 
*/ 
var ikey; 

/** Constructor for a key */ 
function Key() { 
    if (!(this instanceof Key)) 
     return new Key(); 
    } 

/* Same key constructor */ 
ikey = Key; 

/** 
* Hide a secret using a key 
* 
* @param Key 
* The key to lock away the secret with 
* 
* @param Secret 
* The secret to be locked away 
* 
* @return 
* A function which hides the secret inside 
*/ 
function KeepSecret(Key, Secret) { 
    /* The function can access itself */ 
    var closure; 

    if (!(Key instanceof ikey)) 
     throw "KeepSecret: Invalid key"; 

    closure = function(key) { 
     /* If we were not passed the key, authenticate */ 
     if (key !== Key) { 
      Key.keeper = closure; 
      return; 
      } 

     /* The caller knew the key, so reveal the secret */ 
     return Secret; 
     } 
    return closure; 
    } 

/** 
* Use a key and a function to reveal the secret that function keeps 
* 
* @param Key 
* The key for unlocking the secret 
* 
* @param Keeper 
* The function keeping the secret 
* 
* @return 
* The secret, if the key unlocks it 
*/ 
function FetchSecret(Key, Keeper) { 
    /* Tracks authentication */ 
    var closure; 

    if (!(Key instanceof ikey) || !(Keeper instanceof Function)) 
     throw "FetchSecret: Invalid parameter(s)"; 

    /* Ask the keeper to authenticate */ 
    Keeper(); 

    /* Note the authenticated function */ 
    closure = Key.keeper; 

    /* Clear the authentication */ 
    delete Key.keeper; 

    /* Did the keeper prove that they know the key? */ 
    if (closure !== Keeper) 
     /* No */ 
     return; 

    /* They know the key. Show we know the key, too */ 
    return closure(Key); 
    } 

Namespace.Key = Key; 
Namespace.KeepSecret = KeepSecret; 
Namespace.FetchSecret = FetchSecret; 
return true; 

    });