Heren, dames,

welke is beter: foo of bar:


<?php
class FB {

  static public $config;

  public function foo() {
    $config = static::$config;
  }

  public function bar() {
    $config = $this::$config;
  }

}
?>


Het verschil zit dus in de manier van het aanroepen van de statische property $config. In PHP < 5.3 kon dit met self::$config, maar omdat FB wel eens extensions zou kunnen hebben (zonder de overwrite van foo() of bar()), is self:: niet goed genoeg. Het kan (en kon al) daarom met $this::. Het kan nu ook met static::...

Het verschil tussen self::$config en $this::$config snap ik. is er een verschil tussen static::$config en $this::$config? Werkt het hetzelfde voor methoden (ipv properties)? Is een van de twee 'beter'? Waarom?

Ik vraag dit omdat het syntactically (syntaxelijk?) heel raar is. Onderstaande zijn allemaal geldig, maar doen niet perse iets anders:


ClassName::$prop // obviously niet dynamisch
$class::$prop // $class is een string
$obj::$prop // $obj is een object
ClassName::func()
$class::func() // idem string
$obj::func() // idem object


Dank

PS. Als je PHP >= 5.3 niet kent, hoef je niet te reageren (no offense).
$this:: is volgens mij gewoon fout, omdat een statisch veld een eigenschap van de klasse is, niet van het object.
Maar in PHP < 5.3 kon je niet zonder $this::.... Ik heb het al miljarden keren gebruiken. En het werkt.
En het zou ook moeten werken! Je bent namelijk niet in een statische omgeving, maar wil wel een statische property opvragen. self:: is niet goed genoeg omdat die __CLASS__ (statische omgevind) gebruikt ipv get_class($this) (niet-statische omgeving).

Ze werken allemaal: static::$config, self::$config, $this::$config, waarschijnlijk ook:

[code]
$class = get_class($this);
$config = $class::$config
[code]

maar die is een beetje raar =)
Je method zelf is niet static, dus je roept hem blijkbaar altijd in de context van een instantie aan, dus is er altijd een $this, dus kan je net zo goed $this:: gebruiken. PHP vindt het niet erg, geeft niet eens een strict warning, dus waarom dan ook niet?
Waarschijnlijk is het de C-mens in mij die nu spreekt (php is altijd al wat losser geweest)...

De gedachte bij het begrip static:
Een static method (functie) is een functie waar je de eigenschappen ($this-> variabelen) niet mee sleurt.

Waarom? Stel je hebt een functie die een e-mail adres valideert. Die functie moet gewoon 1 parameter krijgen: een (string) e-mail adres; verder een boolean return (true of false). Die functie hoeft verder niets te weten van de $this-> variabelen in het object; de functie wordt dan ook veel lichter.

Wat deze vraag betreft ... misschien snap ik het php begrip static niet zo goed.
Dat is natuurlijk waar, maar volgens mij is het idee van static meer dat de KLASSE in plaats van het OBJECT de eigenschap draagt of de handeling uitvoert. Denk aan:
<?php
$user = User::loadFromId(112);
$user->save();
?>
Of
<?php
echo Guestbook::$version;
?>
Hier is geen object (nodig) om de handeling uit te voeren.

Reageren