So implementieren Sie die grammatikalischen Funktionen privater Mitglieder und die Implementierung privater Mitglieder basierend auf JavaScript_Javascript-Kenntnissen

Vorwort

Im objektorientierten Programmierparadigma ist die Kapselung ein wesentliches Konzept, und in traditionellen objektorientierten Sprachen wie Java und C sind private Mitglieder ein wichtiger Weg, um die Kapselung zu erreichen. Allerdings gibt es in JavaScript tatsächlich keine Unterstützung für private Mitglieder in JS, was dazu führt, dass Entwickler verschiedene Tricks verwenden, um private Mitglieder in JS zu implementieren ein Vergleich ihrer Vor- und Nachteile.

Einige vorhandene Implementierungslösungen

Gemeinsames Benennungsschema

Es wird vereinbart, dass Mitgliedsnamen, die mit einem Unterstrich „_“ beginnen, als private Mitglieder betrachtet werden. Es darf nur auf Methoden von Klassenmitgliedern zugegriffen werden und auf private Mitglieder darf nicht extern zugegriffen werden. Der einfache Code lautet wie folgt:

JavaScript

var MyClass = function () {
  this._privateProp = ‘privateProp';
};
MyClass.prototype.getPrivateProp = function () {
  return this._privateProp;
};
var my = new MyClass();
alert(my.getPrivateProp()); // ‘privateProp';
alert(my._privateProp); // 并未真正隐藏，依然弹出 ‘privateProp'

Vorteile

Es besteht kein Zweifel, dass die Namenskonvention die einfachste Lösung ist, um private Mitglieder ohne Arbeit auf Codeebene zu implementieren.
Das Debuggen ist bequem und Sie können die privaten Mitglieder des Objekts direkt auf der Konsole sehen, was die Fehlerbehebung erleichtert.
Gute Kompatibilität, unterstützt von ie6

Nicht genug

Es gibt keine Möglichkeit, den externen Zugriff und Änderungen an privaten Mitgliedern zu verhindern. Wenn ein Entwickler, der die Vereinbarung nicht kennt oder sich nicht daran hält, private Attribute ändert, kann nichts unternommen werden.
Jeder muss gezwungen oder überredet werden, sich an diese Vereinbarung zu halten. In einem Team mit Codestandards ist dies natürlich kein großes Problem.

es6-Symbollösung

In es6 wurde eine Symbolfunktion eingeführt, mit der private Mitglieder implementiert werden sollen.
Die Hauptidee besteht darin, einen zufälligen und eindeutigen Zeichenfolgenschlüssel für den Namen jedes privaten Mitglieds zu generieren. Die interne Sichtbarkeit wird durch die Abschlussvariable von js erreicht

JavaScript

(function() {
   var privateProp = Symbol(); // 每次调用会产生一个唯一的key
   function MyClass() {
     this[privateProp] = ‘privateProp'; // 闭包内引用到这个 key
   }
   MyClass.prototype.getPrivateProp = function () {
     return this[privateProp];
   };
})();
var my = new MyClass();
alert(my.getPrivateProp()); // ‘privateProp';
alert(my.privateProp); // 弹出 undefined，因为成员的key其实是随机字符串

Vorteile

Der Komfort des Debuggens ist akzeptabel. Im Allgemeinen wird ein Zeichenfolgenparameter an den Konstruktor von Symbol übergeben und der entsprechende private Eigenschaftsname wird auf der Konsole als Symbol (Schlüssel)
angezeigt

Nicht genug

Extern können Sie weiterhin den Symboleigenschaftennamen der Instanz über Object.getOwnPropertySymbols abrufen und über diesen Namen Zugriffsrechte auf private Mitglieder erhalten. Dieses Szenario kommt relativ selten vor, und es wird davon ausgegangen, dass die Ebene der Entwickler, die diesen Ansatz kennen, in der Lage ist, die Auswirkungen ihrer Aktionen zu erkennen, sodass dieser Mangel kein wirklicher Mangel ist.

es6 WeakMap-Lösung

JavaScript

(function() {
   var privateStore = new WeakMap(); // 私有成员存储容器
   function MyClass() {
     privateStore.set(this, {privateProp: ‘privateProp'}); // 闭包内引用到privateStore, 用当前实例做 key，设置私有成员
   }
   MyClass.prototype.getPrivateProp = function () {
     return privateStore.get(this).privateProp; 
   };
})();
var my = new MyClass();
alert(my.getPrivateProp()); // ‘privateProp';
alert(my.privateProp); // 弹出 undefined，实例上并没有 privateProp 属性

(function() {
   var $private = createPrivate(); // 私有成员 token 函数，可以传入对象参数，会作为原型链上的私有成员
   function MyClass() {
     $private(this).privateProp = ‘privateProp' ; // 闭包内引用到privateStore, 用当前实例做 key，设置私有成员
   }
   MyClass.prototype.getPrivateProp = function () {
     return $private(this).privateProp; 
   };
})();
var my = new MyClass();
alert(my.getPrivateProp()); // ‘privateProp';
alert(my.privateProp); // 弹出 undefined，实例上并没有 privateProp 属性

// createPrivate.js
function createPrivate(prototype) {
  var privateStore = Symbol('privateStore');
  var classToken = Symbol(‘classToken');
  return function getPrivate(instance) {
     if (!instance.hasOwnProperty(privateStore)) {
       instance[privateStore] = {};
     }
    var store = instance[classToken];
     store[token] = store[token] || Object.create(prototype || {});
     return store[token];
   };
}

 function testFn(){ 
    var _Name;//定义Javascript私有成员 
    this.setName = function(name){ 
     _Name = name; //从当前执行环境中获取_Name 
    } 
    this.getName = function(){ 
     return _Name; 
    } 
}// End testFn 
var test = testFn(); 
alert(typeof test._Name === "undefined")//true 
test.setName("KenChen"); 

function testFn(name){ 
  this.Name = name; 
  this.getName = function(){ 
   return this.Name; 
  } 
} 
var test = new testFn("KenChen"); 
test.getName(); //KenChen 
test.Name = "CC"; 
est.getName();//CC 

function testFn(){ 
} 
testFn.Name = "KenChen"; 
alert(testFn.Name);//KenChen 
testFn.Name = "CC"; 
alert(testFn.Name);//CC