Частные участники в CoffeeScript?

Кто-нибудь знает, как сделать частные нестатические элементы в CoffeeScript? В настоящее время я делаю это, которая просто использует открытую переменную, начинающуюся с подчеркивания, чтобы уточнить, что ее нельзя использовать вне класса:

class Thing extends EventEmitter
  constructor: (@_name) ->

  getName: -> @_name

Помещение переменной в класс делает его статическим членом, но как я могу сделать его нестатичным? Возможно ли это даже без "фантазии"?

85 голосов | спросил thejh 14 Jam1000000amFri, 14 Jan 2011 00:43:23 +030011 2011, 00:43:23

11 ответов


0
  

Возможно ли это даже без "фантазии"?

К сожалению, вам нужно быть модным .

class Thing extends EventEmitter
  constructor: (name) ->
    @getName = -> name

Помните, "Это просто JavaScript."

ответил matyr 14 Jam1000000amFri, 14 Jan 2011 02:02:14 +030011 2011, 02:02:14
0

классы - это просто функции, поэтому они создают области видимости. все, что определено внутри этой области, не будет видно снаружи.

class Foo
  # this will be our private method. it is invisible
  # outside of the current scope
  foo = -> "foo"

  # this will be our public method.
  # note that it is defined with ':' and not '='
  # '=' creates a *local* variable
  # : adds a property to the class prototype
  bar: -> foo()

c = new Foo

# this will return "foo"
c.bar()

# this will crash
c.foo

coffeescript компилирует это в следующее:

(function() {
  var Foo, c;

  Foo = (function() {
    var foo;

    function Foo() {}

    foo = function() {
      return "foo";
    };

    Foo.prototype.bar = function() {
      return foo();
    };

    return Foo;

  })();

  c = new Foo;

  c.bar();

  c.foo();

}).call(this);
ответил Vitaly Kushner 1 ThuEurope/Moscow2011-12-01T03:12:24+04:00Europe/Moscow12bEurope/MoscowThu, 01 Dec 2011 03:12:24 +0400 2011, 03:12:24
0

Я хотел бы показать что-то еще более изумительное

class Thing extends EventEmitter
  constructor: ( nm) ->
    _name = nm
    Object.defineProperty @, 'name',
      get: ->
        _name
      set: (val) ->
        _name = val
      enumerable: true
      configurable: true

Теперь вы можете сделать

t = new Thing( 'Dropin')
#  members can be accessed like properties with the protection from getter/setter functions!
t.name = 'Dragout'  
console.log t.name
# no way to access the private member
console.log t._name
ответил Tim Wu 26 thEurope/Moscowp30Europe/Moscow09bEurope/MoscowWed, 26 Sep 2012 09:54:02 +0400 2012, 09:54:02
0

В ответе Виталия есть одна проблема, заключающаяся в том, что вы не можете определить переменные, которые должны быть уникальными для области, если вы сделали таким образом личное имя, а затем изменили его, значение имени будет меняться для каждого экземпляра класса, так что есть один способ решить эту проблему

# create a function that will pretend to be our class 
MyClass = ->

    # this has created a new scope 
    # define our private varibles
    names = ['joe', 'jerry']

    # the names array will be different for every single instance of the class
    # so that solves our problem

    # define our REAL class
    class InnerMyClass 

        # test function 
        getNames: ->
            return names;

    # return new instance of our class 
    new InnerMyClass

Доступ к массиву имен извне невозможен, если вы не используете getNames

Проверьте это

test = new MyClass;

tempNames = test.getNames()

tempNames # is ['joe', 'jerry']

# add a new value 
tempNames.push 'john'

# now get the names again 
newNames = test.getNames();

# the value of newNames is now 
['joe', 'jerry', 'john']

# now to check a new instance has a new clean names array 
newInstance = new MyClass
newInstance.getNames() # === ['joe', 'jerry']


# test should not be affected
test.getNames() # === ['joe', 'jerry', 'john']

Скомпилированный Javascript

var MyClass;

MyClass = function() {
  var names;
  names = ['joe', 'jerry'];
  MyClass = (function() {

    MyClass.name = 'MyClass';

    function MyClass() {}

    MyClass.prototype.getNames = function() {
      return names;
    };

    return MyClass;

  })();
  return new MyClass;
};
ответил iConnor 24 FebruaryEurope/MoscowbMon, 24 Feb 2014 07:02:55 +0400000000amMon, 24 Feb 2014 07:02:55 +040014 2014, 07:02:55
0

Вот решение, основанное на нескольких других ответах, а также https://stackoverflow.com/a/7579956/1484513 . Он хранит частные (нестатические) переменные экземпляра в массиве частного (статического) класса и использует идентификатор объекта, чтобы узнать, какой элемент этого массива содержит данные, принадлежащие каждому экземпляру.

# Add IDs to classes.
(->
  i = 1
  Object.defineProperty Object.prototype, "__id", { writable:true }
  Object.defineProperty Object.prototype, "_id", { get: -> @__id ?= i++ }
)()

class MyClass
  # Private attribute storage.
  __ = []

  # Private class (static) variables.
  _a = null
  _b = null

  # Public instance attributes.
  c: null

  # Private functions.
  _getA = -> a

  # Public methods.
  getB: -> _b
  getD: -> __[@._id].d

  constructor: (a,b,@c,d) ->
    _a = a
    _b = b

    # Private instance attributes.
    __[@._id] = {d:d}

# Test

test1 = new MyClass 's', 't', 'u', 'v'
console.log 'test1', test1.getB(), test1.c, test1.getD()  # test1 t u v

test2 = new MyClass 'W', 'X', 'Y', 'Z'
console.log 'test2', test2.getB(), test2.c, test2.getD()  # test2 X Y Z

console.log 'test1', test1.getB(), test1.c, test1.getD()  # test1 X u v

console.log test1.a         # undefined
console.log test1._a        # undefined

# Test sub-classes.

class AnotherClass extends MyClass

test1 = new AnotherClass 's', 't', 'u', 'v'
console.log 'test1', test1.getB(), test1.c, test1.getD()  # test1 t u v

test2 = new AnotherClass 'W', 'X', 'Y', 'Z'
console.log 'test2', test2.getB(), test2.c, test2.getD()  # test2 X Y Z

console.log 'test1', test1.getB(), test1.c, test1.getD()  # test1 X u v

console.log test1.a         # undefined
console.log test1._a        # undefined
console.log test1.getA()    # fatal error
ответил Waz 23 72014vEurope/Moscow11bEurope/MoscowSun, 23 Nov 2014 16:35:31 +0300 2014, 16:35:31
0

Вот лучшая статья, которую я нашел об установке public static members, private static members, public and private members и некоторые другие связанные вещи. Он охватывает много деталей и js против coffee Сравнение. И по историческим причинам вот лучший пример кода из этого:

# CoffeeScript

class Square

    # private static variable
    counter = 0

    # private static method
    countInstance = ->
        counter++; return

    # public static method
    @instanceCount = ->
        counter

    constructor: (side) ->

        countInstance()

        # side is already a private variable, 
        # we define a private variable `self` to avoid evil `this`

        self = this

        # private method
        logChange = ->
            console.log "Side is set to #{side}"

        # public methods
        self.setSide = (v) ->
            side = v
            logChange()

        self.area = ->
            side * side

s1 = new Square(2)
console.log s1.area()   # output 4

s2 = new Square(3)
console.log s2.area()   # output 9

s2.setSide 4            # output Side is set to 4
console.log s2.area()   # output 16

console.log Square.instanceCount() # output 2
ответил plunntic iam 1 J0000006Europe/Moscow 2015, 17:41:39
0

Вот как вы можете объявить приватные нестатические элементы в Coffeescript
Для получения полной информации вы можете посмотреть на https://github.com/vhmh2005/jsClass

class Class

  # private members
  # note: '=' is used to define private members
  # naming convention for private members is _camelCase

  _privateProperty = 0

  _privateMethod = (value) ->        
    _privateProperty = value
    return

  # example of _privateProperty set up in class constructor
  constructor: (privateProperty, @publicProperty) ->
    _privateProperty = privateProperty
ответил Hung Vo 17 J000000Thursday14 2014, 12:47:14
0

«класс» в сценариях кофе приводит к результату на основе прототипа. Так что даже если вы используете закрытую переменную, она распределяется между экземплярами. Вы можете сделать это:

EventEmitter = ->
  privateName = ""

  setName: (name) -> privateName = name
  getName: -> privateName

.. ведет к

emitter1 = new EventEmitter()
emitter1.setName 'Name1'

emitter2 = new EventEmitter()
emitter2.setName 'Name2'

console.log emitter1.getName() # 'Name1'
console.log emitter2.getName() # 'Name2'

Но будьте осторожны, чтобы поместить закрытые члены перед общедоступными функциями, потому что сценарий кофе возвращает общедоступные функции как объект. Посмотрите на скомпилированный Javascript:

EventEmitter = function() {
  var privateName = "";

  return {
    setName: function(name) {
      return privateName = name;
    },
    getName: function() {
      return privateName;
    }
  };
};
ответил Stefan Dohren 6 PM00000060000005431 2015, 18:42:54
0

Поскольку сценарий кофе компилируется в JavaScript, единственный способ иметь закрытые переменные - через замыкания.

class Animal
  foo = 2 # declare it inside the class so all prototypes share it through closure
  constructor: (value) ->
      foo = value

  test: (meters) ->
    alert foo

e = new Animal(5);
e.test() # 5

Это скомпилируется через следующий JavaScript:

var Animal, e;
Animal = (function() {
  var foo; // closured by test and the constructor
  foo = 2;
  function Animal(value) {
    foo = value;
  }
  Animal.prototype.test = function(meters) {
    return alert(foo);
  };
  return Animal;
})();

e = new Animal(5);
e.test(); // 5

Конечно, это имеет те же ограничения, что и все другие частные переменные, которые вы можете иметь с помощью замыканий, например, недавно добавленные методы не имеют к ним доступа, поскольку они не были определены в той же области.

ответил Ivo Wetzel 14 Jam1000000amFri, 14 Jan 2011 01:06:12 +030011 2011, 01:06:12
0

Вы не можете сделать это легко с классами CoffeeScript, потому что они используют шаблон конструктора Javascript для создания классов.

Тем не менее, вы можете сказать что-то вроде этого:

callMe = (f) -> f()
extend = (a, b) -> a[m] = b[m] for m of b; a

class superclass
  constructor: (@extra) ->
  method: (x) -> alert "hello world! #{x}#{@extra}"

subclass = (args...) -> extend (new superclass args...), callMe ->
  privateVar = 1

  getter: -> privateVar
  setter: (newVal) -> privateVar = newVal
  method2: (x) -> @method "#{x} foo and "

instance = subclass 'bar'
instance.setter 123
instance2 = subclass 'baz'
instance2.setter 432

instance.method2 "#{instance.getter()} <-> #{instance2.getter()} ! also, "
alert "but: #{instance.privateVar} <-> #{instance2.privateVar}"

Но вы теряете величие классов CoffeeScript, потому что вы не можете наследовать от класса, созданного таким образом, любым другим способом, кроме повторного использования extended (). instanceof перестанет работать, а созданные таким образом объекты потребляют немного больше памяти. Кроме того, вы не должны больше использовать ключевые слова new и super .

Дело в том, что замыкания должны создаваться каждый раз, когда создается экземпляр класса. Закрытия членов в чистых классах CoffeeScript создаются только один раз, то есть, когда создается «тип» времени выполнения класса.

ответил Jaakko Salomaa 3 J0000006Europe/Moscow 2012, 00:59:09
0

Если вы хотите отделить только частные члены от общедоступных, просто поместите их в переменную $ variable

$:
        requirements:
              {}
        body: null
        definitions: null

и используйте @$.requirements

ответил borovsky 19 FebruaryEurope/MoscowbTue, 19 Feb 2013 20:11:20 +0400000000pmTue, 19 Feb 2013 20:11:20 +040013 2013, 20:11:20

Похожие вопросы

Популярные теги

security × 330linux × 316macos × 2827 × 268performance × 244command-line × 241sql-server × 235joomla-3.x × 222java × 189c++ × 186windows × 180cisco × 168bash × 158c# × 142gmail × 139arduino-uno × 139javascript × 134ssh × 133seo × 132mysql × 132