带有隐私的伪经典继承? [英] Pseudo-classical inheritance with privacy?

问题描述

在 JavaScript: The Good Parts 中，Crockford 认为使用伪经典继承模式的缺点之一是它公开暴露实例变量.

In JavaScript: The Good Parts, Crockford argues that one of the downsides of using the pseudo-classical pattern of inheritance is that it publicly exposes instance variables.

例如:

var Ball = function(width, color) {
  this.width = width;
  this.color = color;
}

var redBall = new Ball(5, "red");
redBall.width = 12; // Changes width to 12

现在，如果我希望球的宽度是私有的怎么办?

Now, what if I want the width of the ball to be private?

这是我尝试过的:

var Ball = function(width, color) {
  this.getWidth = function() { return width; }
  this.color = color;
}

var redBall = new Ball(5, "red");

问题是我们仍然可以更改 this.getWidth 并且可能有依赖它的原型方法.

Problem with that is we can still change this.getWidth and there may be prototype methods that rely on it.

那……

var Ball = function(width, color) {
  return {
    getWidth: function() { return width; },
    color: color
  }
}

var redBall = new Ball(5, "red");

问题在于原型方法不再可以访问实例变量.它也更接近于继承的功能模式，但使用 new 运算符具有更多的间接性.

Problem with that is that the prototype methods no longer have access to the instance variables. It's also closer to the functional pattern of inheritance, but with more indirection using the new operator.

那么如何使用伪经典继承模式实现隐私呢?这甚至可能吗?

So how do I achieve privacy using the pseudo-classical inheritance pattern? Is this even possible?

推荐答案

回答你的问题；拥有特定私有成员的唯一方法是让成员和特权函数(可以访问它们的函数)在同一范围内.这意味着它们都必须在构造函数体中(var my private...this.myPrivileged=function(){ console.log (myPrivate...) 或在带有闭包对象的 IIFE 中跟踪 实例及其私有.

To answer your question; the only way to have intace specific private members is to have both the members and privileged functions (functions that can access them) in the same scope. This means they all have to be in the constructor body (var my private...this.myPrivileged=function(){ console.log (myPrivate...) or in a IIFE with a closure object keeping track of instances and their privates.

当返回一个私有对象时，你已经失去了隐私，因为调用代码可以改变你的私有值.为了防止这种情况，您必须深度复制该值并返回该值.

When returning an object private you already loose privacy because the calling code can mutate your private value. To prevent this you have to deep copy the value and return that.

要在原型上拥有私有数据，私有数据将被共享.这是因为在声明您的原型和私有成员时不知道该实例.

To have privates on the prototype the privates will be shared. This because the instance is not known when declaring your prototype and private members.

这是因为 JavaScript 没有私有修饰符，只能通过闭包来模拟它们.

This is because JavaScript doesn't have a private modifier and only simulates them through closures.

可以使用原型作为实例特定受保护变量的一种模式是使用 Crockford 的盒子示例.

One pattern that can use prototype for instance specific protected variables is using Crockford's box example.

所有受保护的东西都放在一个只能用钥匙打开的盒子里，钥匙可以通过关闭所有 IIFE 中定义的原型成员获得.

All protecteds are put in a box that can only be opened with a key, the key is available through closures to all prototype members defined in the IIFE.

因为在创建原型时不知道实例，所以您必须从实例调用 initProtecteds 以创建实例特定的受保护成员.

Because the instance isn't known when creating prototype you have to invoke initProtecteds from the instance in order to create instance specific protected members.

Animal 中使用了包含一个名为medicalHistory 的示例受保护实例成员的最少代码.

Minimal code with an example protected instance member called medicalHistory is used in Animal.

function makeBox(key){
  var ret = {};
  return {
    get : function(pKey){
      if(pKey===key){
        return ret;
      }
      return false;
    }
  }
};

var Person = function(args){
  args = args || {};
  this.name = args.name || "Nameless Person";
  this.initProtecteds();
};

//using IIFE to define some members on Person.prototype
//  these members and only these members have access to 
//  the passed object key (through closures)
//  later the key is used to create a box for each instance
//  all boxes use the same key so instances of same type
//  can access each other's protected members and instances
//  inheriting from Person can do so too, extending parent methods
//  will be trickier, no example for that is given in this code
(function(key){
  //private shared member
  var privateBehavior =  function(instance,args){
    //when you invoke this from public members you can pass
    //  the instance or use call/apply, when using call/apply
    //  you can refer to this as the current instance, when
    //  passing it as an argument then instance will 
    //  be the current instance
    console.log("private shared invoked");
  };
  //set default _protecteds to false so init knows
  //  it has not been initialised and needs to be shadowed
  //  with a box
  Person.prototype._protecteds=false;
  Person.prototype.getMedicalHistory = function(){
    //Maybe run some code that will check if you can access
    //  medical history, invoking a private method
    privateBehavior(this,{});
    var protectedObject  = this._protecteds.get(key);
    //if medicalHistory is an object the calling code
    //  can now mutate it
    return protectedObject.medicalHistory;
  };
  Person.prototype.hasSameDesease = function(person){
    //this Person instance should be able to see
    //  medical history of another Person instance
    return person._protecteds.get(key);
  };
  Person.prototype.getArr = function(){
    //Returns protecteds.get(key).arr so we can
    //  mutate it and see if protecteds are instance
    //  specific
    return this._protecteds.get(key).arr;
  };
  Person.prototype.initProtecteds =  function(){
    //only create box if it hasn't been created yet
    if(this._protecteds!==false)
      return;
    //use the same key for all instance boxes, one instance
    //  can now open another instance's box
    this._protecteds=makeBox(key);
    //retreive the object held by the box
    var protectedObject  = this._protecteds.get(key);
    //add protected members by mutating the object held
    //   by the box
    protectedObject.medicalHistory = "something";    
    protectedObject.arr = [];
    //protectedObject is no longer needed
    protectedObject=null;
  };
}({}));
var Animal = function(){
  this.initProtecteds();
};
(function(key){
  Animal.prototype._protecteds=false;
  Animal.prototype.initProtecteds =  function(){
    if(this._protecteds!==false)
      return;
    this._protecteds=makeBox(key);
    var protectedObject  = this._protecteds.get(key);
    protectedObject.medicalHistory = "something";    
  };
}({}));
var Employee = function(args){
  //re use Person constructor
  Person.call(this,args);
};
//set up prototype part of inheritance
Employee.prototype = Object.create(Person.prototype);
//repair prototype.constructor to point to the right function
Employee.prototype.constructor = Employee;

var ben = new Person({name:"Ben"});
var nameless = new Person();
console.log(ben.getMedicalHistory());//=something
//key is in closure and all privileged methods are in that closure
//  since {} !== {} you can't open the box unless you're in the closure
//  or modify the code/set a breakpoint and set window.key=key in the closure
console.log(ben._protecteds.get({}));//=false
//One Person instance can access another instance's protecteds
//  Objects that inherit from Person are same
console.log(ben.hasSameDesease(nameless));//=Object { medicalHistory="something"}
var lady = new Animal();
//An Animal type object cannot access a Person protected members
console.log(ben.hasSameDesease(lady));//=false
var jon = new Employee({name:"Jon"});
console.log(ben.hasSameDesease(jon));//=Object { medicalHistory="something"}
//making sure that protecteds are instance specific
ben.getArr().push("pushed in ben");
console.log(jon.getArr());
console.log(nameless.getArr());
console.log(ben.getArr());

这篇关于带有隐私的伪经典继承?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！