[PHP] Extenden van een class (onb. naam)

[Verwijderd]

Ik wil graag een class gaan extenden waarvan de naam tijdens het bouwen van het script nog niet bekend is.. Iets in deze geest:

PHP:

<?$nog_onbekend = "een";class een {    function blabla(){        echo "ik ben de parent class";    }}class twee extends $nog_onbekend{    //....}$t = new twee;?>

Krijg het dus alleen niet goed werkend.. '$nog_onbekend' mag daar niet staan.. iemand een oplossing die wel werkt? Desnoods een soort van "copy" function in class 'twee' die 'een' naar zichzelf copieerd incl variabelen en functies

[whoami]

Waarom weet je de naam van die class nog niet?

[brammetje]

Dit kan idd niet. (niet zo heel gek ook, maar ik kan het niet uitleggen )

Eval() biedt uitkomst, maar misschien is het slimmer eerst de vraag van whoami te beantwoorden

[Verwijderd]

Here ya go:
Ben bezig met het maken van een Module based systeempje..Er zitten bijvoorbeeld de volgende modules in:
news
news_poll
news_comment

news_poll en news_comment "extenden" news.. Er mag maar 1 class overblijven dus dan krijg je iets als:

class news_poll extends news en
class news_comment extends news_poll

Maar op de tijd dat deze modules worden geschreven is er nog niet bekend dat er bijvoorbeeld een module news_comment is...

Brammetje:
Kwil liever niet met aan eval gaan beginnen, dan moet ik de hele class in een eval zetten

[GraasGast]

Zo zou ik het niet doen...

ik ben met een soortgelijk systeem bezig, en dat doe ik ongeveer zo:

ik heb een hele berg classes (modules)

al die classes instantieer ik in een class 'core', dus dan kan ik $core->module->method(); doen.

dan heb ik een class 'module', met een constructor die als parameter een reference (&) van de class 'core' pakt.

alle modules extenden de class 'module' zodat alle andere classes in elke class beschikbaar zijn onder $this->core->module->method();

Als je meer uitleg wil post ik wel wat code.

[Verwijderd]

Op maandag 03 juni 2002 20:30 schreef GraasGast het volgende:
...

Als je meer uitleg wil post ik wel wat code.

Graag, ik kan je niet volgen

[ACM]

Op maandag 03 juni 2002 20:12 schreef TimD het volgende:
Here ya go:
Maar op de tijd dat deze modules worden geschreven is er nog niet bekend dat er bijvoorbeeld een module news_comment is...

Dan zit er toch wat goed fout in je model...

Ik zou eens naar het ontwerp kijken als ik jou was, aangezien je wel heel rare dingen wilt. Die in geen enkele taal (echt goed iig) mogelijk zijn?

[Glimi]

Dat is nou een mooi voorbeeld van een ZEER nuttig gebruik van abstracte classes.

Je levert dan een zut classes waarvan men geen instanties kan maken, maar die wel een basis bieden voor andere classes om te extenden.
Echter hiet moet je wel een gecompileerde taal voor hebben, want anders sloopt men gewoon het abstract keyword weg.

Maarja je wilt dus niet dat dat je classe zijn overerving variabel is. Zo kun je toch nooit specificeren welk subtype je kwijt kan (als z'n moeder verschillend kan zijn?)

Gewoon alles initaliseren in een classe en dan de boel ZENDEN lijkt me. Of kiezen voor een NIET open-source taal die compileert (Java)

[brammetje]

Op maandag 03 juni 2002 20:12 schreef TimD het volgende:
Kwil liever niet met aan eval gaan beginnen, dan moet ik de hele class in een eval zetten

Dat het niet slim is snap ik ook wel, maar het zou kunnen

[Verwijderd]

Okee thnx, maar kheb men probleem al opgelost.. Iedereen bedankt voor zen reply.

ACM: "Dan zit er toch wat goed fout in je model..." Waarom zit er dan in java "implements" toch om de mogelijkheid te bieden om meerdere classes te kunnen extenden.. (ook al moet je dan bij implements zelf de methodes van je class vullen)

[dusty]

Dat er bepaalde functies in een programmeertaal zitten betekent niet dat door gebruik van die functies je je code als "goed" kan bestempelen. Netzoals bij PHP zit er GLOBAL in terwijl in 99.99% van de gevallen geen global gebruikt hoort te worden, echter zegt men: Het werkt toch dan is mijn code toch goed?

Hiervoor geldt exact hetzelfde.

[Glimi]

Op maandag 03 juni 2002 21:20 schreef TimD het volgende:
ACM: "Dan zit er toch wat goed fout in je model..." Waarom zit er dan in java "implements" toch om de mogelijkheid te bieden om meerdere classes te kunnen extenden.. (ook al moet je dan bij implements zelf de methodes van je class vullen)

Een interface is GEEN oplossing van multiple inheritance. Een interface definieert aan welke eisen een class moet voldoen:

Kijk eens naar Clonable, Serializable en Remote en er gaat een hele wereld voor je open. Wist je btw dat RMI en CORBA helemaal draaien op interfaces? Dat heeft echt geen drol meer te maken met multiple inheritance

[GraasGast]

Op maandag 03 juni 2002 20:33 schreef DiEana het volgende:

[..]

Graag, ik kan je niet volgen

Okay, bij deze:
(Daar dit commerciele code betrefd heb ik het meeste eruit gesloopt, zodat alleen de essentie overblijft. Het gaat om het idee, nietwaar )

code:

class module {

    // Core
    var $core;

    // Constructor
    function module(&$core) {
        $this->core = &$core;
    }
}

class core {

    // Clasvars
    var $db;
    var $template;
    var $user;
    var $nodes;

    // Constructor
    function core() {

        // Benodigde bestanden includen
        require_once("core.db.mysql.php");
        require_once("core.template.php");
        require_once("core.user.php");
        require_once("core.nodes.php");

        // Core Classes instantiëren. Let op het argument $this,
        // dat word doorgeven aan de constructor van de class module
        $this->db       = &new db($this);
        $this->template     = &new template;
        $this->user     = &new user($this);
        $this->nodes        = &new nodes($this);
    }
}

Dat is de kern van het systeem, andere (core)modules zijn allemaal classes die ik module laat extenden.
Classes die voor andere classes nodig zijn moet je in de core instantiëren

voorbeeldje van een (core)module en het gebruik van $this->core:

code:

class nodes extends module {

    // Functie die de gegevens van een node module ophaald
    function get_node($node_id) {

        $query =


            "SELECT T1.node_id, T1.node_name, T2.module_name, T1.item_id ".

            "FROM nodes AS T1, modules AS T2 ".
            "WHERE T2.module_id = T1.module_id ".

            "AND T1.node_id = ".$node_id;


        return $this->core->db->fetch_array($query);
    }

    // Functie die de gegevens van de parent van een node ophaald
    function get_node_parent($node_id) {

        $query =

            "SELECT T1.* ".
            "FROM nodes AS T1, nodes AS T2 ".
            "WHERE T1.node_id = T2.node_parent ".
            "AND T2.node_id = ".$node_id;

        return $this->core->db->fetch_array($query);
    }

    // Functie die de gegevens van de children van een node ophaald
    function get_node_children($node_id) {

        $query =

            "SELECT * ".
            "FROM nodes ".
            "WHERE node_parent = ".$node_id;

        return $this->core->db->fetch_rows($query);
    }

    // Functie die de gegevens van alle parents van een node ophaald
    function get_node_path($node_id, $path = "") {

        if ($parent = $this->get_node_parent($node_id)) {
            $path[] = $parent;
        }

        if ($path[count($path)-1][1] != 0) {
            $path = $this->get_node_path($path[count($path)-1][0], $path);
        }

        return $path;
    }
}

Veel plezier ermee

edit: ik ben trouwens benieuwd wat dusty van m'n code vind