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
    }
});