Vraag Wanneer gebruik ik dit zelf meer dan $?


In PHP 5, wat is het verschil tussen gebruiken self en $this?

Wanneer is elk geschikt?


1775
2017-09-30 06:23


oorsprong


antwoorden:


Kort antwoord

Gebruik $this om naar de huidige te verwijzen   voorwerp. Gebruik self om te verwijzen naar de   huidige klasse. Met andere woorden, gebruik    $this->member voor niet-statische leden,   gebruik self::$member voor statische leden.

Volledig antwoord

Hier is een voorbeeld van correct gebruik van $this en self voor niet-statische en statische lidvariabelen:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo $this->non_static_member . ' '
           . self::$static_member;
    }
}

new X();
?>

Hier is een voorbeeld van niet correct gebruik van $this en self voor niet-statische en statische lidvariabelen:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo self::$non_static_member . ' '
           . $this->static_member;
    }
}

new X();
?>

Hier is een voorbeeld van polymorfisme met $this voor ledenfuncties:

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        $this->foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

Hier is een voorbeeld van het onderdrukken van polymorf gedrag door het gebruiken van self voor ledenfuncties:

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        self::foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

Het idee is dat $this->foo() roept de foo() lidfunctie van wat dan ook> is het exacte type van het huidige object. Als het object van is type X, zo> roept X::foo(). Als het object van is type Y, het roept Y::foo(). Maar met> self :: foo (), X::foo() wordt altijd genoemd.

Van http://www.phpbuilder.com/board/showthread.php?t=10354489:

Door http://board.phpbuilder.com/member.php?145249-laserlight


1508
2017-09-30 06:29



Het trefwoord zelf doet NIET refereer alleen naar de 'huidige klasse', althans niet op een manier die u beperkt tot statische leden. In de context van een niet-statisch lid, self biedt ook een manier om de vtable te omzeilen (zie wiki op vtable) voor het huidige object. Net zoals je kunt gebruiken parent::methodName() om de oudersversie van een functie te bellen, zodat u kunt bellen self::methodName() om de huidige klassenimplementatie van een methode aan te roepen.

class Person {
    private $name;

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

    public function getName() {
        return $this->name;
    }

    public function getTitle() {
        return $this->getName()." the person";
    }

    public function sayHello() {
        echo "Hello, I'm ".$this->getTitle()."<br/>";
    }

    public function sayGoodbye() {
        echo "Goodbye from ".self::getTitle()."<br/>";
    }
}

class Geek extends Person {
    public function __construct($name) {
        parent::__construct($name);
    }

    public function getTitle() {
        return $this->getName()." the geek";
    }
}

$geekObj = new Geek("Ludwig");
$geekObj->sayHello();
$geekObj->sayGoodbye();

Dit zal uitvoeren:

Hallo, ik ben Ludwig de nerd
     Vaarwel van Ludwig de persoon

sayHello() gebruikt de $this aanwijzer, dus de vtable wordt aangeroepen om te bellen Geek::getTitle(). sayGoodbye() toepassingen self::getTitle(), dus de vtable wordt niet gebruikt, en Person::getTitle() wordt genoemd. In beide gevallen hebben we te maken met de methode van een geïnstantieerd object en hebben we toegang tot de $this aanwijzer binnen de opgeroepen functies.


710
2017-07-27 18:00



GEBRUIK NIET self::, gebruik static::

Er is een ander aspect van zelf: dat is het vermelden waard. hinderlijk self:: verwijst naar de scope op het punt van definitie niet op het punt van uitvoering. Overweeg deze eenvoudige les met twee methoden:

class Person
{

    public static function status()
    {
        self::getStatus();
    }

    protected static function getStatus()
    {
        echo "Person is alive";
    }

}

Als we bellen Person::status() we zullen zien "Persoon leeft". Overweeg nu wat er gebeurt als we een klasse maken die hiervan overneemt:

class Deceased extends Person
{

    protected static function getStatus()
    {
        echo "Person is deceased";
    }

}

Roeping Deceased::status() we zouden verwachten te zien "Persoon is overleden" maar wat we zien is "Persoon leeft", aangezien het bereik de oorspronkelijke methode-definitie bevat wanneer self::getStatus() was gedefinieerd.

PHP 5.3 heeft een oplossing. de static:: resolutie-operator implementeert 'laat-statische binding', wat een mooie manier is om te zeggen dat het gebonden is aan het bereik van de klasse die wordt genoemd. Verander de regel in status() naar static::getStatus() en de resultaten zijn wat je zou verwachten. In oudere versies van PHP zul je een kans moeten vinden om dit te doen.

Zien PHP-documentatie

Dus om de vraag niet te beantwoorden zoals gevraagd ...

$this-> verwijst naar het huidige object (een instantie van een klasse), terwijl static::verwijst naar een klasse


428
2017-07-24 15:08



Om echt te begrijpen waar we het over hebben als we het hebben over self versus $this, we moeten echt graven in wat er gaande is op een conceptueel en een praktisch niveau. Ik voel niet echt dat een van de antwoorden dit op de juiste manier doet, dus hier is mijn poging.

Laten we beginnen door te praten over wat een klasse en een voorwerp is.

Klassen en objecten, Conceptueel

Dus is een klasse? Veel mensen definiëren het als een plan of a sjabloon voor een object. Sterker nog, je kunt meer lezen Over klassen in PHP hier. En tot op zekere hoogte is dat wat het werkelijk is. Laten we naar een klas kijken:

class Person {
    public $name = 'my name';
    public function sayHello() {
        echo "Hello";
    }
}

Zoals je ziet, is er een eigenschap in die klasse genaamd $name en een methode (functie) genaamd sayHello().

Haar heel belangrijk om op te merken dat de klasse is een statische structuur. Dat betekent dat de klas Person, eenmaal gedefinieerd, is altijd overal hetzelfde waar je ernaar kijkt.

Een object aan de andere kant is wat een an wordt genoemd aanleg van een klasse. Wat dat betekent is dat we de "blauwdruk" van de klas nemen en deze gebruiken om een ​​dynamische kopie te maken. Deze kopie is nu specifiek gekoppeld aan de variabele waarin deze is opgeslagen. Daarom zijn alle wijzigingen in een aanleg is lokaal voor die instantie.

$bob = new Person;
$adam = new Person;
$bob->name = 'Bob';
echo $adam->name; // "my name"

We creëren nieuw instanties van een klasse met behulp van de new operator.

Daarom zeggen we dat een Klasse een globale structuur is en een Object een lokale structuur. Maak je geen zorgen over dat grappige -> syntaxis, we zullen daar een beetje op ingaan.

Een ander ding waar we over moeten praten, is dat we dat kunnen controleren als een instantie een is instanceof een bepaalde klasse: $bob instanceof Person die een booleaanse waarde retourneert als de $bob instantie is gemaakt met behulp van de Person klasse, of een kind van Person.

Staat definiëren

Dus laten we een beetje graven in wat een klas eigenlijk bevat. Er zijn 5 soorten "dingen" die een klasse bevat:

  1. eigenschappen - Beschouw deze als variabelen die elke instantie zal bevatten.

    class Foo {
        public $bar = 1;
    }
    
  2. Statische eigenschappen - Zie deze als variabelen die op klasseniveau worden gedeeld. Dit betekent dat ze nooit door elke instantie worden gekopieerd.

    class Foo {
        public static $bar = 1;
    }
    
  3. methoden - Dit zijn functies die elke instantie zal bevatten (en op exemplaren werken).

    class Foo {
        public function bar() {}
    }
    
  4. Statische methoden - Dit zijn functies die over de hele klas worden gedeeld. Zij doen niet werken op exemplaren, maar alleen op de statische eigenschappen.

    class Foo {
        public static function bar() {}
    }
    
  5. constanten - Klasse opgeloste constanten. Hier niet dieper gaan, maar toevoegen voor de volledigheid:

    class Foo {
        const BAR = 1;
    }
    

Dus eigenlijk bewaren we informatie over de klasse en objectcontainer met behulp van 'hints' statisch die bepalen of de informatie wordt gedeeld (en dus statisch) of niet (en dus dynamisch).

Staat en methoden

Binnen een methode wordt de instantie van een object vertegenwoordigd door de $thisvariabel. De huidige status van dat object is aanwezig en het muteren (wijzigen) van een eigenschap resulteert in een wijziging in die instantie (maar niet in andere).

Als een methode statisch wordt genoemd, de $this veranderlijk is niet gedefinieerd. Dit komt omdat er geen instantie is gekoppeld aan een statische oproep.

Het interessante hier is hoe statische oproepen worden gedaan. Laten we het dus hebben over hoe we toegang krijgen tot de staat:

Toegang tot staat

Dus nu we die staat hebben opgeslagen, moeten we er toegang toe hebben. Dit kan een beetje lastig worden (of manier meer dan een beetje), laten we dit opsplitsen in twee gezichtspunten: van buiten een instantie / klasse (bijvoorbeeld van een normale functieaanroep of van de globale scope), en binnen een instantie / klasse (van binnen een methode op de voorwerp).

Van buiten een instantie / klasse

Van buiten de instantie / klasse zijn onze regels vrij eenvoudig en voorspelbaar. We hebben twee operators en elk vertelt ons onmiddellijk of we te maken hebben met een instantie of een statische klasse:

  • -> - object-operator - Dit wordt altijd gebruikt als we een exemplaar openen.

    $bob = new Person;
    echo $bob->name;
    

    Het is belangrijk om op te merken dat bellen Person->foo heeft geen zin (sindsdien Person is een klasse, geen instantie). Daarom is dat een ontleedfout.

  • :: - scope-resolutie-operator - Dit wordt altijd gebruikt om toegang te krijgen tot een statische eigenschap of methode van Class.

    echo Foo::bar()
    

    Bovendien kunnen we een statische methode op een object op dezelfde manier noemen:

    echo $foo::bar()
    

    Haar uiterst belangrijk om op te merken dat wanneer we dit doen van buitenaf, de instantie van het object is verborgen voor de bar() methode. Dit betekent dat het exact hetzelfde is als lopen:

    $class = get_class($foo);
    $class::bar();
    

daarom $this is niet gedefinieerd in de statische oproep.

Van binnenuit een instantie / klasse

Dingen veranderen hier een beetje. Dezelfde operatoren worden gebruikt, maar hun betekenis wordt aanzienlijk vervaagd.

De object-operator  -> wordt nog steeds gebruikt om te bellen naar de instantie van het object.

class Foo {
    public $a = 1;
    public function bar() {
        return $this->a;
    }
}

Oproep aan de bar() methode op $foo (een instantie van Foo) met behulp van de object-operator: $foo->bar() zal resulteren in de versie van de instantie van $a.

Dus dat is hoe we verwachten.

De betekenis van de :: operator hoewel veranderingen. Het hangt af van de context van de oproep naar de huidige functie:

  • In een statische context

    In een statische context, alle oproepen die worden gedaan met :: zal ook statisch zijn. Laten we een voorbeeld bekijken:

    class Foo {
        public function bar() {
            return Foo::baz();
        }
        public function baz() {
            return isset($this);
        }
    }
    

    Roeping Foo::bar() zal de baz() methode statisch, en vandaar $this zullen niet bevolkt zijn. Het is vermeldenswaard dat in recente versies van PHP (5.3 +) dit een trigger zal zijn E_STRICT fout, omdat we statische statische methoden aanroepen.

  • In een instance-context

    In de context van een instance anderzijds, oproepen gemaakt met :: afhankelijk van de ontvanger van de oproep (de methode die we bellen). Als de methode is gedefinieerd als static, dan zal het een statische oproep gebruiken. Als dit niet het geval is, wordt de instantie-informatie doorgestuurd.

    Dus, kijkend naar de bovenstaande code $foo->bar() zal terugkeren true, omdat de "statische" aanroep plaatsvindt in een instance-context.

Heb je zin? Ik dacht het niet. Het is verwarrend.

Kortere weg trefwoorden

Omdat het samenvoegen van alles samen met klassenamen nogal vies is, biedt PHP 3 standaard "snelkoppelings" -woorden om het oplossen van de reikwijdte gemakkelijker te maken.

  • self - Dit verwijst naar de huidige klassenaam. Zo self::baz() is hetzelfde als Foo::baz() binnen de Foo klasse (elke methode erop).

  • parent - Dit verwijst naar de ouder van de huidige klas.

  • static - Dit verwijst naar de opgeroepen klasse. Dankzij overerving kunnen onderliggende klassen methoden en statische eigenschappen overschrijven. Dus ze bellen met static in plaats van een klassenaam kunnen we bepalen waar de oproep vandaan kwam in plaats van het huidige niveau.

Voorbeelden

De gemakkelijkste manier om dit te begrijpen, is door naar enkele voorbeelden te kijken. Laten we een klas kiezen:

class Person {
    public static $number = 0;
    public $id = 0;
    public function __construct() {
        self::$number++;
        $this->id = self::$number;
    }
    public $name = "";
    public function getName() {
        return $this->name;
    }
    public function getId() {
        return $this->id;
    }
}

class Child extends Person {
    public $age = 0;
    public function __construct($age) {
        $this->age = $age;
        parent::__construct();
    }
    public function getName() {
        return 'child: ' . parent::getName();
    }
}

Nu kijken we ook naar overerving. Negeer even dat dit een slecht objectmodel is, maar laten we eens kijken naar wat er gebeurt als we hiermee spelen:

$bob = new Person;
$bob->name = "Bob";
$adam = new Person;
$adam->name = "Adam";
$billy = new Child;
$billy->name = "Billy";
var_dump($bob->getId()); // 1
var_dump($adam->getId()); // 2
var_dump($billy->getId()); // 3

Dus de ID-teller wordt gedeeld tussen beide instanties en de kinderen (omdat we deze gebruiken self om toegang te krijgen. Als we het hebben gebruikt static, we kunnen het in een kinderklasse opheffen).

var_dump($bob->getName()); // Bob
var_dump($adam->getName()); // Adam
var_dump($billy->getName()); // child: Billy

Merk op dat we de Person::getName()  aanleg methode elke keer. Maar we gebruiken de parent::getName() om het in een van de gevallen te doen (de kinderzaak). Dit is wat deze aanpak krachtig maakt.

Word Of Caution # 1

Merk op dat de aanroepende context is wat bepaalt of een instantie wordt gebruikt. daarom:

class Foo {
    public function isFoo() {
        return $this instanceof Foo;
    }
}

Is niet altijd waar.

class Bar {
    public function doSomething() {
        return Foo::isFoo();
    }
}
$b = new Bar;
var_dump($b->doSomething()); // bool(false)

Nu is het werkelijk raar hier. We bellen een andere klas, maar de $this dat wordt doorgegeven aan de Foo::isFoo() methode is de instantie van $bar.

Dit kan allerlei soorten bugs en conceptuele WTF-ery veroorzaken. Dus stel ik ten zeerste het vermijden van de :: operator van binnen methoden op alles behalve deze drie virtuele "short-cut" trefwoorden (static, self, en parent).

Word Of Caution # 2

Merk op dat statische methoden en eigenschappen door iedereen worden gedeeld. Dat maakt ze in feite globale variabelen. Met dezelfde problemen als die van de wereld. Dus zou ik echt aarzelend zijn om informatie op te slaan in statische methoden / eigenschappen, tenzij u er geruststellend over bent dat het echt wereldwijd is.

Word Of Caution # 3

Over het algemeen wilt u het gebruik van zogenaamde Late Static-Binding gebruiken static in plaats van self. Maar merk op dat ze niet hetzelfde zijn, dus zeggen "altijd gebruiken static in plaats van self is echt kortzichtig. Stop in plaats daarvan en denk na over de oproep die u wilt doen en denk na of u wilt dat onderliggende klassen dat kunnen negeren statisch opgelost noemen.

TL / DR

Jammer, ga terug en lees het. Het is misschien te lang, maar zo lang omdat dit een complex onderwerp is

TL / DR # 2

Oké, prima. In het kort, self wordt gebruikt om te verwijzen de huidige klassenaambinnen een klasse, waar als $this verwijst naar het huidige object aanleg. Let daar op self is een snelkoppeling voor kopiëren / plakken. Je kunt het veilig vervangen door je lesnaam, en het werkt prima. Maar $this is een dynamische variabele die niet van tevoren kan worden vastgesteld (en misschien niet eens uw klas is).

TL / DR # 3

Als de object-operator wordt gebruikt (->), dan jij altijd weet dat je te maken hebt met een instantie. Als de scope-resolutie-operator wordt gebruikt (::), hebt u meer informatie over de context nodig (bevinden we ons al in een objectcontext, bevinden we ons buiten een object, enzovoort).


228
2018-06-10 15:21



self (niet $ zelf) verwijst naar de type van klasse, waar als $this verwijst naar de huidige aanleg van de klas. self is voor gebruik in statische lidfuncties waarmee u statische lidvariabelen kunt openen. $this wordt gebruikt in niet-statische lidfuncties en is een verwijzing naar het exemplaar van de klasse waarop de lidfunctie is aangeroepen.

Omdat this is een object, je gebruikt het als: $this->member

Omdat self is geen object, het is eigenlijk een type dat automatisch verwijst naar de huidige klasse, je gebruikt het als: self::member


109
2017-09-30 07:26



$this-> wordt gebruikt om te verwijzen naar een specifiek exemplaar van de variabelen van een klasse (lidvariabelen) of methoden.

Example: 
$derek = new Person();

$ derek is nu een specifiek exemplaar van Person. Elke persoon heeft een voornaam en een achternaam, maar $ derek heeft een specifieke voornaam en achternaam (Derek Martin). In de $ derek-instantie kunnen we deze verwijzen naar $ this-> first_name and $ this-> last_name

ClassName :: wordt gebruikt om te verwijzen naar dat type klasse en de statische variabelen ervan, statische methoden. Als het helpt, kunt u het woord "statisch" in geestelijk opzicht vervangen door "gedeeld". Omdat ze worden gedeeld, kunnen ze niet verwijzen naar $ this, wat verwijst naar een specifiek exemplaar (niet gedeeld). Statische variabelen (dat wil zeggen statische $ db_connection) kunnen worden gedeeld tussen alle exemplaren van een type object. Alle databaseobjecten delen bijvoorbeeld een enkele verbinding (statische $ -verbinding).

Statische variabelen Voorbeeld: Beweren dat we een database-klasse hebben met een variabele van één lid: statische $ num_connections; Plaats dit nu in de constructor:

function __construct()
{
    if(!isset $num_connections || $num_connections==null)
    {
        $num_connections=0;
    }
    else
    {
        $num_connections++;
    }
}

Net zoals objecten constructeurs hebben, hebben ze ook destructors, die worden uitgevoerd wanneer het object sterft of wordt uitgeschakeld:

function __destruct()
{
    $num_connections--;
}

Telkens wanneer we een nieuw exemplaar maken, wordt onze verbindingsteller met één verhoogd. Telkens wanneer we een exemplaar vernietigen of stoppen, wordt de verbindingsteller met één verlaagd. Op deze manier kunnen we het aantal exemplaren van het databaseobject dat we gebruiken, volgen:

echo DB::num_connections;

Omdat $ num_connections statisch (gedeeld) is, geeft dit het totale aantal actieve database-objecten weer. Mogelijk hebt u deze techniek zien gebruiken om databaseverbindingen te delen tussen alle exemplaren van een databaseklasse. Dit wordt gedaan omdat het maken van de databaseverbinding lang duurt, dus het is het beste om er maar een te maken en te delen (dit wordt een Singleton-patroon genoemd).

Statische methoden (dat wil zeggen openbare statische weergave :: format_phone_number ($ digits)) kunnen worden gebruikt ZONDER eerst een instantie van een van die objecten te instantiëren (d.w.z. Zij verwijzen intern niet naar $ this).

Statische methode Voorbeeld:

public static function prettyName($first_name, $last_name)
{
    echo ucfirst($first_name).' '.ucfirst($last_name);
}

echo Person::prettyName($derek->first_name, $derek->last_name);

Zoals je ziet, weet de openbare statische functie prettyName niets over het object. Het werkt gewoon met de parameters die u invoert, zoals een normale functie die geen deel uitmaakt van een object. Waarom zouden we het dan niet als onderdeel van het object willen hebben?

  1. Ten eerste helpt het koppelen van functies aan objecten je dingen georganiseerd te houden, zodat je weet waar je ze kunt vinden.
  2. Ten tweede voorkomt het naamgevingsconflicten. In een groot project zijn er waarschijnlijk twee ontwikkelaars die getName () -functies maken. Als iemand een ClassName1 :: getName () maakt en de andere ClassName2 :: getName () maakt, is dit helemaal geen probleem. Geen conflict. Yay statische methoden!

ZELF:: Als je codeert buiten het object met de statische methode waarnaar u wilt verwijzen, moet u dit object bellen met de naam van het object View :: format_phone_number ($ phone_number); Als je codeert binnen het object met de statische methode waarnaar je wilt verwijzen, dat kan een van beide gebruik de naam van het object View :: format_phone_number ($ pn), OF je kunt de zelf :: format_phone_number ($ pn) sneltoets gebruiken

Hetzelfde geldt voor statische variabelen: Voorbeeld: Bekijk :: templates_path versus self :: templates_path

In de DB-klasse zouden we, als we naar een statische methode van een ander object zouden verwijzen, de naam van het object gebruiken: Voorbeeld: Session :: getUsersOnline ();

Maar als de DB-klasse naar zijn eigen statische variabele zou willen verwijzen, zou het gewoon zelf zeggen: Voorbeeld: zelf :: aansluiting;

Hoop dat het helpt om dingen duidelijk te maken :)


93
2017-10-22 17:52



Van deze blog post:

  • self verwijst naar de huidige klasse
  • self kan worden gebruikt om statische functies aan te roepen en te verwijzen naar statische lidvariabelen
  • self kan binnen statische functies worden gebruikt
  • self kan ook polymorf gedrag uitschakelen door de vtable te omzeilen
  • $this verwijst naar het huidige object
  • $this kan worden gebruikt om statische functies aan te roepen
  • $this mag niet worden gebruikt om statische lidvariabelen te noemen. Gebruik self in plaats daarvan.
  • $this kan niet worden gebruikt binnen statische functies

27
2018-05-10 12:00



In PHP gebruikt u het zelfzoekwoord om toegang te krijgen tot statische eigenschappen en methoden.

Het probleem is dat je kunt vervangen $this->method() met self::method()overal, ongeacht of method() is statisch verklaard of niet. Dus welke moet je gebruiken?

Overweeg deze code:

class ParentClass {
    function test() {
        self::who();    // will output 'parent'
        $this->who();   // will output 'child'
    }

    function who() {
        echo 'parent';
    }
}

class ChildClass extends ParentClass {
    function who() {
        echo 'child';
    }
}

$obj = new ChildClass();
$obj->test();

In dit voorbeeld self::who() zal altijd 'ouder' uitvoeren, terwijl $this->who() zal afhangen van welke klasse het object heeft.

Nu kunnen we zien dat zelf verwijst naar de klasse waarin het wordt genoemd, terwijl $this verwijst naar de klasse van het huidige object.

Dus je zou alleen jezelf moeten gebruiken wanneer $this is niet beschikbaar, of wanneer u niet wilt dat nakomende klassen de huidige methode overschrijven.


23
2017-12-29 13:20



Binnen een klassedefinitie verwijst $ dit naar het huidige object, terwijl zelf naar de huidige klasse verwijst.

Het is noodzakelijk om te verwijzen naar een klasse-element met behulp van zelf, en verwijs naar een objectelement met $ this.

self::STAT // refer to a constant value
self::$stat // static variable
$this->stat // refer to an object variable  

19
2018-05-08 06:58



Hier is een voorbeeld van correct gebruik van $ this en self voor niet-statisch   en statische lidvariabelen:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo $this->non_static_member . ' '
           . self::$static_member;
    }
}

new X();
?> 

17
2017-12-06 11:26



Volgens http://www.php.net/manual/en/language.oop5.static.php er is geen $self. Er is enkel $this, voor verwijzing naar de huidige instantie van de klasse (het object) en zelf, die kan worden gebruikt om te verwijzen naar statische leden van een klasse. Het verschil tussen een objectinstantie en een klasse komt hier om de hoek kijken.


16
2017-09-30 06:29