Home / Questions / 48387
Accepted
Edwin V
Asked: 2020-02-09 08:38:39 +0800 CST 2020-02-09 08:38:39 +0800 CST

Javascript 类中的私有方法

  • 772

我的问题是如何在 javascript 类中定义私有方法，以便不能直接访问它们。

class User {
  constructor(name, password, email) {
		this.name     = name;
		this.password = password;
		this.email    = email;
  }

  privado(){
  	console.log("Accediste a un metodo privado")
  }
}

var u = new User("usuario","123","[email protected]");
u.privado();

我尝试在构造函数之外定义变量，但它不起作用。

javascript

5 Answers

  1. JavaScript 实现面向对象编程的方式与 Java、C# 等语言不同。在 JavaScript 中，基本上没有封装的概念。即便如此，由于其极大的灵活性，您可以用一些独创性来模拟它。

    引用变量/函数

    它是最简单和最实用的。您在类外部创建函数或变量，在类内部创建引用。

    class User {
	publico () {
  	console.log('Soy un método público');
    privado(); // se ejecuta correctamente
  }
}

let pepito = new User();
pepito.publico();
pepito.privado(); // pepito.privado is not a function

function privado () {
    console.log('Soy un método privado');
}

    使用工厂

    请记住：在 Javascript中没有classes的概念。即使在 ES6 中，保留字的到来class仍然不存在。JavaScript 是一种原型语言。即使您使用新语法来创建“类”，您仍然会使用原型创建函数。

    当您想要实现私有变量或方法时，通常会使用这种形式。诀窍是返回一个对象，该对象引用要返回的对象中函数的变量和/或局部方法。这就是魔方的魔力closures。

    function User () {
  const privado = function () {
    console.log('Soy un método privado');
  }
  
  return {
    publico () {
      console.log('Soy un método público');
      privado(); // se ejecuta correctamente
    }
  }
}

let pepito = User();
pepito.publico();
pepito.privado(); // pepito.privado is not a function

    • 6
  2. Best Answer

    尝试这个，

    class User {
  constructor(name, password, email) {
		this.name     = name;
		this.password = password;
		this.email    = email;
        var privado_ = function(){
          console.log('realmente esto es privado');
        };
    
       this.privado = function(){
  	      console.log("Accediste a un metodo privado");
          privado_();
       }
  }

}

var u = new User("usuario","123","[email protected]");
u.privado();

    • 5

  3. 虽然我喜欢@jolsalazar 的回答，而且看起来很实用，但我想离开我解决这个问题的方式，这对我来说似乎更“优雅”：

    var Salute = (function (){

    // Esta función es nuestro constructor
    function Salute(lang){
        this._lang = lang;
    }

    // Este es nuestro método privado
    function Hi(){
        if(this._lang == "en"){
            alert('Hi, I am a private method');
        }else if(this._lang == "es"){
            alert('Hola, Yo soy un método privado');
        }
    }

    // Este es nuestro método público
    Salute.prototype.sayHi = function () {
        return Hi.call(this);
    }

    return Salute;

})();

var salute_es = new Salute('es');

salute_es.Hi(); 
// La consola nos mostrará que Hi(); 
// no es una función válida

salute_es.sayHi();  
// Nos saldrá un alert con el texto 
// 'Hola, Yo soy un método privado'

    让我解释一下我的代码：

    我们创建一个带有自调用函数的“对象”，并使用该方法“注入”一个新函数，并通过将上下文作为参数传递给调用函数将其“公开”。prototypethis

    应该注意的是javascript，没有保留字，例如public或private在其中定义方法Class，因此必须执行一种类型的“hack”，如上所示。

    • 5

  4. 尽管 JavaScript 不是面向对象的语言，但我们可以更深入地考虑私有方法的定义。

    私有方法是那些可以从类的方法调用但不能从类外部调用的方法。

    首先要做的是从构造函数中省略 this 关键字。

    我们定义 private(); 和一个名为 method() 的公共方法；它调用私有方法，这将是我们可以从外部 javascript 方法调用的方法。

    这样，请记住变量和方法与 this 是公共的，而 var 它们是私有的。

    class User {
 
 constructor(name, password, email) {
		var name     = name;
		var password = password;
		var email    = email;
        var privado  = function() { 
          console.log("Accediste a un metodo privado"); 
        }
        
        this.getPrivado = function(){ privado(); }
  }
  
}

var u = new User("usuario","123","[email protected]");
u.getPrivado();

    • 5

  5. 效果很好的方法是在前面实现类成员 #

    export class Ceil
{
    // miembros privados
    #intm = 0;
    #intn = 0;
    #inta = 0;

    constructor (intm, intn, inta)
    {
        this.#intm = intm;
        this.#intn = intn;
        this.#inta = inta;
    }

    // metodo publico
    printNumCeil = () =>
    {
        var intHorCeil;
        var intVertCeil;

        intHorCeil = this.#getNumCeil(this.#intm, this.#inta);
        intVertCeil = this.#getNumCeil(this.#intn, this.#inta);

        console.log(intHorCeil * intVertCeil);
    };

    // metodo privado
    #getNumCeil = (intDimCeil, intDimArea) =>
    {
        return (intDimArea + intDimCeil - 1) / intDimArea;
    }; 
}
    • 2