Johannes Ott wrote on 11/03/2015 13:36:
Am 11.03.2015 um 14:03 schrieb Rowan Collins:
Johannes Ott wrote on 10/03/2015 20:46:
okay indeed the dynamic properties are a problem I didn't think about on
my suggestion. Without the wish to hijack this thread for another
typesafety discussion, I must say again that PHP needs a less dynamic
and more declaratively properties concept in my opinion.
Yes, I think a standard way to say that a particular object has strictly
declared all its properties, and should not allow would be useful.
(Even with that, though, I'd be against guessing that "$foo" meant
"$this->foo"; it just makes code harder to read.)
I disagree, programming Java beside PHP since about 15 years now,
personally I think always having "this"-keyword, where it is not
necassary in a strict OOP-world, makes the code more unreadable for the
simple fact it is more to read.
My reasoning is that code that is ambiguous is hard to read. If "$foo"
can mean either "a local variable called $foo" or "a property of the
current object called $foo", then you have to know which it is in order
to understand what code is doing.
This is not about "a strict OOP-world", incidentally, it's about scoping
rules. Java imports object properties into the scope of each method, PHP
does not. Even if properties had to be declared (which is probably a
good idea), local variables still wouldn't be - in Java, the fact that
it's not declared locally means it *must* be coming from somewhere else.
I also know that when I was first learning Java at school, it confused
me immensely which variables I was allowed to access in static contexts.
In PHP, that's simple - if you can't access $this, you can't access any
of it's properties.
So I would suggest for now to keep the $this variable, but to make it
more similar to other OOP-languages I would suggest to remove the
$-character in front. In my opinion it would fit better to other object
keywords like parent and self as well.
Other OOP languages only don't have a sigil such as $ in front of this
if they don't have one in front of *any* variable. Why should $this,
which acts like a normal variable in pretty much every way, drop the $
when every other variable in the language has one?
Note that the syntax of parent and self is different, and is consistent
with static member/method access, or more strictly "scope resolution".
You can't pass parent or self around as variables, only use them to
resolve scopes, so they don't have a $.
I only agree a bit, because the keyword "this", is what to call a
hybridization, more often used to define the scope of the property or
method you want to use, then used really as a pure variable.
For example:
this->a;
or
this->some_function(...);
just defining the scope as in the current instance is much more used then.
some_function($this);
This is true of any object variable.
These resolve the scope of the property/method to the variable $foo:
$a = $foo->a;
$foo->some_function(...);
These resolve the scope of the property/method to the variable $this:
$a = $this->a;
$this->some_function(...);
If you want to resolve the scope of a method to the current object
without using the variable $this, you can also use the "static" keyword;
these are equivalent:
$this->some_function(...);
static::some_function(...);
// http://3v4l.org/E0XYs
There is nothing unvariable-like about $this, so if variables begin with
$, $this should begin with $.
Regards,
--
Rowan Collins
[IMSoP]
--
PHP Internals - PHP Runtime Development Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
