CoffeeScript: Getter / Setter en Inicializadores de objetos

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 función global (lo 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 de rectángulo que se define en términos de (x, y, width, height), pero proporciona accesores 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 JavaScript correspondiente código. ¡Que lo disfrutes!

Puede usar Object.defineProperty también en objetos JSON rectos.

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

La notación get/set no funciona por varias razones en CoffeeScript. El mayor es que el compilador no ha sido construido para tener en cuenta 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 los nuevos estándares ECMA (ECMAScript5) menciona Object.defineProperty como la forma de definir propiedades con getters / setters.

Al igual que @curran, prefiero no modificar el prototipo Function. Aquí está lo que hice en uno de mis proyectos :

Defina en algún lugar una función de utilidad que para una clase dada devuelve 2 funciones que le permiten 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 representa getter y setter.

Luego, compila 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

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

Gracias a los otros que han ido antes. Muy 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"