Как реализовать модификаторы C# доступа в JavaScript? ⇐ C#

[Anonymous]

• summary < /strong> < /p>
  
  Я пытался правильно достичь наследования и инкапсуляции в JavaScript, как на языке на основе класса, таком как C#. < /p>
  
  Уродливая часть заключается в том, что защищенные участники имеют несколько копий в частных экземплярах, которые доступны только через закрытие, и у меня нет идеи, кроме обновления этих участников к частным экземплярам.
  
  Если это возможно, я хочу избавиться как от передачи , так и передачи в моем коде function.extend .
• обновление
  Для людей, которые заинтересованы в цитировании или исследовании, вот репозиторий исходного кода:
  
  https://github.com/kenkins/function.extend>
  

  Код: Выделить всё

  public

  и частные модификаторы не так сложно достичь; Но с наследством, защищенная значительно сложна. Тем не менее, это не рекомендуется связано с JavaScript, большинство статей, которые я прочитал, говорится в префиксе со специальным персонажем и документируйте его . < /p>
  
  Но, кажется, я настойчив, чтобы сделать JavaScript для моделирования языков на основе классов. Я украл эту идею и реализован на моем пути, код находится в задней части этого поста. < /p>
  
  Идея сцены состоит в том, чтобы установить более высокую доступность с более высоким прототипом и получить доступ к самой высокой с закрытием.
  
  Скажите, что у нас есть три прототипа A , d и g , он выглядит как
  
  
  
  
  The closure for accessing the private instance, это ['' '] . Требуется аргумент, который предназначен для определения класса. Владелец модификаторов - это просто идентификатор класса, названный y in function.extend и _ В тестовом коде его не следует выявлять вне объявления класса. Он также используется в качестве ярлыка этого ['' '] . < /p>
  

  Код: Выделить всё

  _['base']

  на самом деле является не только базовым конструктором, но и частным создателем экземпляров. Это создает частные экземпляры и обновляет это ['' '] для каждого конструктора с наследством, поэтому его всегда следует вызывать в конструкторах. < /p>
  
  Хотя частный экземпляр будет иметь доступ общедоступных членов, его не следует использовать для их изменения, поскольку это ['' '] < /code> не гарантируется, что при выходе к общественным членам. Но доступ к частному экземпляру; Недавние вспоминают о последнем доступном частном экземпляре и обновите охраняемых участников, если они изменяются. < /p>
  
  Мой вопрос: как я могу избавиться от такого рода освежающих охраняемых членов? Существуют ли лучшие идеи для достижения инкапсуляции более реалистичной? < /p> < /li>
  < /ul>
  
  
  
  
  function.extend < /strong> < /p>
  

  Код: Выделить всё

  Function.extend=function(base, factory) {
  factory.call(initializeClass);
  updateStaticMembersOfDerivedInnerClasses(y['public'].constructor);
  transfer(y['protected'], y['public']);
  return y['public'].constructor;
  
  function y($this) {
  return $this[''](y);
  }
  
  function transfer(target, source, descriptor) {
  if(target!==source?
  'undefined'!==typeof target?
  'undefined'!==typeof source:
  false:false) {
  var keys='undefined'!==typeof descriptor? descriptor:source;
  
  for(var key in keys) {
  if(Object.prototype.hasOwnProperty.call(source, key)) {
  target[key]=source[key];
  }
  }
  }
  }
  
  function updateStaticMembersOfDerivedInnerClasses(outer) {
  var member, inner;
  
  for(var key in outer) {
  if(Object.prototype.hasOwnProperty.call(outer, key)?
  (member=outer[key]) instanceof outer?
  outer!==(inner=member.constructor):
  false:false) {
  transfer(inner, outer);
  }
  }
  }
  
  function initializeInstance() {
  var $this=Object.create(y['private']);
  var derivedGet=this[''];
  var recent=$this;
  
  this['']=function(x) {
  var value=y!==x? derivedGet.call(this, x):$this;
  
  if(value!==recent) {
  transfer(value, recent, x['protected']);
  recent=value;
  }
  
  transfer(value, this);
  return value;
  };
  
  base.apply(this, arguments);
  $this['']=this[''];
  }
  
  function initializeClass(derived) {
  y['public']=Object.create(base.prototype);
  y['public'].constructor=derived;
  
  if(Object.prototype.hasOwnProperty.call(base, 'transmit')) {
  base.transmit(y);
  }
  else {
  y['protected']=Object.create(y['public']);
  }
  
  y['private']=Object.create(y['protected']);
  y['base']=initializeInstance;
  transfer(derived, base);
  
  derived.transmit=function(x) {
  if(x['public'] instanceof derived) {
  x['protected']=Object.create(y['protected']);
  x['protected'].constructor=x['public'].constructor;
  }
  };
  
  derived.prototype=y['public'];
  return y;
  }
  };
  

• тестовый код [/b]
  
  'use strict';
  
  var BaseClass=Function.extend(Object, function () {
  var _=this(BaseClass);
  
  var NestedClass=Function.extend(BaseClass, function () {
  var _=this(NestedClass);
  
  function NestedClass(x, y, z) {
  _['base'].apply(this, arguments);
  _(this).Y=y;
  _(this).Z=z;
  }
  
  _['public'].SetX=function (x) {
  _(this).InternalSetX(x);
  };
  
  _['public'].GetX=function () {
  return _(this).InternalGetX();
  };
  
  _['public'].GetY=function () {
  return _(this).Y;
  };
  
  _['public'].SetZ=function (z) {
  _(this).Z=z;
  };
  
  _['public'].GetZ=function () {
  return _(this).Z;
  };
  
  _['private'].Y=0;
  });
  
  function BaseClass(x) {
  _['base'].apply(this, arguments);
  _(this).X=x;
  }
  
  _['protected'].InternalSetX=function (x) {
  _(this).X=x;
  };
  
  _['protected'].InternalGetX=function () {
  return _(this).X;
  };
  
  _['private'].X=0;
  _['protected'].Z=0;
  
  BaseClass.Sample=new NestedClass(1, 2, 3);
  });
  
  var DerivedClass=Function.extend(BaseClass, function () {
  var _=this(DerivedClass);
  
  function DerivedClass(x, y, z) {
  _['base'].apply(this, arguments);
  }
  });
  
  var o=DerivedClass.Sample;
  alert(o.GetX());
  alert(o.GetY());
  alert(o.GetZ());
  o.SetX(3);
  o.SetZ(1);
  alert(o.GetX());
  alert(o.GetY());
  alert(o.GetZ());

Подробнее здесь: https://stackoverflow.com/questions/211 ... javascript