CoffeeScript中的私人成员?


84

有人知道如何在CoffeeScript中成为私有的非静态成员吗​​?目前,我正在执行此操作,该操作仅使用以下划线开头的公共变量来阐明不应在类外使用它:

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

  getName: -> @_name

将变量放在类中使其成为静态成员,但是如何使其变为非静态呢?甚至有可能没有得到“幻想”?

Answers:


20

甚至有可能没有得到“幻想”?

可悲的是,你必须是看中

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

请记住,“这只是JavaScript。”


1
...因此您必须像在JS中那样去做。当它藏在所有糖后面时,容易忘记它,谢谢!
thejh 2011年

4
那真的是私人的吗?您仍然可以在课堂外访问它。a = Thing('a')然后a.getName()返回该值,而a.getName =->'b'对其进行设置。
阿米尔(Amir)

4
@Amir:name仅在构造函数闭包内部可见。看一下要点:gist.github.com/803810
thejh 2011年

13
同样值得注意的是,这@getName = -> name似乎破坏了该getName函数的任何继承。
肯德尔·霍普金斯

12
这个答案是错误的:这里getName是公共的,name只能从构造函数中访问,因此它实际上不是对象的“私有”。
tothemario

203

类只是函数,因此它们创建范围。从外部看不到在此范围内定义的所有内容。

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

9
应当注意,这些私有变量不可用于子类。
Ceasar Bautista 2012年

45
还应当指出的是,“私人”的方法都需要这样调用foo.call(this),以便this成为该函数的实例。这就是为什么尝试在JavaScript中模拟经典继承会变得麻烦的原因。
乔恩·温菲尔德

3
另一个缺点是您将无法使用“私有”方法进行单元测试
。–

16
@nuc私有方法是通过调用它们的公共方法进行测试的实现细节,也就是说,私有方法不应进行单元测试。如果私有方法似乎应该可以单元测试,那么也许应该是公共方法。看到这个帖子了一个很好的解释,以及stackoverflow.com/questions/5750279/...
mkelley33

2
还应注意,您需要在“公共”函数中使用它们的位置上方定义“私有”变量。否则,CoffeeScript会感到困惑,并创建新的内部var声明以使其阴影化。
Andrew Miner 2014年

11

我想展示一些更奇特的东西

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

2

Vitaly的答案存在一个问题,那就是您无法定义要在作用域中唯一的变量,如果您以这种方式创建了一个私有名称,然后对其进行了更改,则该名称值将针对该类的每个实例而变化,所以有一种方法可以解决这个问题

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

我喜欢这个实现。有什么缺点吗?
Erik5388'1

2

这是一个利用此处其他答案的解决方案,以及https://stackoverflow.com/a/7579956/1484513。它将私有实例(非静态)变量存储在私有类(静态)数组中,并使用对象ID知道该数组的哪个元素包含属于每个实例的数据。

# 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

2

这里是最好的文章中,我发现了大约设置public static membersprivate static memberspublic and private members,和其他一些相关的东西。它涵盖了很多细节,并jscoffee比较。出于历史原因,这里是其中最好的代码示例:

# 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

1

这是在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

1

咖啡脚本中的“类”导致基于原型的结果。因此,即使您使用私有变量,它也会在实例之间共享。你可以这样做:

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'

但是要小心,将私有成员放在公共功能之前,因为coffee脚本会将公共功能作为对象返回。查看编译的Javascript:

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

  return {
    setName: function(name) {
      return privateName = name;
    },
    getName: function() {
      return privateName;
    }
  };
};

0

由于coffee脚本会编译为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

当然,这与使用闭包可以拥有的所有其他私有变量具有相同的局限性,例如,新添加的方法无法访问它们,因为它们不在同一范围内定义。


9
那是一个静态成员。e = new Animal(5);f = new Animal(1);e.test()提醒一个,我要五个。
thejh 2011年

@thejh哦,对不起,我现在看到错误,猜想昨天考虑这个问题为时已晚。
伊沃·韦策尔

@thejh发生在我身上,我已经尝试在答案中解决该问题。
iConnor 2014年

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类的优越性,因为您不能通过其他方式(通过再次使用extend())从以这种方式创建的类中继承。instanceof将停止工作,以这种方式创建的objecs将消耗更多的内存。另外,您不得使用newsuper关键字了。

关键是,每次实例化类时都必须创建闭包。纯CoffeeScript类中的成员闭包仅创建一次-即在构造类运行时“类型”时。


-3

如果您只想将私人成员与公共成员分开,则将其包装在$变量中

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

和使用 @$.requirements

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.