For POD data members, it makes no difference, it’s just a matter of style. For class members which are classes, then it avoids an unnecessary call to a default constructor. Consider: class A { public: A() { x = 0; } A(int x_) { x = x_; } int x; }; class B { public: … Read more
I would suggest that you also create a unified interface (or even an abstract base class) for the decorators and the objects you want decorated. To continue the above example provided you could have something like: interface IDecoratedText { public function __toString(); } Then of course modify both Text and LeetText to implement the interface. … Read more
You cannot use “use” where you are using it. The “use” keyword is either in front of a class definition to import other classes/interfaces/traits into it’s own namespace, or it is inside the class (but not inside a method) to add traits to the class. <?php namespace Foo; use Different\Class; // use can go here … Read more
Preface: POP and OOP are not mutually exclusive. They’re design paradigms that are greatly related. The primary aspect of POP over OOP is that is prefers composition over inheritance. There are several benefits to this. In large inheritance hierarchies, the ancestor classes tend to contain most of the (generalized) functionality, with the leaf subclasses making … Read more
PHP doesn’t support any friend-like declarations. It’s possible to simulate this using the PHP5 __get and __set methods and inspecting a backtrace for only the allowed friend classes, although the code to do it is kind of clumsy. There’s some sample code and discussion on the topic on PHP’s site: class HasFriends { private $__friends … Read more
Edit 2: I had another potential thought here: You mentioned that you are running on x64. I’ve tested this same issue on x86, and seen the same performance when using auto-properties vs. fields. However, if you look around on Connect and mailing list/forum posts, there are many references online to the fact that the x64 … Read more
Here is a good set of guidelines for when to use properties vs methods from Bill Wagner (fixed link) Use a Property when all these are true: The getters should be simple and thus unlikely to throw exceptions. Note that this implies no network (or database) access. Either might fail, and therefore would throw an … 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
This looks like the non-singleton version of the module pattern, whereby private variables can be simulated by taking advantage of JavaScript’s “closures”. I like it (kinda…). But I don’t really see the advantage in private variables done in this way, especially when it means that any new methods added (after initialisation) do not have access … Read more
The advantage of prototypal inheritance is that it potentially allows fancy metaprogramming in a straightforward way because the prototype chain is easily manipulated. This is a rather academic advantage because metaprogramming is the wrong answer 99% of the time. As an example, you could have a Javascript Key-Value Observer style data manipulation layer with a … Read more