Javascript définit-il des méthodes privées ?

JavaScript est un langage de programmation orienté objet qui fournit des méthodes d'encapsulation pour masquer des données ou des méthodes. En JS, nous pouvons utiliser des fonctions et des objets pour réaliser l'encapsulation. Les méthodes d'encapsulation couramment utilisées consistent à utiliser des fermetures ou des constructeurs. Cependant, l’encapsulation ne privatise que certaines propriétés ou méthodes, sans les privatiser véritablement.

En JavaScript, il n'existe pas de méthode privée formelle. Cependant, nous pouvons utiliser quelques astuces pour simuler des méthodes privées afin d'assurer la protection et l'encapsulation des données.

Une façon courante de simuler des méthodes privées consiste à utiliser des fermetures. Nous pouvons définir certaines variables et fonctions locales à l'intérieur de la fonction. Ces variables et fonctions forment une fermeture et peuvent accéder aux variables et paramètres à l'intérieur de la fonction (portée parent). Depuis le monde extérieur, nous ne pouvons pas accéder directement à ces variables et fonctions, atteignant ainsi l'objectif de simuler la confidentialité.

Par exemple, nous voulons définir un objet qui a une méthode publique et une méthode privée, où la méthode privée ne peut être utilisée qu'à l'intérieur de l'objet. Nous pouvons utiliser des fermetures pour y parvenir :

function MyObject() {
    this.publicMethod = function() {
        console.log('This is a public method.');
        privateMethod();
    };
  
    var privateMethod = function() {
        console.log('This is a private method.');
    };
}

Dans cet exemple, la variable privateMethod est définie à l'intérieur du constructeur, elle n'est donc accessible que par les méthodes publiques à l'intérieur du constructeur, obtenant ainsi l'effet de « fausses » méthodes privées. privateMethod 变量在构造函数内部定义，因此它只能被构造函数内部的公共方法所访问，从而达到了“伪造”私有方法的效果。

另一种常见的实现“伪造”私有方法的方式是使用命名约定。通过将方法名称以_

Une autre façon courante d'implémenter de « fausses » méthodes privées consiste à utiliser une convention de dénomination. En commençant le nom de la méthode par _, nous indiquons que la méthode est privée et ne doit pas être appelée en dehors de l'objet. Bien entendu, cette approche ne protège pas vraiment la méthode, car en JavaScript on peut toujours appeler directement les propriétés et méthodes de l’objet.

Dans ECMAScript 6, nous pouvons utiliser les propriétés de type Symbol pour créer des méthodes privées. Le symbole est un nouveau type de données de base qui peut être utilisé pour créer des propriétés d'objets. Étant donné que les propriétés de type Symbol sont uniques, nous pouvons l'utiliser pour créer des méthodes privées afin de garantir qu'il n'y a pas de problèmes de conflits de noms de méthodes. Par exemple, nous pouvons définir un objet comme ceci :

const PRIVATE_METHOD = Symbol();

class MyClass {
    constructor() {
        this[PRIVATE_METHOD] = function() {
            console.log('This is a private method.');
        };
    }
  
    publicMethod() {
        console.log('This is a public method.');
        this[PRIVATE_METHOD]();
    }
}

let object = new MyClass();
object.publicMethod();  // 输出 "This is a public method." 和 "This is a private method."
object[PRIVATE_METHOD]();  // 抛出TypeError异常，因为该方法是私有的

Dans cet exemple, nous privatisons la méthode privée en utilisant l'attribut de type Symbol, garantissant que la méthode privée n'est pas accessible en dehors de l'objet.

En bref, JavaScript n'a pas de méthodes privées directes, mais nous pouvons utiliser des fermetures, des conventions de dénomination ou des attributs de type Symbol pour implémenter indirectement les fonctions des méthodes privées. Dans le développement réel, nous devons choisir la manière la plus appropriée de mettre en œuvre l'encapsulation des données en fonction de la situation spécifique. #🎜🎜#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!