[PHP] Class variable als integer werkt niet.

[Verwijderd]

Ik ben bezig met een class, die class is op het moment pas 3kb. De class die ik aan het maken ben zou moetten zorgen voor de MySQL afhandeling binnen een website. Ik wil dus per uitgevoerde query een optellend getal hebben, hiervoor heb ik een mooie waarde aangemaakt bij iedere functie die ik wil laten "counten".

Het probleem is dat hij mijn werkwijze niet leuk vind. PHP heeft nl de eigenschap als je een waarde op de volgende manier aanmaakt dat hij hem dan unset:

PHP:

$var=0;

Ik heb ergens een paar topics gevonden waardat ze de volgende oplossing hadden.

PHP:

$var = (int)0;

Echter omdat ik de waardes in een class heb staan wil dit ook niet echt werken.

PHP:

class BlaatClass {
  var $A = 0;
  //ik kan hem ook veranderen naar var $A = (int)0;
  //maar dan krijg ik foutmelding 2


  function Functietje() {
    //wat ik ook doe, foutmelding 1
    $this->A++;
    //of $this->A = $this->A + (int)1;
    //of die (int) bij een andere waarde, zelfde effect
  }
}

Bijbehorende foutmelding:

code:

1)
Notice: Undefined property: A in C:\WebSites\**
***\includes\class.mysql.php on line 5

2)
Parse error: parse error, unexpected T_INT_CAST in C:\WebSites\**
***\includes\class.mysql.php on line 2

^{Ik heb bij de foutmeldingen wat aangepast, zodat het klopt op dit stukje. Regelnummers en waarde A}

Iedere keer dat ik de functie aanroep dan zou hij hem moetten ophogen, dat doet hij dus niet. Ik kan mezelf wel allemaal (niet z'n nette) manieren gaan bedenken om het toch werkend te krijgen maar ik ben er bijna zeker van dat er een nettere manier is.

[beetle71]

Als ik je voorbeeld hier LETTERLIJK overneem en dit doe:

PHP:

$test=new BlaatClass();
$test->Functietje();
$test->Functietje();
$test->Functietje();
$test->Functietje();
$test->Functietje();
$test->Functietje();
echo $test->A;

Dan krijg ik netjes 6 als uitkomst,
dus het werkt gewoon, je probleem zit ergens anders!

[NMe]

Gebruik je PHP 4 of 5? Wat je zou kunnen proberen is het type setten in de constructor van de class, en hem daar ook te initialiseren. Anders weet ik het ook niet.

beetle71 schreef op 07 augustus 2004 @ 20:59:
Als ik je voorbeeld hier LETTERLIJK overneem en dit doe:

PHP:

$test=new BlaatClass();
$test->Functietje();
$test->Functietje();
$test->Functietje();
$test->Functietje();
$test->Functietje();
$test->Functietje();
echo $test->A;

Dan krijg ik netjes 6 als uitkomst,
dus het werkt gewoon, je probleem zit ergens anders!

Bij mij ook, maar ik draai nog PHP4. Ik vermoed dat TS PHP5 draait.

[ Voor 61% gewijzigd door NMe op 07-08-2004 21:02 ]

[Verwijderd]

Ik maak zelf ook nog gebruik van PHP4.x, dus daar kan het probleem niet zitten.
Als ik de code overneem die ik hier heb staan dan werkt hij ook dus ik vermoed idd dat er iets mis is in mijn eigen code.

PHP:

class MySQLSystem {
    var $CON = false;
    var $DB = false;
    var $ST_CONN = false;
    var $ST_DBSEL = false;
    var $CNT_QUERYS = 0;
    var $CNT_FETCHARR = 0;
    var $CNT_NUMROW = 0;
    
    function query($query) {
        $this->CNT_QUERYS++;
        return mysql_query($query);
    }
}

code:

Notice: Undefined property: CNT_QUERYS in C:\WebSites\**
**\includes\class.mysql.php on line 11

[Grijze Vos]

PHP:

class BlaatClass {
  var $A;

  function __construct()
  {
    $this->A = 0;
  }

  function Functietje() {
    //wat ik ook doe, foutmelding 1
    $this->A++;
    //of $this->A = $this->A + (int)1;
    //of die (int) bij een andere waarde, zelfde effect
  }
}

in php4 moet je de functie __construct gewoon de naam van de class geven.

[ Voor 20% gewijzigd door Grijze Vos op 07-08-2004 21:13 ]

[Verwijderd]

Maak je wel een instantie van je object? Het lijkt erop dat je alles als 'static' aanroept?

[beetle71]

Verwijderd schreef op 07 augustus 2004 @ 21:13:
Maak je wel een instantie van je object? Het lijkt erop dat je alles als 'static' aanroept?

Dat vermoeden heb ik ook, want als ik

PHP:

BlaatClass::Functietje();

Aanroep krijg ik ook een undefined error!

Je moet dus eerst een instance maken..

Grijze Vos schreef op 07 augustus 2004 @ 21:12:

PHP:

class BlaatClass {
  var $A;

  function __construct()
  {
    $this->A = 0;
  }

  function Functietje() {
    //wat ik ook doe, foutmelding 1
    $this->A++;
    //of $this->A = $this->A + (int)1;
    //of die (int) bij een andere waarde, zelfde effect
  }
}

in php4 moet je de functie __construct gewoon de naam van de class geven.

Je mag de variabele gewoon als class var op 0 zetten, dit hoeft niet vanuit een constructor.

[ Voor 45% gewijzigd door beetle71 op 07-08-2004 21:37 ]

[Bosmonster]

beetle71 schreef op 07 augustus 2004 @ 21:35:
[...]

Je mag de variabele gewoon als class var op 0 zetten, dit hoeft niet vanuit een constructor.

De PHP.NET manual vindt toch echt van niet

http://nl.php.net/oop

In PHP 4, only constant initializers for var variables are allowed. To initialize variables with non-constant values, you need an initialization function which is called automatically when an object is being constructed from the class. Such a function is called a constructor (see below).

En zie dus het voorbeeld aldaar.

[ Voor 3% gewijzigd door Bosmonster op 07-08-2004 23:58 ]

[Grijze Vos]

Bovendien is het ook een stuk netter.

Dat PHP iets slikt wil niet zeggen dat het 'mag'.

[Verwijderd]

Grijze Vos schreef op 08 augustus 2004 @ 00:34:
Dat PHP iets slikt wil niet zeggen dat het 'mag'.

Ja dat blijkt wel weer

Ik ben er nou achter dat mijn class werkt, maar dat het hem zit in de manier dat ik de aanroep doe naar de class.

Ik heb 2 classes, vanuit ClassA open ik de mysqlsystem::query, bv op de volgende manier:

PHP:

class ClassA {
  function hoi() {
    $bla = MYSQLSYSTEM::QUERY("SELECT * FROM table;");
  }
}

Zodra ik het op deze manier aanroep dan gaat hij vanuit de MySQLSystem class klagen dat het niet mag.

[Grijze Vos]

ja, das logisch, want dan instantieer je de class niet he.

[Bosmonster]

Je kunt zo prima methodes aanroepen, maar je kunt dan natuurlijk geen dingen als $this gebruiken.

[Verwijderd]

Bosmonster schreef op 08 augustus 2004 @ 11:37:
Je kunt zo prima methodes aanroepen, maar je kunt dan natuurlijk geen dingen als $this gebruiken.

Hoezo zou dat niet kunnen? Als ik de volgende php code gebruik dan werkt hij wel gewoon, en daarmee kan ik aantonen dat hij de $this wel degelijk een waarde geeft op deze manier.

Het optellen gaat zelfs GOED als ik het op deze manier gebruik, hij geeft alleen een foutmelding ( Undefined property: CNT_QUERYS ). Als ik de onderstaande code aanroep met een nieuwe class krijg ik ook de foutmelding maar hij count het wel.

PHP:

    function query($query) {
        $this->CNT_QUERYS++;
        echo "<b>".$this->CNT_QUERYS."</b>";
        return mysql_query($query);
    }

^{Deze php code staat dan in de class MySQLSystem.}

PHP:

class ClassA {
  function hoi() {
    $bla = MYSQLSYSTEM::QUERY("SELECT * FROM table;");
  }
}
$t = new ClassA();
$t->hoi();
$t->hoi();
$t->hoi();
$t->hoi();
$t->hoi();

@Grijze Vos: leg uit?

[Apache]

Met $this verwijs je naar de instantie van je class, maar er is geen instantie aangezien je hem static oproept.

Je moet dus met new een instatie van het object aanmaken zodat de properties bijgehouden worden, ik weet niet of het in PHP4 mogelijk is om static class properties te gebruiken waarmee je dit hier wel zou kunnen oplossen door je properties static te maken zodat ze in alle instaties en static calls je CNT_QUERYS property dezelfde waarde heeft.

[/OO basics]

[beetle71]

Als je dit perse op deze manier wilt doen, dan moet je het SINGLETON principe eens bestuderen. zie http://www.phppatterns.co...rticle/articleview/6/1/1/

Daarin is een workaround gedaan voor het ontbreken van static class properties in php4 waarover Apache het hierboven heeft.

[Verwijderd]

@ Apache: Zou het uitmaken als ik nou PHP5 zou gaan gebruiken? Zou het dan wel werken?

@ beetle71: Op watvoor manier zou ik de aanroep dan beter kunnen doen? Ik probeer het zo te maken dat ik geen "extends" tussen deze classes gebruik omdat ik dan die functies in de userclass zou krijgen, en daar heb ik geen behoefte aan (dubbele namings in die classen bv).

[Apache]

Onder PHP5 is het op te lossen alsvolgt:

PHP:

<?php

class MyClass {

    static private $qryTeller = 0;

    static public function query($query){

        MyClass::$qryTeller++;
        // hier meer code

    }

}

?>

K'denk dat je OO een beetje opgepoets mag worden, aangezien je user je mysql class zou willen laten extenden denk ik? Je ziet zelf wel dat het lelijk is, en dat is ook zo.

Je zou wel je User class constructor een Mysql class kunnen voeden zodat je in de user class gebruik kan maken van je database object.

Het extends keyword is meer iets wat je in de volgende situatie toepast
class figuur
class vierhoek extends figuur
class ruit extends vierhoek

je specificieert dus steeds meer eigenschappen, vierhoek tov figuur heeft een zijde en de ruit heeft ook nog een kleine en grote diagonaal.

Je kan als je dan toch naar PHP5 gaat meteen een mooie singleton bouwen of gewoon afdwingen dat er een instantie word gemaakt van je object en je niet met static truukjes dit gaat toepassen

[beetle71]

Verwijderd schreef op 08 augustus 2004 @ 15:21:
@ beetle71: Op watvoor manier zou ik de aanroep dan beter kunnen doen? Ik probeer het zo te maken dat ik geen "extends" tussen deze classes gebruik omdat ik dan die functies in de userclass zou krijgen, en daar heb ik geen behoefte aan (dubbele namings in die classen bv).

Helaas zijn static class variabelen in php4 niet mogelijk, dat betekend dat je het singleton-pattern niet zoals 'gewoonlijk' kunt implementeren. Maar er is een 'workaround' voor php 4.
Een voorbeeld:

PHP:

class myDBClass{
    
    var $querycount;
    
    function myDBClass(){
        // Constructor
        // Hier bijvoorbeeld ook een DB connectie maken,    
        $this->querycount=0;
    }
    
    function doQuery($qry){
        // voer de query uit.
        $this->querycount++;
        return('het resultaat');
    }
    function aantalQueries(){
        return($this->querycount);
    }
}

function &staticDBClass(){
    static $DBclass_instance;
    
    if(!isset($DBclass_instance)){
        $DBclass_instance=new myDBClass();
    }
    return($DBclass_instance);
}


class probeersel{
    
    function probeersel(){
        $this->dbClass=& staticDBClass();
    }
    function ietsDoen(){
        $result=$this->dbClass->doQuery('Test');
    }
}

$test=new probeersel();
$test->ietsDoen();
$test->ietsDoen();
$test->ietsDoen();
$test->ietsDoen();
$test->ietsDoen();


$test2=new probeersel();
$test2->ietsDoen();
$test2->ietsDoen();
$test2->ietsDoen();
$test2->ietsDoen();
$test2->ietsDoen();


$results=& staticDBClass();
echo $results->aantalQueries();

Doordat een functie wel static variabelen kent, wordt de instantie van de DBclass als static member van een functie opgeslagen, en met een referentie teruggegeven. (Er bestaat nu slechts EEN instance van de DBclass)

Het resultaat van de echo op de laatste regel is dus 10 ! er zijn in totaal 10 queries uitgevoerd

[Verwijderd]

Apache schreef op 08 augustus 2004 @ 16:30:
Je zou wel je User class constructor een Mysql class kunnen voeden zodat je in de user class gebruik kan maken van je database object.

Hoe bedoel je dit? Dat ik in de constructor van de userclass de mysqlclass laad, als op de volgende manier?

PHP:

class mysqlsystem {
  var $bla;
  function query($query) {
    return mysql_query($query);
  }
  function mysqlsystem() {
     //iets
     $this->BLA = "hoi";
  }
}

class ClassA {
  var $whoei;
  function hoitje() {

  }
  function ClassA() {
    $this->WHOEI = new mysqlsystem();
  }
}

//en dan via
$iets = new ClassA();
$iets->whoei->query("SELECT iets FROM table;");

Begrijp ik het goed? Ik heb het nl wel ooit ergens gezien (iig de laatste regel), maar ik begreep het nooit (niet echt nodig gehad voor mn scripts).

Als ik het goed begrepen heb, dan meteen een vraag. Krijg ik hierdoor niet meerdere MySQL connecties naar een server vanaf 1 script, en kan dat geen kwaad?

je specificieert dus steeds meer eigenschappen, vierhoek tov figuur heeft een zijde en de ruit heeft ook nog een kleine en grote diagonaal.

Zover was ik al, ik zou het wel kunnen gebruiken maar dan heb ik een probleem omdat ik dubbele functienamen heb en die gaan elkaar dan overschrijven (toch?!).

[EDIT]
Ik ben traag met posten
Ik ga even proberen of ik het nu snap. Het ziet er opzich wel logisch uit, kijken of ik het goed begrepen heb.

[ Voor 7% gewijzigd door Verwijderd op 08-08-2004 16:57 ]

[Apache]

functienamen worden overschreven door de class die het laatst gespecifieerd zijn (het verst in de boom van overerving) dat maakt dus niet uit, tenzij ze niet overschreven mogen worden maar dat probleem heb je in php4 niet omdat die het final keyword nog niet kent.

Ik bedoelde meer iets als:

PHP:

<?
class mysqlsystem {
  var $bla;
  function query($query) {
    return mysql_query($query);
  }
  function mysqlsystem() {
     //iets
     $this->BLA = "hoi";
  }
}

class ClassA {
  var $whoei;
  function hoitje() {

  }
  function ClassA(&$mysqlSystem) {
    $this->WHOEI = $mysqlSystem;
  }
}

//en dan via
$mijnMysqlSystemDatIkOveralKanGebruiken = new mysqlSystem();
$iets = new ClassA($mijnMysqlSystemDatIkOveralKanGebruiken);
$iets->whoei->query("SELECT iets FROM table;");
?>

nu kan je die whoei niet private declareren maar je kan hem wel enkel binnen je user class gebruiken en dus daarmee al je queries gaan uitvoeren in je userclass, maar ook doorgeven naar andere classes.

Als je de reference naar dezelfde instantie nog naar enkele andere classes passed, bijvoorbeeld een nieuws classe die ook wat queries moet uitvoeren word er in je centrale object de query teller opgehoogd.

[ Voor 12% gewijzigd door Apache op 08-08-2004 17:08 ]

[ACM]

Bosmonster schreef op 07 augustus 2004 @ 23:58:
[...]


De PHP.NET manual vindt toch echt van niet

http://nl.php.net/oop


[...]


En zie dus het voorbeeld aldaar.

Je spreekt hem tegen met een quote die onderschrijft dat hij gelijk heeft

Je mag zowel dit doen:

PHP:

class bla
{ var $x = 1;}

Als dit:

PHP:

class bla
{
  var $x;
  function bla()
  { $this->x = 1; }
}

[Soultaker]

Bosmonster schreef op 07 augustus 2004 @ 23:58:
beetle71: "Je mag de variabele gewoon als class var op 0 zetten, dit hoeft niet vanuit een constructor.
De PHP.NET manual vindt toch echt van niet

http://nl.php.net/oop: "In PHP 4, only constant initializers for var variables are allowed. To initialize variables with non-constant values, you need an initialization function which is called automatically when an object is being constructed from the class. Such a function is called a constructor (see below)."

Die conclusie is onjuist. 0 is een constante literal en die mag je gewoon toekennen buiten de constructor. (Zie ook de voorbeelden bij de quote.) Je mag echter geen expressie gebruiken. beetle71 heeft echter gelijk dat je die variabelen wel gewoon op 0 kunt initializeren.

edit:
* Soultaker slaps ACM around a bit with a large trout.

[ Voor 5% gewijzigd door Soultaker op 08-08-2004 17:23 ]

[Verwijderd]

Ok het zijn twee verschillende ideen met het zelfde effect. Wat zou ik het beste kunnen gebruiken (flexibelste?). Ik heb nou het idee van Apache in mijn script om te testen (en dat werkt goed, zonder errors).

ACM schreef op 08 augustus 2004 @ 17:22:
Je spreekt hem tegen met een quote die onderschrijft dat hij gelijk heeft

Bosmonster is gewoon tegenstrijdig, hij weet niet echt wat hij nou wil
[/offtopic]

Je mag dan wel bijde manieren gebruiken, toch vind ik (zoals ik er nu tegenaan kijk) het vullen van de data netter in de constructor.

[Robinski]

Ik heb zelf ook zo'n classe gemaakt voor PHP5
ik heb zelf voor de counter een static gebruikt, dit omdat als je zo 3 DB Objectne hebt alles bijelkaar komt

je kan het ook aanpassen uiteraard, dan moet je wel in de constructor de counter op 0 zetten

PHP:

class DB
{
private static $queryCount = 0; // Counter for the amount of querys done by the Database

    public function query($query)
    {
        self::$queryCount++;
        $result = mysqli_query($this->link,$query);
}

    static function getQueryCount()
    {
        return self::$queryCount;
    }
}

via de laatste functie is het mogelijk om dus in je scripts dit te doen:
DB:getQueryCount();

hopelijk heb je hier iets aan

[Apache]

Tsjah, wat nu het beste is, ik heb er in php5 voor gekozen om mijn DBL gewoon te instantieren, geen static truukjes.

Om heb in andere classes te gebruiken heb ik één singleton class die een static verzameling heeft van welke classen erbij geregistreerd zijn, adhv de naam van de class kan je zien of er een instantie geregistreerd is in de verzameling van het singleton anders geeft hij een fout.

bvb

PHP:

<?php
zen::register(new mysqlSystem);

// en dan kan ik overal zo aan mijn object:
zen::getInstanceOf('mysqlSystem')->Query('SELECT .... ');
?>

[beetle71]

Verwijderd schreef op 08 augustus 2004 @ 16:56:
[...]

Begrijp ik het goed? Ik heb het nl wel ooit ergens gezien (iig de laatste regel), maar ik begreep het nooit (niet echt nodig gehad voor mn scripts).

Als ik het goed begrepen heb, dan meteen een vraag. Krijg ik hierdoor niet meerdere MySQL connecties naar een server vanaf 1 script, en kan dat geen kwaad?

Je begrijpt het goed. Maar je vraag is vervolgens ook een hele goeie. Je creeert daarmee in elke class een aparte instance van de DBClass. En dus meerdere connecties, meerdere querycount etc. etc.
En dat is precies wat je niet wilt! Daarom zul je gebruik moeten maken van een singleton-pattern (dat is een bepaald soort van classe, waarbij er slecht 1 instance kan/mag voorkomen in het totale script. ff zoeken bij google voor meer info)

Dus.... Of je kiest voor php5, die static class variabelen ondersteund waarbij je dus eenvoudig een singleton-pattern kunt maken, zoals het voorbeeld hierboven, of bij php4 voor het singleton-pattern zoals in mijn eerdere voorbeeld.

Een andere (persoonlijk vindt ik dat een heel lelijke oplossing) is om een instance te maken van je DBClass in je main script en deze global te maken.

PHP:

$db=new DBClass();

class foo{
     function bar(){
          global $db;
         $db->doQuery('xyx');
    }
}

Overigens vond ik nog een interessante link mbt. static class variabelen...
http://www.webkreator.com...atic-class-variables.html

[ Voor 7% gewijzigd door beetle71 op 08-08-2004 18:28 ]

[Verwijderd]

@beetle71: Ik denk dat ik ga voor de PHP4 via het singleton-pattern zoals jij eerder aangaf. Ik heb dmv wat extra tests bekeken of hij meerdere sql connecties ging leggen, maar volgends mij doet hij dat op die manier niet. Dus ik ben (als het goed is) uit de brand geholpen