javascript - react - Cómo definir setter/getter en prototipo

react getters and setters

Question

EDITAR Oct 2016 : tenga en cuenta que esta pregunta se realizó en 2012. Cada mes más o menos alguien agrega una nueva respuesta o comentario que refuta una respuesta, pero realmente no tiene sentido hacerlo ya que la pregunta probablemente esté desactualizada (recuerde, fue para Gnome Javascript para escribir extensiones gnome-shell, no cosas del navegador, que es bastante específico).

Siguiendo mi pregunta anterior sobre cómo hacer subclases en Javascript, estoy creando una subclase de una superclase como esta:

function inherits(Child,Parent) {
var Tmp = function {};
Tmp.prototype = Parent.prototype;
Child.prototype = new Tmp();
Child.prototype.constructor = Child;
}
/* Define subclass */
function Subclass() {
Superclass.apply(this,arguments);
/* other initialisation */
}
/* Set up inheritance */
inherits(Subclass,Superclass);
/* Add other methods */
Subclass.prototype.method1 = function ... // and so on.

Mi pregunta es, ¿cómo puedo definir un setter / getter en el prototipo con esta sintaxis?

Lo solía hacer:

Subclass.prototype = {
__proto__: Superclass.prototype,
/* other methods here ... */
get myProperty() {
// code.
}
}

Pero obviamente lo siguiente no funcionará:

Subclass.prototype.get myProperty() { /* code */ }

Estoy usando GJS (GNOME Javascript), y el motor está destinado a ser más o menos el mismo que el de Mozilla Spidermonkey. Mi código no está destinado para un navegador, siempre y cuando sea compatible con GJS (supongo que eso significa Spidermonkey?), No me importa si no es compatible.

Answer 1

Creo que querías hacer esto:

function Unit() {
this._data; // just temp value
}
Unit.prototype = {
get accreation() {
return this._data;
},
set accreation(value) {
this._data = value
},
}
Unit.prototype.edit = function(data) {
this.accreation = data; // setting
this.out();
};
Unit.prototype.out = function() {
alert(this.accreation); // getting
};
var unit = new Unit();
unit.edit(''setting and getting'');
function Field() {
// children
}
Field.prototype = Object.create(Unit.prototype);
Field.prototype.add = function(data) {
this.accreation = data; // setting
this.out();
}
var field1 = new Field();
field1.add(''new value for getter&setter'');
var field2 = new Field();
field2.out();// because field2 object has no setting

Answer 2

Especifique un getter o un setter en constructores mediante el método Object.defineProperty (). Este método toma tres argumentos: el primer argumento es el objeto para agregar la propiedad, el segundo es el nombre de la propiedad y el tercero es el descriptor de la propiedad. Por ejemplo, podemos definir el constructor para nuestro objeto persona de la siguiente manera:

var Employee = (function() {
function EmployeeConstructor() {
this.first = "";
this.last = "";
Object.defineProperty(
this,
"fullName", {
get: function() {
return this.first + " " +
this.last;
},
set: function(value) {
var parts = value.toString().split(" ");
this.name = parts[0] || "";
this.last = parts[1] || "";
}
});
}
return
EmployeeConstructor;
}());

El uso de Object.defineProperty () otorga más control sobre nuestra definición de propiedad. Por ejemplo, podemos especificar si la propiedad que estamos describiendo se puede eliminar o redefinir dinámicamente, si se puede cambiar su valor, y así sucesivamente.

Podemos tales restricciones estableciendo las siguientes propiedades del objeto descriptor:

• escribible: este es un booleano que dice si se puede cambiar el valor de la propiedad; su valor predeterminado es falso
• configurable: es un booleano que dice si el descriptor de la propiedad se puede cambiar o la propiedad en sí se puede eliminar; su valor predeterminado es falso
• enumerable: es un booleano que indica si se puede acceder a la propiedad en un bucle sobre las propiedades del objeto; su valor predeterminado es falso
• valor: Esto representa el valor asociado a la propiedad; su valor predeterminado no está definido

Answer 3

Para definir setters y getters "dentro del prototipo del objeto" tienes que hacer algo como esto:

Object.defineProperties(obj.__proto__, {"property_name": {get: getfn, set: setfn}})

Puede acotar eso con una función de utilidad:

//creates get/set properties inside an object''s proto
function prop (propname, getfn, setfn) {
var obj = {};
obj[propname] = { get: getfn, set: setfn };
Object.defineProperties(this, obj);
}
function Product () {
this.name = "Product";
this.amount = 10;
this.price = 1;
this.discount = 0;
}
//how to use prop function
prop.apply(Product.prototype, ["total", function(){ return this.amount * this.price}]);
pr = new Product();
console.log(pr.total);

Aquí usamos prop.apply para establecer el contexto Product.prototype como "this" cuando lo llamamos.

Con este código, finaliza con una propiedad get / set dentro del prototipo del objeto, no la instancia, como la pregunta.

(Probado Firefox 42, Chrome 45)

Answer 4

Usando una declaración literal de objeto (la forma más simple):

var o = {
a: 7,
get b() {
return this.a + 1;
},
set c(x) {
this.a = x / 2
}
};

Usando Object.defineProperty (en los navegadores modernos que soportan ES5):

Object.defineProperty(o, "myProperty", {
get: function myProperty() {
// code
}
});

O usando __defineGetter__ y __defineSetter__ ( DEPRECATED ):

var d = Date.prototype;
d.__defineGetter__("year", function() { return this.getFullYear(); });
d.__defineSetter__("year", function(y) { this.setFullYear(y); });

Answer 5

Use Object.defineProperty en Subclass.prototype . También hay __defineGetter__ y __defineSetter__ disponibles en algunos navegadores, pero están en desuso. Para su ejemplo, sería:

Object.defineProperty(Subclass.prototype, "myProperty", {
get: function myProperty() {
// code
}
});