[PHP/OO] var wordt niet geset met __set

[Verwijderd]

nu ik het post zie ik het al.... "this" vergeten

mag dus dicht dit topic....

ik heb hier het meest simpele stukje code. maar ik krijg het maar niet werkend. eerder heeft dit soort code wel gewoon gewerkt, maar ik denk dat ik ergens overheen kijk.
de output op dit moment is:

code:

testje: test 
hoi -

terwijl hij ook die $myTestvar af hoort te drukken.
dus gewenst is dit:

code:

testje: test 
hoi - test

bij de __set method druk ik om te testen die $myTestvar ook af en daar komt hij wel goed. maar wanneer ik de zelfde class nogmaals aanroep lijkt die variabele ineens gereset te zijn oid..

wat doe ik nou fout? eerdere OO gevalletjes die ik in php heb gebakken gingen wel goed dus ik snap er helemaal niets meer van..

PHP:

<?php

    class Test
    {
        private $myTestvar;
        
        public function testfunc($arg)
        {
            echo $arg." - ".$myTestvar."\r\n";
        }
        
         // Callback method for getting a property
        public function __get($prop_name) 
        {
            switch ($prop_name)
            {
                case "testvar":
                    
                    return $myTestvar;
                    break;
            
            }
        }
    
        // Callback method for setting a property
        public function __set ($prop_name, $prop_value)
        {
            switch ($prop_name)
            {
                case "testvar":
                    $myTestvar = $prop_value;
                    printf("testje: %s \r\n", $myTestvar);
                    break;
            }
        }
            
        
    }
    
    $testclass = new Test();
    $testclass->testvar = "test";
    echo $testclass->testvar;
    $testclass->testfunc("hoi");

?>

[sTeVuu]

Gebruik $this->:

PHP:

        public function __set ($prop_name, $prop_value)
        {
            switch ($prop_name)
            {
                case "testvar":
                    $this->myTestvar = $prop_value;
                    printf("testje: %s \r\n", $this->myTestvar);
                    break;
            }
        }

PHP:

        public function testfunc($arg)
        {
            echo $arg." - ".$this->myTestvar."\r\n";
        }

[Verwijderd]

tnx voor de reactie... had het net ook zelf door ben c++ gewend

[Jaap-Jan]

En dat moet omdat hier:

PHP:

        public function __set ($prop_name, $prop_value)
        {
            switch ($prop_name)
            {
                case "testvar":
                    $myTestvar = $prop_value;
                    printf("testje: %s \r\n", $myTestvar);
                    break;
            }
        }

$myTestVar een lokale variabele is voor de functie testfunc(). De variabele die geprint wordt is ook de lokale variabele $myTestVar, maar die is weer vergeten zodra de functie is voltooid.

Om een klassevariabele aan te spreken, gebruik je $this->myTestVar:

PHP:

        public function __set ($prop_name, $prop_value)
        {
            switch ($prop_name)
            {
                case "testvar":
                    $this->myTestvar = $prop_value;
                    printf("testje: %s \r\n", $this->myTestvar);
                    break;
            }
        }

[ Voor 50% gewijzigd door Jaap-Jan op 09-11-2007 15:40 ]

[YopY]

Altijd al gedacht dat dat hele $this verhaal overbodig is. Mijns inziens moeten ze hier zo snel mogelijk vanaf.

[Voutloos]

Tja, of je onthoud gewoon wel voor eens en altijd hoe je bij een member var komt.

[FragFrog]

YopY schreef op vrijdag 09 november 2007 @ 16:05:
Altijd al gedacht dat dat hele $this verhaal overbodig is. Mijns inziens moeten ze hier zo snel mogelijk vanaf.

PHP is al weaktyped, wil je dan ook nog eens je variabele scopes onvoorspelbaar maken? Leuk als je een keer een (abstracte) class extend die toevallig ergens in een niet-overloaded member een variabele gebruikt die jij ook ergens gebruikt

* FragFrog is allang blij dat'ie sinds 5.1 eindelijk objecten en array's kan typehinten

[Snake]

FragFrog schreef op vrijdag 09 november 2007 @ 19:10:
[...]

PHP is al weaktyped, wil je dan ook nog eens je variabele scopes onvoorspelbaar maken? Leuk als je een keer een (abstracte) class extend die toevallig ergens in een niet-overloaded member een variabele gebruikt die jij ook ergens gebruikt

* FragFrog is allang blij dat'ie sinds 5.1 eindelijk objecten en array's kan typehinten

Onvoorspelbaar? Dit is onvoorspelbaar gedrag, bij Java & C# is het ook zo, gelijk TS zijn code schrijft. Dit is geen -imo- een failure van PHP.

Java:

public class Test1
{ 
   private int getal;
   public Test1()
   { }

   public void setGetal(int getal)
   {
      this.getal = getal;
   }
   //---- of
   public void setGetal(int g)
   {
      getal = g;
      //geen lokale scope voor getal
   }

   public int getGetal()
   {
      return getal;
      //== return this.getal;
   }

[ Voor 23% gewijzigd door Snake op 09-11-2007 19:27 ]

[FragFrog]

Snake schreef op vrijdag 09 november 2007 @ 19:24:
Onvoorspelbaar? Dit is onvoorspelbaar gedrag, bij Java & C# is het ook zo, gelijk TS zijn code schrijft. Dit is geen -imo- een failure van PHP.

Als een variabele automatisch de hele class als scope krijgt zorgt dat ervoor dat je scopes ineens veel groter worden. Dat noem ik eerder een nadeel dan een voordeel:

PHP:

abstract class foo {
  public function __construct () {
    $variable = true;
  }
}

class bar extends foo {
  public function hasVariable () {
    return $variable ? true : false;
  }
}

$bar = new bar;
var_dump($bar -> hasVariable());

Voor een PHP'er is deze code heel logisch en overzichtelijk: $variable is binnen hasVariable niet geset en die var_dump zal altijd false opleveren. Echter, als je zonder $this variabelen zou mogen assignen en uitlezen zal deze code ineens true opleveren omdat -ergens- in de abstracte class $variable wel een waarde krijgt!

Nu is dit een versimplificeerd voorbeeld, maar zodra je het over wat grotere classes gaat hebben ga je volgens mij heel snel situaties krijgen waarin variabelen ineens halverwege veranderen omdat een ander stuk code ze ook gebruikt en ze toevallig nog niet assigned waren binnen een bepaalde scope - helemaal omdat PHP in tegenstelling tot bijvoorbeeld VC++ ook nog geen namespaces kent. Dan neem ik die 6 extra tekens met genoegen voor lief om dat soort maf gedrag te voorkomen.

[MisterData]

Dat is ook een beetje zo gegroeid omdat je in C++ en Java kunt aangeven of je member variabelen al dan niet zichtbaar zijn in subclasses (private vs. protected/public). Verder worden C++ en Java gecompileerd en zijn er gewoon regels die vertellen welke variabele er moet worden gekozen als er meerdere met dezelfde naam in de scope zijn. Wil je dan toch een andere, dan kun je de Base::member notatie gebruiken om een specifieke variabele aan te wijzen. PHP kent pas access modifiers sinds PHP5 en daarvoor was de $this->member syntax al volop in gebruik. Daarnaast is iedere variabele in C++ en Java vantevoren bekend, maar in PHP kun je nog een hoop andere grapjes uithalen die ervoor zorgen dat je at runtime steeds andere variabelen kunt hebben

[Grijze Vos]

Strong typed talen kunnen tenminste een compiler warning geven hierover, iets wat een interpreted taal natuurlijk niet kan.

[Verwijderd]

toch leuk dat een tiepfoutje van me een hele discussie op laait over talen maarja. ik vind het zelf niet zo onlogisch. ik moet er alleen wel aan denken

[FragFrog]

Grijze Vos schreef op zaterdag 10 november 2007 @ 00:19:
Strong typed talen kunnen tenminste een compiler warning geven hierover, iets wat een interpreted taal natuurlijk niet kan.

Tja, zie ook mijn laatste opmerking in mijn eerste post: PHP begint het gelukkig eindelijk te kunnen Waarom ze wel support voor typehinting van classes en arrays gemaakt hebben en niet voor 'standaard' types als bools, ints en strings is me een raadsel, maar soit. Heb goede hoop dat dat met PHP6 nog wel goed zal komen

Overigens, MisterData, in PHP kun je ook prima aangeven of een variable private danwel public (en of static) moet zijn. Als ik in de abstracte class foo eerst private $variable had gedeclareerd was het hele probleem niet aan de orde geweest - maar dat betekend dus dat je, als $this niet zou bestaan, alle variabelen private moet maken in een dergelijk geval, aangezien in PHP classe variabelen standaard public zijn tenzij anders gedefinieerd.

Al met al is er een beetje een conflict in de filosofie achter PHP dat aan de ene kant ook mensen zonder programmeerkennis er al heel snel iets in kunnen maken maar aan de andere kant het ook steeds meer geavanceerdere functies van 'echte' talen krijgt. Dat levert helaas consessies op als deze