Steve Brown wrote:
> I've been doing a bunch of reading about objects and overloading in
> PHP5, but I've got a couple of questions that I can't seem to find the
> answer to online. Suppose the following code in PHP5.2.4:
>
> <?php
> class foo {
> public $x;
> private $z = 'z';
>
> public function __set ($name, $val) {
> echo "Setting \$this->$name to $val...\n";
> $this->{$name} = $val;
> }
>
> public function __get ($name) {
> return "The value of $name is {$this->{$name}}.\n";
> }
> }
> ?>
>
> My questions are as follows:
>
> 1) It seems that the getter and setter are not called on every single
> call. For example, if I do the following:
>
> $bar = new foo;
> $bar->x = 'x';
>
> There is no output. I would expect to see "Setting $this->x to x."
remove "public $x" and it works. __set() is only called for
non-existent variables.
> Another example:
>
> $bar = new foo;
> $bar->y = 'y';
> echo $bar->y;
>
> I would expect this to see "The value of y is y." but instead I just
> get 'y' as output. So when do the various setters/getters get used?
again, because your code sets $y with $this->{$name} = $value, the
variable $y now exists, and so __get() is not called.
If you're using normal variables, then you don't need setters/getters.
Instead, if you store the values inside an internal array (for
instance), then a setter/getter can help to abstract the array contents.
For instance, this class:
http://svn.pear.php.net/wsvn/PEARSVN/Pyrus/trunk/src/PackageFile/v2/Developer.php?op=file&rev=0&sc=0
(which is under development currently for the next incarnation of the
PEAR installer) allows logical manipulation of maintainers of a package
within package.xml. Instead of either direct array manipulation or the
old way, which was a complex method call that is easy to mis-order:
$pf->addMaintainer('cellog', 'Greg Beaver', '[EMAIL PROTECTED]', 'yes');
One can do:
$pf->maintainer['cellog']
->name('Greg Beaver')
->email('[EMAIL PROTECTED]')
->active('yes');
and then values can be retrieved using normal stuff like:
echo $pf->maintainer['cellog']->email;
The entire time, the class is abstracting stuff that would be really
complex as it is actually accessing the underlying XML of the
package.xml directly when making the modifications.
The examples you give don't need this kind of complexity.
> 2) It seems that getters ignore the visibility of properties. Why is
> this? For example:
>
> $bar = new foo;
> echo $bar->z;
>
> I would expect this to throw an error about accessing a private
> member, but it outputs "The value of z is z." just fine. If I remove
> the __get() overloader, an error is thrown.
private properties simply don't exist outside the class, so you can
create public properties on external access with impunity.
You should open a documentation bug for this at bugs.php.net
Greg
--
PHP General Mailing List (http://www.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php
