Applicatie naamgeving

Liever nog zien we het antwoord gewoon hier in dit topic...

Het woord is aan...

JARON!

@PHP Scripter: Heeft Jaron al iets laten horen via PM?

@ozzie, dit is nog steeds bumpen van het topic... I.p.v. vragen op antwoord vragen of iemand anders het antwoord al gevonden heeft...
Ik weet dat ik de moderators niet mag helpen, maar ik begin dit een beetje storend te vinden.

Wouter, PHP Scripter zou een PM sturen naar Jaron. Ik vraag gewoon of daar al reactie op is. Mja, misschien storend voor jou. Ik vind het veel storender dat iemand een stelling deponeert en die vervolgens niet wil / kan verdedigen.

Haha, wat een reacties op 1 zinnetje ;).
Ik denk dat hij meent dat
$user_name = User::getName($user_id);
Niet net is en het
$user_name = User::getById($user_id)->getName();
zou moeten zijn.

Ik vind zelf trouwens
$user = new User($user_id);
een lelijke methode om data uit je DB te halen en een User te instantiëren, omdat je complexe handelingen (DB query) uitvoert in de constructor, die in mijn ogen slechts het object moet opzetten, niet vullen.

De mooiste methode is m.i. een statische method factory, zoals ik eerder gebruikt heb en die staat hier niet in. Misschien bedoelde Jason dat. In dat geval ben ik het met hem eens, al had hij dat best wat beter mogen toelichten.

Hallo Pim,

Da's alweer een tijdje geleden. Leuk om te zien dat je er weer bent.

Zou je mij eens kunnen uitleggen:

1) Waarom $user_name = User::getName($user_id) niet netjes is? Waarom is $user_name = User::getById($user_id)->getName() beter? En hoe werkt deze (in mijn ogen vreemde) constructie precies?

2) Waarom $user = new User($user_id) lelijk is? Ik heb in het verleden regelmatig voorbij zien komen dat het id in de constructor wordt meegegeven. Hoe zou jij het zelf dan doen?

Graag je reactie.

1: omdat het logischer is om een user te zoeken en die naar zijn naam vragen (wat de code doet, eerst een user opbouwen en daar getName op uitvoeren) dan aan het modeltype, de class, te vragen welke naam bij welke identifier hoort.

2: omdat een factory, het patroon dat dan gebruikt wordt, een dynamischer opbouw mogelijk maakt en een betere scheiding van verantwoordelijkheden bevat.

Dit zijn wel vooral 'estetische' overwegingen. Andere methodes kunnen net zo goed prima functioneren en ik wil ze helemaal niet met klem afraden. De net genoemde oplossingen vind ik alleen mooier.

[size=xsmall]Toevoeging op 20/12/2011 13:55:00:[/size]

De veel gebruikte ORM, dat wat de relatie van objecten en de db beheert, Doctrine2 zal, met behulp van reflection, bij het opbouwen van bestaande 'entities', bijv. een user, zelfs de constructor overslaan. Deze gebruik je dan alleen bij het aanmaken van nieuwe entities. Zo lijkt het net alsof de opgeslagen entities in het geheugen behouden blijven en dat is zo ongeveer het ultieme streven van een ORM.

[size=xsmall]Toevoeging op 20/12/2011 14:10:45:[/size]

Oh en die constructie heet geloof ik method of call chaining. Je roept de rechter functie aan op het resultaat van de linker functie:

<?php
class Number
{
protected $val;
public function __construct($val)
{
$this->val = $val;
}

// Maak een nieuwe instantie van zichzelf (dezelfde klasse) en geef die als waard de som van de eigen waarde en het argument
public function add($n)
{
return new self($this->val + $n);
}
public function __toString()
{
return $this->val;
}
}
$n = new Number(3);

echo $n->add(4);
// Geeft 7. Het object op $n maakt een nieuw object aan met waarde 7, deze echo je

echo $n-add(4)->add(2);
// Geeft 9. Het object $n maakt een nieuw object aan met waarde 7
// Dit object maakt vervolgens weer een nieuw object aan met waarde 9
// Je hebt hier dus een ketting gemaakt van functie-aanroepen

$n->add(2)->add(54)->add(3)->add(213);
// Kan natuurlijk ook
?>

Om even verder te gaan met onzin spuien:
De instantie van 'Number' zijn 'value objects', oftewel objecten die gekenmerkt worden door een bepaalde waarde. Ook zijn ze onveranderlijk. Een aanpassing zal dus altijd een nieuw object opleveren. In dit geval is $this->val ook niet aan te passen. Hetzelfde object zal dus altijd dezelfde waarde dragen, wat in veel situaties handig is.
Bron

Uhm ja... t/m punt 1 kon ik je nog volgen :)

Kun je een voorbeeld geven van punt 2 hoe jij dan een user zou aanmaken op basis van een id.

Dus je hebt:

$user_id = 12;

... en hoe dan verder?

In striktere OO talen zijn de primitieven van PHP (int, string etc) value objects.

(Toch?)

Hou het simpel Pim anders kan ik je niet volgen. Kun je een simpel voorbeeldje geven van hoe jij het zou doen?