javascript - Javascriptでデータを隠す

Question

Javaプログラミング言語では、privateキーワードはデータの非表示に使用されます。privateとしてマークされたフィールドまたはメソッドは、クラスまたはサブクラスの外部には表示されません。

それは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

これがあなたが楽しむかもしれない簡単なAPIです。Key（コンストラクター）、KeepSecret、FetchSecretの3つの機能があります。

あなたができることは、プロパティとしてシークレットキーパーを持つオブジェクトを持つことです。その後、オブジェクトはデータを「持ち運ぶ」ことができますが、オブジェクトにアクセスするがキーを知らないコードは、非表示のデータにアクセスできません。

/**
 * 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;

  });

Answer 4

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