[Conny Westh]

Ursprungligen postat av orreborre

Nu vet jag inte vad du egentligen är ute efter men att behöva ange alla godkända egenskaper i __set och __get känns omständigt.

Jag skulle gjort såhär: http://pastebin.com/ZDzJM0NL

Och för att lägga till nya egenskaper som ska kunna sättas definierar du först scopet och sen sätter dem till något defaultvärde i konstruktorn.

Det är ju en rätt grundläggande princip att man alltid måste definiera en klass egenskaper i dess defnition, så att man INTE kan stoppa in nya egenskaper i en klass i runtime.

Det är en del av styrkan med att ha den objektorienterde paradigmen. Man ökar kvaliten på koden mångfalt genom att programspråket stöder denna princip. Jag har aldrig sett något annat sråk som tillåter odefinierade egenskaper i en klass. I enklare imperativa skriptspråk är det vanligt att ha odeklareade/dynamiska variabler, men i objektorienterade språk brukar det i vart fall finnas den implicita tvingande egenskapen (kanske 'restriktionen' på ren svenska).

Att ha getters och setters är till för att man ska kunna ha beräknade egenskaper som ibland kan vara ganska komplexa. Men de ska vara enkla att använda. Man kan vidare ha validering av status på en egenskap genom att använda getters och setters, så man kan kasta en exception om det blir tokigheter.

Det finns även situationer där man ha komplicerade formateringsregler av caption (dvs displayvärden) men man har fortfarande en ganska teknisk grundinformation, typexempel kan vara datum som kan vara lagrat som ett mycket kompakt lagringsformat men som visas med en text som är lätt för en människa att förstå. Andra exempel är "scientific notation" o.s.v. ....

Det är kompilatorns styrka att den hjälper mig att hitta fel under utvecklingsarbetet, jag vill ALDRIG råka ut för att fel smyger med och upptäcks först i produktion. Det är ofta 100-1000 gånger dyrare att åtgärda fel som upptäcks i produktion jämfört med under kodningsfasen eller kravfasen.

[Conny Westh]

Jag har brutit ut den generella egenskapen att hantera getters och setetrs och lagt det i en abstract Rootklass så andra klasser kan ärva in beteendet och vissa egenskaper.

Så här blev det i min testkod:

<?php
///////////////////////////////////////////////////////////////////////////////
// File: AbstractRoot.php
// Class: AbstractRoot
///////////////////////////////////////////////////////////////////////////////
abstract class AbstractRoot
{
    private $_ChildClassname;

	public function __construct($ChildClassname)
	{
		$this->ChildClassname = $ChildClassname;
	}

    public function __set($name, $value)
    {
        switch ($name)
        {
            case 'ChildClassname':
                $this->_ChildClassname = $value;
                break;

            default:
            		// By throwing Exception for undefined property we can enforce strict property definition rules
            		// we also achive better error messages for improved debugging during development
            		// this is necessare because of lack of support for strict properties in php 5.3.15
            		$error = "Error: __set property: " . $name . " not supported by class: " . $this->ChildClassname . "." ;
					throw new Exception($error);
					break;
        }
    }

    public function __get($name)
    {
        switch ($name)
        {
            case 'ChildClassname':
                return $this->_ChildClassname;
                break;

            default:
            		// By throwing Exception for undefined property we can enforce strict property definition rules
            		// we also achive better error messages for improved debugging during development
            		// this is necessare because of lack of support for strict properties in php 5.3.15
            		$error = "Error: __get property: " . $name . " not supported by class: " . $this->ChildClassname . ".";
					throw new Exception($error);
					break;
        }
        return null;
    }
}

?>

<?php
///////////////////////////////////////////////////////////////////////////////
// File: Person.php
// Class: Person
///////////////////////////////////////////////////////////////////////////////
class Person extends AbstractRoot
{
    private $firstname;
    private $lastname;

	public function __construct($pFirstname, $pLastname)
	{
		parent::__construct(__CLASS__);

		// Always
		$this->firstname = $pFirstname;
		$this->lastname = $pLastname;
	}

	/* a String representation for every Person. */
	public function __toString()
	{
		return $this->firstname . " " . $this->lastname;
	}
}
?>

<?php
///////////////////////////////////////////////////////////////////////////////
// File: PersonAge.php
// Class: PersonAge
///////////////////////////////////////////////////////////////////////////////
class PersonAge extends AbstractRoot
{
    private $firstname;
    private $lastname;
    private $age;

	public function __construct($pFirstname, $pLastname, $pAge)
	{
		parent::__construct(__CLASS__);

		// Always
		$this->firstname = $pFirstname;
		$this->lastname = $pLastname;
		$this->age = $pAge;
	}

	/* a String representation for every PersonAge. */
	public function __toString()
	{
		return $this->firstname . " " . $this->lastname . " (" . $this->age . ")";
	}
}
?>

<?php
///////////////////////////////////////////////////////////////////////////////
// File: PropertiesTest.php
// Test for Class: AbstractRoot, Person, PersonAge
///////////////////////////////////////////////////////////////////////////////
class PropertiesTest
{
	public function __construct()
	{
		try
		{
			echo "\nTest of errormessage wehen faulty property ...\n";
			echo "\nStart testing class: Person.\n---------------------------------------\n\n";
			$rad = 0;

			echo "(row) - Firstname Lastname\n";
			# create a PHP Array and initialize it with Person objects
			$persons = array
			(
				new Person("Fredrik", "Framberg"),
				new Person("Greta", "Gavelstam"),
				new Person("Urban", "Urberg"),
				new Person("Anna", "Ambtesteg"),
				new Person("Henrik", "Hammarberg"),
				new Person("Kristina", "Karlestam"),
				new Person("Hans", "Hallin"),
				new Person("Berit", "Bygdén")
			);

			# print out the results - calls Person->__toString().
			foreach($persons as $person) echo "(" . ++$rad . ") - " . "$person\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (1): ',  $e->getMessage(), "\n";
		}

		try
		{
			echo "\nTest of creating new object of class Person ...\n";
			$faultyPerson = new Person("Dennis","Harper");
			echo "This message will hopefully be written to console.\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (2): ',  $e->getMessage(), "\n";
		}

		try
		{
			echo "\nTest of errormessage when faulty __set property ...\n";
			echo "(" . ++$rad . ") - " . "$faultyPerson\n";
			$faultyPerson->Age = 34;
			$faultyPerson->ShoeSize = 45;
			echo "Age: " . $faultyPerson->Age . " years.\n";
			echo "ShoeSize: " . $faultyPerson->ShoeSize . ".\n";

			echo "This message will not be written to console.\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (3): ',  $e->getMessage(), "\n";
		}

		try
		{
			echo "\nTest of errormessage when faulty __get property ...\n";
			echo "(" . ++$rad . ") - " . "$faultyPerson\n";
			echo "ShoeSize: " . $faultyPerson->ShoeSize . ".\n";
			echo "Age: " . $faultyPerson->Age . " years.\n";

			echo "This message will not be written to console.\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (4): ',  $e->getMessage(), "\n";
		}

		echo "\nDone testing class: Person.\n---------------------------------------\n\n";

		echo "\nStart testing class: PersonAge.\n---------------------------------------\n\n";
		try
		{
			echo "\nTest of errormessage when faulty __set property ...\n";
			$faultyPersonAge = new PersonAge("Arthur","Trent",47);
			echo "(" . ++$rad . ") - " . "$faultyPersonAge\n";
			$faultyPersonAge->age = 58;
			$faultyPersonAge->ShoeSize = 43;
			echo "ShoeSize: " . $faultyPersonAge->ShoeSize . ".\n";
			echo "Age: " . $faultyPersonAge->age . " years.\n";

			echo "This message will not be written to console.\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (5): ',  $e->getMessage(), "\n";
		}

		try
		{
			echo "\nTest of errormessage when faulty __get property ...\n";
			//$faultyPersonAge = new PersonAge("Gary","Middleton",56);
			echo "(" . ++$rad . ") - " . "$faultyPersonAge\n";
			echo "Age: " . $faultyPersonAge->age . " years.\n";
			echo "ShoeSize: " . $faultyPersonAge->ShoeSize . ".\n";

			echo "This message will not be written to console.\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (6): ',  $e->getMessage(), "\n";
		}

		echo "\nDone testing class: PersonAge.\n---------------------------------------\n\n";
	}
}

try
{
	$test = new PropertiesTest();
}
catch (Exception $e)
{
	echo 'Caught exception (7): ',  $e->getMessage(), "\n";
}

?>

[Weaver]

Ursprungligen postat av ConnyWesth

Jag har aldrig sett något annat sråk som tillåter odefinierade egenskaper i en klass.

Det är därför funktionerna __get/__set kallas för magiska Och magi är just oftast sådant vi vill undvika såvida det inte finns en annan lösning.

Du behöver ju faktiskt inte använda dem och de har ett par nackdelar så som:
- De är långsammare än direkt access eller access via en vanlig funktion
- Det är svårare att skriva bra dokumentation för dem

Den klassiska metoden är att skriva get/set metoder för varje värde du vill exponera och även den metoden jag rekommenderar även om det blir mer knackande på tangentbordet.

class Person
{
    private $firstname;

    public function getFirstname()
    {
        return $this->firstname;
    }

    public function setFirstname($firstname)
    {
       $this->firstname = $firstname;
    }
}

[orreborre]

Ursprungligen postat av ConnyWesth

Det är ju en rätt grundläggande princip att man alltid måste definiera en klass egenskaper i dess defnition, så att man INTE kan stoppa in nya egenskaper i en klass i runtime.

Det är en del av styrkan med att ha den objektorienterde paradigmen. Man ökar kvaliten på koden mångfalt genom att programspråket stöder denna princip. Jag har aldrig sett något annat sråk som tillåter odefinierade egenskaper i en klass. I enklare imperativa skriptspråk är det vanligt att ha odeklareade/dynamiska variabler, men i objektorienterade språk brukar det i vart fall finnas den implicita tvingande egenskapen (kanske 'restriktionen' på ren svenska).

Att ha getters och setters är till för att man ska kunna ha beräknade egenskaper som ibland kan vara ganska komplexa. Men de ska vara enkla att använda. Man kan vidare ha validering av status på en egenskap genom att använda getters och setters, så man kan kasta en exception om det blir tokigheter.

Det finns även situationer där man ha komplicerade formateringsregler av caption (dvs displayvärden) men man har fortfarande en ganska teknisk grundinformation, typexempel kan vara datum som kan vara lagrat som ett mycket kompakt lagringsformat men som visas med en text som är lätt för en människa att förstå. Andra exempel är "scientific notation" o.s.v. ....

Det är kompilatorns styrka att den hjälper mig att hitta fel under utvecklingsarbetet, jag vill ALDRIG råka ut för att fel smyger med och upptäcks först i produktion. Det är ofta 100-1000 gånger dyrare att åtgärda fel som upptäcks i produktion jämfört med under kodningsfasen eller kravfasen.

Ja, du missuppfattade vad jag menade.
Jag menade att det känns som en dålig lösning att ha en switch-/if-sats i __get och __set.
Min lösning visar ett sätt att slippa det.

[Jake.Nu]

Ursprungligen postat av ConnyWesth

Jag har brutit ut den generella egenskapen att hantera getters och setetrs och lagt det i en abstract Rootklass så andra klasser kan ärva in beteendet och vissa egenskaper.

Så här blev det i min testkod:

<?php
///////////////////////////////////////////////////////////////////////////////
// File: AbstractRoot.php
// Class: AbstractRoot
///////////////////////////////////////////////////////////////////////////////
abstract class AbstractRoot
{
    private $_ChildClassname;

	public function __construct($ChildClassname)
	{
		$this->ChildClassname = $ChildClassname;
	}

    public function __set($name, $value)
    {
        switch ($name)
        {
            case 'ChildClassname':
                $this->_ChildClassname = $value;
                break;

            default:
            		// By throwing Exception for undefined property we can enforce strict property definition rules
            		// we also achive better error messages for improved debugging during development
            		// this is necessare because of lack of support for strict properties in php 5.3.15
            		$error = "Error: __set property: " . $name . " not supported by class: " . $this->ChildClassname . "." ;
					throw new Exception($error);
					break;
        }
    }

    public function __get($name)
    {
        switch ($name)
        {
            case 'ChildClassname':
                return $this->_ChildClassname;
                break;

            default:
            		// By throwing Exception for undefined property we can enforce strict property definition rules
            		// we also achive better error messages for improved debugging during development
            		// this is necessare because of lack of support for strict properties in php 5.3.15
            		$error = "Error: __get property: " . $name . " not supported by class: " . $this->ChildClassname . ".";
					throw new Exception($error);
					break;
        }
        return null;
    }
}

?>

<?php
///////////////////////////////////////////////////////////////////////////////
// File: Person.php
// Class: Person
///////////////////////////////////////////////////////////////////////////////
class Person extends AbstractRoot
{
    private $firstname;
    private $lastname;

	public function __construct($pFirstname, $pLastname)
	{
		parent::__construct(__CLASS__);

		// Always
		$this->firstname = $pFirstname;
		$this->lastname = $pLastname;
	}

	/* a String representation for every Person. */
	public function __toString()
	{
		return $this->firstname . " " . $this->lastname;
	}
}
?>

<?php
///////////////////////////////////////////////////////////////////////////////
// File: PersonAge.php
// Class: PersonAge
///////////////////////////////////////////////////////////////////////////////
class PersonAge extends AbstractRoot
{
    private $firstname;
    private $lastname;
    private $age;

	public function __construct($pFirstname, $pLastname, $pAge)
	{
		parent::__construct(__CLASS__);

		// Always
		$this->firstname = $pFirstname;
		$this->lastname = $pLastname;
		$this->age = $pAge;
	}

	/* a String representation for every PersonAge. */
	public function __toString()
	{
		return $this->firstname . " " . $this->lastname . " (" . $this->age . ")";
	}
}
?>

<?php
///////////////////////////////////////////////////////////////////////////////
// File: PropertiesTest.php
// Test for Class: AbstractRoot, Person, PersonAge
///////////////////////////////////////////////////////////////////////////////
class PropertiesTest
{
	public function __construct()
	{
		try
		{
			echo "\nTest of errormessage wehen faulty property ...\n";
			echo "\nStart testing class: Person.\n---------------------------------------\n\n";
			$rad = 0;

			echo "(row) - Firstname Lastname\n";
			# create a PHP Array and initialize it with Person objects
			$persons = array
			(
				new Person("Fredrik", "Framberg"),
				new Person("Greta", "Gavelstam"),
				new Person("Urban", "Urberg"),
				new Person("Anna", "Ambtesteg"),
				new Person("Henrik", "Hammarberg"),
				new Person("Kristina", "Karlestam"),
				new Person("Hans", "Hallin"),
				new Person("Berit", "Bygdén")
			);

			# print out the results - calls Person->__toString().
			foreach($persons as $person) echo "(" . ++$rad . ") - " . "$person\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (1): ',  $e->getMessage(), "\n";
		}

		try
		{
			echo "\nTest of creating new object of class Person ...\n";
			$faultyPerson = new Person("Dennis","Harper");
			echo "This message will hopefully be written to console.\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (2): ',  $e->getMessage(), "\n";
		}

		try
		{
			echo "\nTest of errormessage when faulty __set property ...\n";
			echo "(" . ++$rad . ") - " . "$faultyPerson\n";
			$faultyPerson->Age = 34;
			$faultyPerson->ShoeSize = 45;
			echo "Age: " . $faultyPerson->Age . " years.\n";
			echo "ShoeSize: " . $faultyPerson->ShoeSize . ".\n";

			echo "This message will not be written to console.\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (3): ',  $e->getMessage(), "\n";
		}

		try
		{
			echo "\nTest of errormessage when faulty __get property ...\n";
			echo "(" . ++$rad . ") - " . "$faultyPerson\n";
			echo "ShoeSize: " . $faultyPerson->ShoeSize . ".\n";
			echo "Age: " . $faultyPerson->Age . " years.\n";

			echo "This message will not be written to console.\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (4): ',  $e->getMessage(), "\n";
		}

		echo "\nDone testing class: Person.\n---------------------------------------\n\n";

		echo "\nStart testing class: PersonAge.\n---------------------------------------\n\n";
		try
		{
			echo "\nTest of errormessage when faulty __set property ...\n";
			$faultyPersonAge = new PersonAge("Arthur","Trent",47);
			echo "(" . ++$rad . ") - " . "$faultyPersonAge\n";
			$faultyPersonAge->age = 58;
			$faultyPersonAge->ShoeSize = 43;
			echo "ShoeSize: " . $faultyPersonAge->ShoeSize . ".\n";
			echo "Age: " . $faultyPersonAge->age . " years.\n";

			echo "This message will not be written to console.\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (5): ',  $e->getMessage(), "\n";
		}

		try
		{
			echo "\nTest of errormessage when faulty __get property ...\n";
			//$faultyPersonAge = new PersonAge("Gary","Middleton",56);
			echo "(" . ++$rad . ") - " . "$faultyPersonAge\n";
			echo "Age: " . $faultyPersonAge->age . " years.\n";
			echo "ShoeSize: " . $faultyPersonAge->ShoeSize . ".\n";

			echo "This message will not be written to console.\n";
		}
		catch (Exception $e)
		{
			echo 'Caught exception (6): ',  $e->getMessage(), "\n";
		}

		echo "\nDone testing class: PersonAge.\n---------------------------------------\n\n";
	}
}

try
{
	$test = new PropertiesTest();
}
catch (Exception $e)
{
	echo 'Caught exception (7): ',  $e->getMessage(), "\n";
}

?>

Dummaste jag sett på länge.. Antingen kan du språket/vet vad du gör (oavsett programspråk) eller så kan/vet du inte.. Vad är det för mening med att sätta 200 parametrar som ändå inte används?

PHP-kod:

// styrkan i PHP:
$x = new StdClass();
$x->pelle = "ett namn";

// bara dumt!
eval($x->jagtrorjaghittarpanagotsomkanskeintefinnsmendetfunkarsakerteftersomphparjusakassochkontrollavindataharjusakertintemeddettaattgora); 


??

Bygga in skydd/lager-på-lager-på-lager-på-lager mot klantskallar kan ju Java/.NET fortsätta hålla på med tills dom avlider..

Förväntar du dig ett viss datatyp när du sätter en property så får du väl kolla efter det istället? Inte bara om den ens finns "definierad" i klassen.

[Clarence]

Ursprungligen postat av ConnyWesth

Jag har brutit ut den generella egenskapen att hantera getters och setetrs och lagt det i en abstract Rootklass så andra klasser kan ärva in beteendet och vissa egenskaper.

Ett par kommentarer:
Din abstrakta klass verkar lite omständig. Med switch-satsen måste du uppdatera root-klassen med alla properties för alla underklasser. Du har redan fått ett vettigt exempel med isset() istället, som du faktiskt kan lägga som en abstrakt klass utan att få massa switch cases på ett helt ologiskt ställe. Använder du PHP5.4 kan du använda den som en trait (tyvärr är den inte helt redo för alla produktionsmiljöer pga extensions som apc och patches som suhoshin).

Det finn en väl vedertagen standard för hur man skriver kommentarer för att kunna generera dokumentation i PHP - titta på phpdocumentor.

Liksom för testning har du PHPUnit (allra mest välanvänt) som gör vad du gör i din testklass, fast smidigare, bättre output och enklare att integrera i byggservrar osv.

Dynamiska properties är en styrka hos PHP. Överanvändning av det är en svaghet hos programmeraren. Med början i PHP5.4 finns det en stark anledning till att bli striktare med det då de har optimerat hanteringen av fördefinierade properties rejält.

[Ishra]

Ursprungligen postat av orreborre

Ja, du missuppfattade vad jag menade.
Jag menade att det känns som en dålig lösning att ha en switch-/if-sats i __get och __set.
Min lösning visar ett sätt att slippa det.

Din lösning är inte speciellt bra, det enda du har åstadkommit är 20 extra rader för att göra alla klassens egenskaper till public eftersom man med din kod kommer åt alla private variabler, och ifall man gör det så kan man väl likagärna sätta dom till public direkt?

Det är enligt mig självklart att man ska ha en switch/if i en get/set för att styra vad som händer, annars öppnar du ju upp klassen helt, och det kan ju inte vara tanken med get/set-metoderna.

[orreborre]

Ursprungligen postat av Ishra

Din lösning är inte speciellt bra, det enda du har åstadkommit är 20 extra rader för att göra alla klassens egenskaper till public eftersom man med din kod kommer åt alla private variabler, och ifall man gör det så kan man väl likagärna sätta dom till public direkt?

Det är enligt mig självklart att man ska ha en switch/if i en get/set för att styra vad som händer, annars öppnar du ju upp klassen helt, och det kan ju inte vara tanken med get/set-metoderna.

Fast det beror ju på vad målet med det hela är.
Som jag uppfattade det var målet att det inte ska gå att sättaegenskaper som objektet inte redan har. Alla som finns ska kunna sättas/hämtas.

[Nerix]

Ursprungligen postat av ConnyWesth

Det är ju en rätt grundläggande princip att man alltid måste definiera en klass egenskaper i dess defnition, så att man INTE kan stoppa in nya egenskaper i en klass i runtime.

Det är en del av styrkan med att ha den objektorienterde paradigmen. Man ökar kvaliten på koden mångfalt genom att programspråket stöder denna princip. Jag har aldrig sett något annat sråk som tillåter odefinierade egenskaper i en klass. I enklare imperativa skriptspråk är det vanligt att ha odeklareade/dynamiska variabler, men i objektorienterade språk brukar det i vart fall finnas den implicita tvingande egenskapen (kanske 'restriktionen' på ren svenska).

Att ha getters och setters är till för att man ska kunna ha beräknade egenskaper som ibland kan vara ganska komplexa. Men de ska vara enkla att använda. Man kan vidare ha validering av status på en egenskap genom att använda getters och setters, så man kan kasta en exception om det blir tokigheter.

Det finns även situationer där man ha komplicerade formateringsregler av caption (dvs displayvärden) men man har fortfarande en ganska teknisk grundinformation, typexempel kan vara datum som kan vara lagrat som ett mycket kompakt lagringsformat men som visas med en text som är lätt för en människa att förstå. Andra exempel är "scientific notation" o.s.v. ....

Det är kompilatorns styrka att den hjälper mig att hitta fel under utvecklingsarbetet, jag vill ALDRIG råka ut för att fel smyger med och upptäcks först i produktion. Det är ofta 100-1000 gånger dyrare att åtgärda fel som upptäcks i produktion jämfört med under kodningsfasen eller kravfasen.

Har du aldrig hört talas om metaprogrammering?

[Ishra]

Ursprungligen postat av orreborre

Fast det beror ju på vad målet med det hela är.
Som jag uppfattade det var målet att det inte ska gå att sättaegenskaper som objektet inte redan har. Alla som finns ska kunna sättas/hämtas.

Ja, om det är syftet så gör ju din kod det den ska, tycker väl ändå att det är lite onödigt kanske, men den kritiken kan jag inte rikta mot din kod :=)

Hämta egenskaper som inte finns, det går väl aldrig (dom finns ju inte?), och ifall man sätter en egenskap som inte finns egentligen så gör väl inte det så mycket?
Håller med om att är "lite fult" såklart att kunna sätta egenskaper som inte finns egentligen, men klassen borde ju inte fråga efter den egenskapen ändå så borde inte påverka något, eller missar jag något?