javascript - CoffeeScript: Getter/Setter en inicializadores de objetos

oop getter-setter

Question

ECMAScript nos permite definir getters o setters de la siguiente manera:

[texto / javascript]

var object = {
  property: 7,
  get getable() { return this.property + 1; },
  set setable(x) { this.property = x / 2; }
};

Puedo solucionar el problema si estoy usando una clase :

[text / coffeescript]

"use strict"

Function::trigger = (prop, getter, setter) ->
      Object.defineProperty @::,
              get: getter
              set: setter               

class Class
      property: ''''

      @trigger ''getable'', ->
               ''x''

      member: 0

Pero, ¿qué defineProperty si quiero definir el disparador en el objeto directamente , sin usar defineProperty / - ies . Quiero hacer algo como ( no funciona de esa manera):

[text / x-pseudo-coffeescript]

object =
  property: ''xhr''
  get getable: ''x''

Está funcionando en JavaScript sin ningún problema y no quiero que mis scripts retrocedan cuando uso CoffeeScript. ¿No hay una manera de hacer esto tan cómoda como en JavaScript / ECMAScript? Gracias.

Answer 1

Aquí hay otro enfoque para definir propiedades con getters y setters en CoffeeScript que mantiene una sintaxis relativamente limpia sin agregar nada al prototipo de Function global (que prefiero no hacer):

class Person
  constructor: (@firstName, @lastName) ->
  Object.defineProperties @prototype,
    fullName:
      get: -> "#{@firstName} #{@lastName}"
      set: (name) -> [@firstName, @lastName] = name.split '' ''

p = new Person ''Robert'', ''Paulson''
console.log p.fullName # Robert Paulson
p.fullName = ''Space Monkey''
console.log p.lastName # Monkey

Funciona bien con muchas propiedades. Por ejemplo, aquí hay una clase Rectangle que se define en términos de (x, y, ancho, alto), pero proporciona accesos para una representación alternativa (x1, y1, x2, y2):

class Rectangle                                     
  constructor: (@x, @y, @w, @h) ->
  Object.defineProperties @prototype,
    x1:
      get: -> @x
      set: (@x) ->
    x2:
      get: -> @x + @w
      set: (x2) -> @w = x2 - @x
    y1:
      get: -> @y
      set: (@y) ->
    y2:
      get: -> @y + @h
      set: (y2) -> @w = y2 - @y

r = new Rectangle 5, 6, 10, 11
console.log r.x2 # 15

Aquí está el código JavaScript correspondiente . ¡Disfrutar!

Answer 2

Como @curran, prefiero no modificar el prototipo de Function . Aquí es lo que hice en uno de mis proyectos:

Defina en alguna parte una función de utilidad que para una clase determinada devuelva 2 funciones que le permitan agregar fácilmente getters y setters en el prototipo de la clase:

gs = (obj) ->
  getter: (propName, getterFunction) ->
    Object.defineProperty obj.prototype, propName, 
      get: getterFunction
      configurable: true
      enumerable: true
  setter: (propName, setterFunction) ->
    Object.defineProperty obj.prototype, propName, 
      set: setterFunction
      configurable: true
      enumerable: true

gs significa g etter y s etter.

Luego, crea e importa las dos funciones configuradas para su clase:

class Dog
  { getter, setter } = gs @

  constructor: (name, age) -> 
    @_name = name
    @_age = age

  getter ''name'', -> @_name
  setter ''name'', (name) -> 
    @_name = name
    return

  getter ''age'', -> @_age
  setter ''age'', (age) -> 
    @_age = age
    return

Answer 3

Gracias a los otros que han ido antes. Muy en general y simplemente:

attribute = (self, name, getterSetterHash) ->
  Object.defineProperty self, name, getterSetterHash

class MyClass
  constructor: () ->
    attribute @, ''foo'',
      get: -> @_foo ||= ''Foo'' # Set the default value
      set: (who) -> @_foo = "Foo #{who}"

    attribute @, ''bar'',
      get: -> @_bar ||= ''Bar''

    attribute @, ''baz'',
      set: (who) -> @_baz = who


myClass = new MyClass()
alert(myClass.foo) # alerts "Foo"
myClass.foo = ''me'' # uses the foo setter
alert(myClass.foo) # alerts "Foo me"

Answer 4

No, no por ahora :(

De las preguntas frecuentes de CoffeeScript :

P: ¿Agregará la característica X donde la característica X depende de una plataforma?

R: No, las características específicas de la implementación no están permitidas como política. Todo lo que escriba en CoffeeScript debe ser compatible y ejecutable en cualquier implementación de JavaScript actual (en la práctica, esto significa que el denominador común más bajo es IE6). Por lo tanto, las características tales como las siguientes no se implementarán: getters & setters, yield.

Algunos problemas de GitHub sobre la sintaxis getter & setter: #64 , #451 , #1165 (hay una buena discusión en el último).

Personalmente creo que tener la sintaxis literal getter & setter sería una buena característica de defineProperty para CoffeeScript ahora que defineProperty es parte del estándar ECMAScript . La necesidad de getters & setters en JavaScript puede ser cuestionable, pero no está obligado a usarlas solo porque existan.

De todos modos, como Object.defineProperty notado, no es tan difícil implementar una función de contenedor conveniente que llame a Object.defineProperty para las declaraciones de clase. Yo personalmente usaría el enfoque sugerido here :

Function::property = (prop, desc) ->
  Object.defineProperty @prototype, prop, desc

class Person
  constructor: (@firstName, @lastName) ->
  @property ''fullName'',
    get: -> "#{@firstName} #{@lastName}"
    set: (name) -> [@firstName, @lastName] = name.split '' ''

p = new Person ''Robert'', ''Paulson''
console.log p.fullName # Robert Paulson
p.fullName = ''Space Monkey''
console.log p.lastName # Monkey

O bien, tal vez crear dos métodos diferentes:

Function::getter = (prop, get) ->
  Object.defineProperty @prototype, prop, {get, configurable: yes}

Function::setter = (prop, set) ->
  Object.defineProperty @prototype, prop, {set, configurable: yes}

class Person
  constructor: (@firstName, @lastName) ->
  @getter ''fullName'', -> "#{@firstName} #{@lastName}"
  @setter ''fullName'', (name) -> [@firstName, @lastName] = name.split '' ''

Para objetos simples, puede usar Object.defineProperty (u Object.defineProperties ;)) en el objeto en sí, como Jason propuso . Tal vez envolver eso en una pequeña función:

objectWithProperties = (obj) ->
  if obj.properties
    Object.defineProperties obj, obj.properties
    delete obj.properties
  obj

rectangle = objectWithProperties
  width: 4
  height: 3
  properties:
    area:
      get: -> @width * @height

console.log rectangle.area # 12
rectangle.width = 5
console.log rectangle.area # 15

Answer 5

También puede usar Object.defineProperty en objetos JSON rectos.

obj = {}
Object.defineProperty obj, ''foo'',
    get: ->
        return ''bar''

La notación get / set no funciona por varios motivos en CoffeeScript. Lo más importante es que el compilador no se ha diseñado para dar cuenta de la notación get / set.

Tenga en cuenta que get / set no es compatible con todos los navegadores (específicamente, IE). También tenga en cuenta que las nuevas normas ECMA (ECMAScript5) mencionan Object.defineProperty como la forma de definir propiedades con getters / setters.

Answer 6

Un enfoque alternativo:

get = (self, name, getter) ->
  Object.defineProperty self, name, {get: getter}

set = (self, name, setter) ->
  Object.defineProperty self, name, {set: setter}

prop = (self, name, {get, set}) ->
  Object.defineProperty self, name, {get: get, set: set}

class Demo 
  constructor: (val1, val2, val3) ->
    # getter only
    get @, ''val1'', -> val1
    # setter only
    set @, ''val2'', (val) -> val2 = val
    # getter and setter
    prop @, ''val3'', 
      get: -> val3
      set: (val) -> val3 = val