Well if I really have to, I would use this. Swift compiler supports some attributes on getters, so you can use @available(*, unavailable): public subscript(index: Int) -> T { @available(*, unavailable) get { fatalError(“You cannot read from this object.”) } set(v) { } } This will clearly deliver your intention to the code users.
The basic “private field with public getter and setter that do nothing but return or set the field” pattern is indeed completely pointless when it comes to encapsulation, except that it gives you a chance to change it later without changing the API. So don’t use that pattern unthinkingly. Carefully consider what operations you actually … Read more
Yes, this is intentional (a part of the spec). If an object has an own property (.property in your example), this property will be used and not an inherited one. If that property is existent, but is an accessor property without a getter, then undefined will be returned. Notice that this behaviour has not changed … Read more
private data members are generally considered good because they provide encapsulation. Providing getters and setters for them breaks that encapsulation, but it’s still better than public data members because there’s only once access point to that data. You’ll notice this during debugging. If it’s private, you know you can only modify the variable inside the … Read more
The documentation for every method that you listed is easly reachable from the documentation index . Anyway this may be a little extended reference: __get__, __set__ and __del__ are descriptors “In a nutshell, a descriptor is a way to customize what happens when you reference an attribute on a model.” [official doc link] They are … Read more
Apple states in the “Swift Programming Languages Documentation”: If the protocol only requires a property to be gettable, the requirement can be satisfied by any kind of property, and it is valid for the property to be also settable if this is useful for your own code. For this reason, the five following Playground code … Read more
You can’t do that. You can set setter/getters for properties of objects though. I advice you use ES5 Object.defineProperties though. of course this only works in modern browsers. var obj = function() { … Object.defineProperties(this, { “test”: { “get”: function() { … }, “set”: function() { … } } }); } obj.prototype.func = function() { … Read more
No, not for now 🙁 From the CoffeeScript FAQ: Q: Will you add feature X where feature X depends on a platform? A: No, implementation-specific features are not allowed as a policy. Everything that you write in CoffeeScript should be supported and runnable on any current JavaScript implementation (in practice, this means the lowest common … Read more
You can use the Outline view: Right-click on the method in the Outline view, and use “Open Call Hierarchy”. An other way to do it is to right-click on the annotation (@Setter for instance), and use “Open Call Hierarchy” on it, but it may not work with some annotations (like @Data).
Setters and getters have a performance overhead when not optimized out. They are almost always optimized out on compilers that do link time optimization. And on compilers that do not, if they have knowledge of the function body (ie not just a prototype) it will be optimized out. Just look up inline optimization. However, you … Read more