[PHP] static waarde overschrijven

[2playgames]

Ik probeer wat MVC functies te maken. Ik heb een superclass Model. Hiervan maak ik een subclass Member. in Member wil ik een static variabele maken, bijvoorbeeld table, die vanuit Model beschikbaar is. als ik dan bijvoorbeeld Member::get() aanroep moet hij de tabel die bij Member hoort pakken. waarschijnlijk is code makkelijker, ik heb het nu ongeveer zo geprobeerd:

PHP:

<?php

abstract class Model {

protected static $table;

public static function get() {
 doSql('select from ' . self::$table);
}

}

class Member extends Model {
 public static function init() {
  self::$table = 'MemberTable';
 }
}

class Car extends Model {
 public static function init() {
  self::$table = 'CarTable';
 }
}

?>

dit werkt echter niet. als ik in 1 pagina 2 verschillende soorten models opvraag (bijvoorbeeld Member en Car), overschrijft de tabel van Car die van Model. nu ik erover nadenk, is dit eigenlijk vrij logisch.

hoe los ik dit wel op?

[frickY]

Als ik me niet vergis werkt die hele 'self' niet als je geen instantie van het object hebt.
Ook weet ik niet wanneer je uberhaupt init() uitvoert, en dus je variabele probeert te vullen?

Een logische manier lijkt mij niet met statics maar met instanties van je object te werken.

[ Voor 20% gewijzigd door frickY op 06-03-2008 16:12 ]

[2playgames]

die init voer ik uit onder de declaratie van Member, ben ik hier even vergeten.
self werkt wel, want verwijst namelijk naar de klasse, niet de instantie (dat is $this).

en het moet static of iets wat erop lijkt. het is immers een beetje onzinnig om getMember te doen op een instantie van Member. je voert getMember namelijk uit omdat je dan nog geen Member-instantie hebt.

[2playgames]

ok, ik denk dat ik een oplossing heb:

PHP:

<?php

$MODELS = array();
$MODELS['Member'] = array(
 'table' = 'memberTable',
 'fields' = array(
            'name' => self::FT_STRING,
            'password' => self::FT_STRING,
            'type' => self::FT_INT,
            'fullname' => self::FT_STRING,
            'street' => self::FT_STRING,
            'street2' => self::FT_STRING_ORNULL,
            'zipcode' => self::FT_STRING,
            'city' => self::FT_STRING,
            'telephone' => self::FT_STRING_ORNULL,
            'email' => self::FT_STRING
        )
);

abstract class Model {

   public function __construct($type, $data) {
      ...
   }

}

class Member {

   public function getFriends() {
     ...
   }

}

class DAO {

   public function construct($type) {
      ....
   }

   public function get() {
     doSqlThingy('select from ' . $MODEL[$type]['table']);
     new $type($type, $dataFromSql);
   }

}

?>

[Michali]

frickY schreef op donderdag 06 maart 2008 @ 16:11:
Als ik me niet vergis werkt die hele 'self' niet als je geen instantie van het object hebt.
Ook weet ik niet wanneer je uberhaupt init() uitvoert, en dus je variabele probeert te vullen?

Dat werkt dan wel, maar het probleem hier is dat static members en functies niet inherit worden van een superclass. De Member class heeft dus helemaal geen static member $table, dus deze via self::$table opvragen kan niet.

Je kunt proberen om er Model::$table van te maken, maar persoonlijk vind ik dat niet zo netjes. Dit is inderdaad duidelijk een geval voor 'gewone' objecten en inheritance.

[2playgames]

De Member class heeft dus helemaal geen static member $table, dus deze via self::$table opvragen kan niet.

Dat klinkt logisch, maar in PHP kan het toch. self::$table in Member verwijst dan naar Model::$table. Misschien denk je nu aan Java.

Maar goed, het probleem is ongeveer opgelost, zie links:
http://bartvanheukelom.dy...#_fastmvc_classes_models_
http://www.phpfreakz.nl/forum.php?forum=9&iid=1112635

[ Voor 15% gewijzigd door 2playgames op 07-03-2008 11:45 ]

[Morax]

Je kan ook wachten tot PHP5.3 uit is, daar is namelijk een oplossing voor deze tekortkoming van PHP

http://nl.php.net/manual/....late-static-bindings.php

(Ik zit hier zelf ook op te wachten voor een eigen implementatie)

[Michali]

Kun je eens een voorbeeld geven wanneer dit handig zou zijn? Ik vraag me namelijk af of het niet netter is op te lossen.

[prototype]

Michali schreef op vrijdag 07 maart 2008 @ 20:07:
Kun je eens een voorbeeld geven wanneer dit handig zou zijn? Ik vraag me namelijk af of het niet netter is op te lossen.

Zeer handig voor een ActiveRecord design pattern implementatie, en dat is denk ik niet netter op te lossen zonder late static binding. (Volgens mij probeert TS dit ook te doen ). Dan heb je b.v. zoiets als:

PHP:

<?php

class ActiveRecordBase {
  public static $table_name;

  public static find($limit, $options = array()) {
    //...
  }
}

?>

En je wil zoiets als:

PHP:

<?php

public Member extends ActiveRecordBase {
  public static function initialize() {
    self::$table_name = 'members';
  }

}

?>

Als static late binding zou werken, zou je nu klassengebonden finders hebben, hetgeen semantisch ook klopt en wat je wil. Je kan dan zoiets doen als

PHP:

Member::find('first', array('conditions' => array('username' => 'prototype')));

De 'oplossing' / workaround die ik nu heb door 't ontbreken van static late binding in PHP is om te werken met objecten die als prototypes dienen... (no pun intended )

[Toolskyn]

Volgens mij is dit vrij simpel op te lossen in PHP door gebruik van parent::

PHP:

<?php
abstract class Model {
    protected static $table;
    
    public static function get() {
        print self::$table;
    }
}

class Member extends Model {
    public static function init() {
        parent::$table = 'MemberTable';
    }
}

Member::init();
Member::get();
?>

Uitvoer:

MemberTable

Late static binding is in dit geval niet van toepassing. Bij late static binding gebruik je in de parentklasse (basisklasse) iets wat je in de childklasse (subklasse) weer wilt veranderen. Dit kan bijvoorbeeld niet in PHP < 5.3:

PHP:

<?php

class A {
    protected static $var = 'foo';
    
    public static function display() {
        print self::get();
    }

    
    public static function get() {
        return self::$var;
    }
}

class B extends A {
    public static function get() {
        return 'better ' + self::$var;
    }
}

B::display();
?>

Je zou graag willen dat wanneer je B::display() gebruik je ook de get() methode van B gebruikt. In PHP 5.3 of later zal dit als uitvoer geven:

better foo

Terwijl eerdere versies dit zullen doen:

foo

Maar het gegeven voorbeeld kan dus zonder het verhaal van late static binding aangepakt worden.

[Michali]

Dat klopt niet.

Kijk maar naar dit voorbeeld:

PHP:

abstract class Model {
    protected static $table;
    
    public static function get() {
        print self::$table;
    }
}

class Member1 extends Model {
    public static function init() {
        parent::$table = 'MemberTable 1';
    }
}

class Member2 extends Model {
    public static function init() {
        parent::$table = 'MemberTable 2';
    }
}

Member1::init();
Member2::init();
Member1::get()

Dit print "MemberTable 2" uit ipv. het gewenste "MemberTable 1". Dit omdat beide subclasses dezelfde variabel aanspreken.

Overigens zou in je 2de voorbeeld static::get(); in display aangeroepen moeten worden voor die late static binding. Anders krijg je dus wel gewoon 'foo'.


Ik merk wel dat ik geen fan ben van dat ActiveRecord pattern. Klinkt als het misbruiken van een class voor andere doelen dan zijn primaire taak. Lijkt me niet zo veel werk om dit aan een ander object te geven, dan hoef je dit soort vreemde oplossingen ook niet toe te passen.

[Morax]

Ik wil het gebruiken voor een model van database entities.

Mijn superklasse heeft een aantal standaard implementaties, die moeten werken met de waardes uit de child klasses.

Mijn superklasse bevat dan namelijk de implementaties om de insert, delete en update queries uit te voeren, maar de childklasse moet dan gedefinieerd hebben welke tabel hij representeert, en welke kolommen die tabel bevat

[Toolskyn]

Inderdaad je hebt helemaal gelijk, stom van me. PHP is in dit geval wel lichtelijk een 'pain in the ass' om het maar zo uit te drukken.

@TS: Waarom wil je eigenlijk die naam van de tabel perse statisch opslaan? Misschien dat het qua idee wel beter is wat je wil (om wat voor redenen dan ook), maar waarschijnlijk krijg je een elegantere oplossing als je je aan de taal aanpast en van het idee statisch afstapt in dit geval.

[2playgames]

Dat heb ik ook allang gedaan zie een paar posts terug