js-Grundkenntnisse (öffentliche Methoden, private Methoden, privilegierte Methoden)_Grundkenntnisse

Obwohl das in diesem Artikel behandelte Thema sehr grundlegend ist und von vielen als Trick angesehen wird, handelt es sich um ein umfassendes Thema für die Grundkenntnisse von JavaScript. Dazu gehören Kenntnisse über Objektattributkapselung, Prototypen, Konstruktoren, Abschlüsse und die sofortige Ausführung von Ausdrücken .

Öffentliche Methoden
Öffentliche Methoden sind Methoden, auf die extern zugegriffen und die sie aufgerufen werden können.

// 在对象中
var Restaurant = {
 name: 'McDonald',
 // 公有方法
 getName: function() {
 return this.name;
 }
}

// 在构造函数中
function Person(name, age) {
 this.name = name;
 this.age = age;
 // 公有方法
 this.getName = function() {
 return this.name;
 }
}

// 在原型中
Person.prototype.getAge = function() {
 return this.age;
}

Private Methoden und Privilegierte Methoden
Diese beiden Methoden werden im Allgemeinen gemeinsam besprochen, da sich die von uns definierte privilegierte Methode auf die öffentliche Methode bezieht, die Zugriff auf interne private Eigenschaften und private Methoden hat, während sich die private Methode auf die externe unsichtbare und unzugängliche Methode bezieht.

Normalerweise gibt es zwei Möglichkeiten, ein Objekt zu definieren: Eine besteht darin, Objektinstanziierung oder Objektausdruck zu verwenden, und die andere darin, einen Konstruktor zu verwenden. Ebenso unterscheiden sich auch die Formen der Definition privater Methoden und privilegierter Methoden auf unterschiedliche Weise.

im Objekt
Hier verwenden wir den Objektausdruck, um ein Objekt zu erstellen, einige Eigenschaften und Methoden hinzuzufügen und es dann direkt auf statische Weise aufzurufen. Die privaten Daten des Objekts werden in einem anonymen Funktionsausdruck (IIFE) platziert. Dies bedeutet, dass diese Funktion nur im Moment ihres Aufrufs existiert und sofort nach der Ausführung zerstört wird.

Die Art und Weise, private Daten in einem Objekt zu erstellen, wird als Modulmuster im Objektmodus bezeichnet (bezogen auf den Modus zum Erstellen von Objekten). Das Grundformat lautet wie folgt:

var yourObject = (function() {

 // 私有属性和方法

 return {
 // 公有方法和属性
 }
}) ();

Im Modulmodus enthält das zurückgegebene Objektliteral nur Eigenschaften und Methoden, die verfügbar gemacht werden können.

var Restaurant = (function() {
 // 私有属性
 var _total = 10;

 // 私有方法
 var _buyFood = function() {
 _total--;
 };
 var _getTotal = function() {
 return _total;
 }

 return {
 name: 'McDonald',
 getTotal: _getTotal,
 buy: _buyFood
 }
}) ();

Restaurant.buy();
console.log(Restaurant.name); // 'McDonald'
console.log(Restaurant.getTotal()); // 9

Beachten Sie, dass wir Schließungen verwenden, um indirekt interne private Variablen zu verwenden und den Namen des Restaurants zu initialisieren.

Im Konstruktor
Beim Erstellen privater Methoden im oben vorgestellten Modulmuster gibt es keinen wesentlichen Unterschied zwischen öffentlichen Methoden und privilegierten Methoden. Der Grund dafür ist, dass dieses Konzept bei der Verwendung von Konstruktoren zum Erstellen privater Daten definiert wird.

Es ist praktisch, private Eigenschaften und Methoden im Konstruktor zu definieren. Wir müssen keine Abschlüsse verwenden und können die Daten beim Aufruf initialisieren.

function Restaurant(name) {
 // 私有属性
 var _total = 10;

 // 公有属性
 this.name = name;

 // 私有方法
 function _buyFood() {
 _total--;
 }

 // 特权方法
 this.buy = function() {
 _buyFood();
 }

 this.getTotal = function() {
 return _total;
 }
}

// 公有方法, 注意这里不能访问私有成员_total
Restaurant.prototype.getName = function() {
 console.log(_total); // Uncaught ReferenceError: _total is not defined
 return this.name;
}

var McDonald = new Restaurant('McDonald');
console.log(McDonald.getName()); // 'McDonald'
McDonald.buy();
console.log(McDonald.getTotal()); // 9

Zwei in einem, flexibler
Mit dem Modulmuster können wir es mehrmals aufrufen und es wird nach jeder Ausführung zerstört. Einige initialisierte Daten können mit der Konstruktormethode übergeben werden, auf private Mitgliedseigenschaften kann jedoch nicht in öffentlichen Methoden zugegriffen werden. Wenn es viele öffentliche Methoden gibt, die auf private Daten zugreifen müssen, schreiben wir sie alle in privilegierte Methoden und bringen sie schließlich dazu Jede Instanz. Viele unnötige Methoden. Daher kann sich die Kombination der beiden ergänzen und die Kombinationsmethode ist auch sehr einfach

var Restaurant = (function() {
 // 私有属性
 var _total = 10;

 // 私有方法
 function _buyFood() {
 _total--;
 }

 // 构造函数
 function restaurant(name) {
 this.name = name;
 this.getTotal = function() {
 return _total;
 }
 }

 restaurant.prototype.buy = function() {
 console.log(_total); // 10
 _buyFood();
 }

 restaurant.prototype.getName = function() {
 return this.name;
 }

 return restaurant;
}) ();

var McDonald = new Restaurant('McDonald');
console.log(McDonald.getName()); // 'McDonald'
McDonald.buy();
console.log(McDonald.getTotal()); // 9

Das Obige ist der gesamte Inhalt dieses Artikels. Es gibt noch viele Wissenspunkte, die Sie selbst erkunden und studieren können hilfreich für Anfänger.