A $this változó nem annyira objektumorientált, mint gondolnád

Mielőtt továbbmennénk, nézzük meg a $this kulcsszót. Ez kizárólag az objektumorientált programozás (OOP) céljait szolgálja, és azon kívül semmilyen jelentőséggel nem bír. Mi lehetne ennél OOP-szerűbb?

A $this kulcsszó varázslatos módon lehetővé teszi az objektum példányai számára, hogy hozzáférjenek a saját állapotukhoz. A $this az aktuális objektumra utal. Ebben az értelemben, amikor változókat használunk, a $this kulcsszó hihetetlenül erős az OOP világában.

Az állapot eléréséhez a $this fantasztikus eszköz, amely sem a funkcionalitás, sem a rugalmasság, sem más OOP-elvek tekintetében nem okoz problémát.

Viszont amint a $this kulcsszót arra használod, hogy egy osztályon belüli metódust hívj meg, a határvonal elmosódik, és az egész kevésbé lesz objektumorientált, mint elsőre tűnt. Ezzel ugyanis gyakorlatilag nagyon specifikus implementációhoz kötöd magad az adott metódus esetében. Ideális esetben az OOP-ben szinte minden metódus implementációját helyettesíthetővé kell tenni. Ennek két fő előnye van: egyrészt megkönnyíti a tesztelést, másrészt nagyobb rugalmasságot biztosít az egész alkalmazás számára.

Képzelj el egy programot, amely egyetlen osztály egyetlen példányából áll. Pontosan ugyanúgy működne, ha eltávolítanád az osztály {} burkolót, és az összes változó globális lenne, a metódusok pedig eljárásalapú függvények. Most képzeld el ugyanennek az osztálynak több példányát. Ilyenkor ugyan különböző adatokat használhatsz, de a viselkedés (metódusok) nem változtatható meg.

Például:

class A
{
  public function foo()
  {
    $this->bar('x');
  }

  public function bar($x)
  {
    echo $x;
  }
}

Az A::foo() metódusban található $this->bar() hívás kizárólag az A::bar() metódusra utalhat. Ez nem helyettesíthető más implementációval. Bármikor, amikor $this->bar(); hívást kezdeményezünk az A osztály bármely más metódusából, a $thisváltozó az A osztály egy példányát fogja tartalmazni, és a metódushíváshoz szükséges implementációt az A::bar() biztosítja (noha a hívás nem statikus módon történik).

Az osztályon belüli metódushívások hatása az, hogy gyakorlatilag "statikussá" teszik a hívást. Ha figyelmen kívül hagyjuk az objektumállapot elérését, érdemes megvizsgálni a funkcionális különbséget a következő két osztály között:

class A
{
  public function foo()
  {
    $this->bar('x');
  }

  public function bar($x)
  {
    echo $x;
  }
}
class A
{
  public function foo()
  {
    A::bar('x');
  }

  public static function bar($x)
  {
    echo $x;
  }
}

Vagy esetleg:

function foo()
{
  bar('x');
}

function bar($x)
{
  echo $x;
}

Válasz: nincs különbség. Mindhárom eset pontosan ugyanúgy működik. Ha az A::foo() metódust meghívjuk, az A::bar() metódus hívása is megtörténik. Mindhárom forgatókönyvben nincs lehetőség arra, hogy egy A objektumot másik bar() metódus implementációval hozzunk létre. Bár bizonyos esetekben ez hasznos lehet, a legtöbb esetben problémát okoz.

Gondoljunk csak az egységtesztelésre. Az A::foo() metódust lehetetlen tesztelni anélkül, hogy az A::bar() tesztelése is megtörténne. Ha hibát találunk az A::bar() metódusban, az közvetlenül hatással lesz az A::foo() működésére. Azáltal, hogy $this->bar(); hívást használunk, lehetetlenné válik a bar() implementációjának helyettesítése a tesztelés során, így nem lehet gyorsan elkülöníteni a hiba helyét (hogy az a foo vagy a bar metódusban található).

Ha az A::foo() metódus tesztje sikertelen, lehetetlen eldönteni, hogy a hibát a foo() metódus kódja vagy a bar() metódus kódja okozta.

Lényegében kisebb jelentőséggel, de ugyanazon érvelés alkalmazható, mint a függőségek injektálása és a singletonok összehasonlítása során. Ez a "Tell, Don't Ask" elv metódus szinten, nem pedig objektum szinten. Függőséginjektálás esetén például egy mock objektumot tudunk injektálni a teszteléshez. Singleton használata esetén viszont a függőség viselkedésének megváltoztatása problémássá válik. Valószínűleg a legtöbben már találkoztak a singletonok ellen szóló, több száz cikk valamelyikével, amelyek részletesen kifejtik, miért rossz ötlet a singletonok használata.

Bár a $this->method(); használatának negatív hatása kisebb, mint a singletonoké (mivel az összes érintett metódus egy osztályban található), az érvelés ugyanaz. Általában egy nem megfelelő $this->method(); hívás komolyabb problémát jelez, nevezetesen az elkülönített felelősségek (Separation of Concerns) hiányát.

Ezek az érvek egyébként azonosak azokkal, amelyeket az objektumorientált programozás hívei, például Misko Hevery, a statikus metódusokkal kapcsolatban felhoznak. Ennek oka, hogy amint korábban említettem, a $this->method(); hívás lényegében egy statikus metódus hívás, mivel nem helyettesíthető sem tesztelés során, sem futásidőben, sem az alkalmazás élettartama alatt.

Ha ez a három példa funkcionálisan ekvivalens, akkor mit nyerünk az objektumorientált programozással?

Mi történne, ha a képernyőre való kiírás helyett egy fájlba szeretnék írni? Az öröklődés lehet egy megoldás:

class A
{
  public function foo()
  {
    $this->bar('x');
  }

  public function bar($x)
  {
    echo $x;
  }
}

class B extends A
{
  public function bar($x)
  {
    file_put_contents('file', $x);
  }
}

Első pillantásra úgy tűnik, hogy ez megoldja a korábban említett problémákat. A bar() metódust sikeresen helyettesítettük, és:

A $this valóban kontextusfüggő. Utalhat egy A objektumra vagy egy B objektumra. A bar() metódus helyettesíthető egy alosztály használatával, így nem mindig jelent automatikusan A::bar()-t. Azonban ez egy nagyon rugalmatlan módon lett megvalósítva.

Az egész osztály kiterjesztése csak egy metódus felülírása érdekében problémás, mert mi történik, ha két metódust szeretnél különböző módon felülírni?

Ez még mindig nem igazán OO, mert az objektum létrehozásakor az implementáció "rögzül". Egy A objektum mindig a képernyőre ír, míg egy B objektum mindig fájlba ír. Gondolj erre:

class A
{
  public function foo()
  {
    $this->bar('x');
  }

  public function bar($x)
  {
    echo $x;
  }
}

class B extends A
{
  public function bar($x)
  {
    file_put_contents('file', $x);
  }
}

$a = new A();
$b = new B();

$a->foo();
$b->foo();

Ebben a pontban az $a változóban lévő A példány kizárólag a képernyőre tud írni, míg a $b változóban lévő B példány csak fájlba tud írni. Ennek oka, hogy a belső $this->bar(); metódushívás egy előre meghatározott bar() implementációra hivatkozik, amely már az objektum típusának (A vagy B) deklarálásakor rögzült.

Hogyan lehet ezt megoldani? Ahogyan sokan már azonosították, ez a probléma az elkülönített felelősségek (Separation of Concerns) hiányára vezethető vissza, és az osztály két részre bontásával orvosolható:

interface AOutputter
{
  public function bar($output);
}

class A
{
  public function foo(AOutputter $outputter)
  {
    $outputter->bar('x');
  }
}

class AScreenOutput implements AOutputter
{
  public function bar($x)
  {
    echo $x;
  }
}

class AFileOutput implements AOutputter
{
  public function bar($x)
  {
    file_put_contents('file', $x);
  }
}

$a = new A();
$b = new A();

$a->foo(new AScreenOutput());
$b->foo(new AFileOutput());

A B osztályt teljesen eltávolítottuk, és helyette két új osztály jött létre, amelyek kizárólag az adatok kimenetére összpontosítanak. Ezek az osztályok az A osztály foo metódusába kerülnek átadásra.

Az eredmény az, hogy már nem használunk $this->bar() hívást. Ehelyett a metódus egy dinamikus objektumon kerül meghívásra. Az $outputter változó bármilyen típusú objektumra hivatkozhat, míg $this csak az aktuális objektum típusára utalhat. Ennek az az előnye, hogy bármely A objektum kimeneti mechanizmusa futásidőben, dinamikusan dönthető el, és nem rögzül az objektum inicializálásakor.

Ez egy kulcsfontosságú koncepció az OOP-ben, és az egyik fő érv amellett, hogy a $this->method(); hívásokat lehetőség szerint el kell kerülni.

Hogyan kerülhetjük el ezt a problémát?

Minden alkalommal, amikor $this->method(); hívást használsz egy osztályban, érdemes a metódust áthelyezni egy másik osztályba, és függőségként hozzáadni az eredeti osztályhoz.

Például:

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

  public function bar()
  {
    //....
  }
}

A következőképpen lenne érdemes átalakítani a kódot:

class Outputter
{
  public function bar()
  {
    // A kimeneti logika itt
  }
}

class A
{
  private $outputter;

  // Függőség injektálása az osztály konstruktorában
  public function __construct(Outputter $outputter)
  {
    $this->outputter = $outputter;
  }

  public function foo()
  {
    // A kimeneti logikát már nem az osztály végzi, hanem átadja a függőségnek
    $this->outputter->bar();
  }
}

// Példa használat
$outputter = new Outputter();
$a = new A($outputter);
$a->foo();

Itt az A osztály konstrukciója során a bar() metódus implementációja nem tartozik közvetlenül az A osztályhoz. Ez azt jelenti, hogy amikor az A objektumot létrehozzuk, az alkalmazott bar() metódus implementációja dinamikusan eldönthető és átadható. Ezzel szemben az első példában a bar() implementációja teljesen statikus, és minden egyes A objektumnak ugyanazt az implementációt kell használnia. A függőséginjektálás módszerével azonban a bar() implementációját futásidőben lehet meghatározni, ami lehetővé teszi a nagyobb rugalmasságot és a kód bővíthetőségét.

Ez a megközelítés előnyösebb, mivel:

  • Az A osztály nem kötődik szorosan egyetlen bar() implementációhoz, így azt könnyebben lehet cserélni vagy módosítani.
  • Az alkalmazás különböző környezeteiben vagy tesztelési helyzetekben más-más implementációval használható a `bar()7 metódus.
  • A tesztelhetőség javul, mivel könnyen behelyettesíthető egy mock objektum a bar() metódus tesztelésére.

Ez a flexibilitás az OOP egyik alapvető előnye, amely lehetővé teszi a kód jobb karbantarthatóságát és könnyebb bővítését.

A fenti példa eléggé mesterséges, és könnyen átláthatóvá teszi a problémákat. A valóságban azonban általában egy kicsit bonyolultabb a helyzet. Azonban itt van egy valós, széles körben alkalmazott példa, amely jól illusztrálja ezt a típusú problémát:

class BlogController extends Controller
{
  public function index()
  {
    // Változókat rendelünk a templatehez
    $this->render();
  }

  public function edit()
  {
    if ($submitted) {
      // Feldolgozzuk az adatokat
      $this->index();
    }
  }

  public function delete()
  {
    // Töröljük az adott bejegyzést
    $this->index();
  }
}

De bizonyos rendszerekben találkozhatunk a következővel is:

Valós példa: Logger rendszer

A logolás gyakori feladat a szoftverekben, és sok alkalmazásban ugyanaz a probléma merülhet fel: hogyan kezeljük a logolás különböző módjait (pl. fájlba írás, konzolra írás, vagy adatbázisba logolás)?

Nem megfelelő megoldás

class Logger
{
  public function log($message)
  {
    echo $message; // statikus kimeneti módszer
  }
}

class Application
{
  private $logger;

  public function __construct()
  {
    $this->logger = new Logger(); // Logger osztály beágyazása
  }

  public function run()
  {
    $this->logger->log("Application has started.");
  }
}

$app = new Application();
$app->run();

Ebben a példában a Logger osztály kimeneti mechanizmusa (az echo) nem rugalmas, mivel minden Logger objektum ugyanúgy viselkedik, és nem lehet futásidőben más típusú logolási mechanizmust alkalmazni (pl. fájlba vagy adatbázisba írás).

Jobb megoldás: Függőséginjektálás

A függőséginjektálás segítségével a logolás módja dinamikusan meghatározható:

interface LoggerInterface
{
  public function log($message);
}

class ConsoleLogger implements LoggerInterface
{
  public function log($message)
  {
    echo $message; // konzolra logolás
  }
}

class FileLogger implements LoggerInterface
{
  public function log($message)
  {
    file_put_contents('log.txt', $message . PHP_EOL, FILE_APPEND); // fájlba logolás
  }
}

class Application
{
  private $logger;

  // Függőség injektálása konstruktoron keresztül
  public function __construct(LoggerInterface $logger)
  {
    $this->logger = $logger;
  }

  public function run()
  {
    $this->logger->log("Application has started.");
  }
}

// Példa használat
$logger = new ConsoleLogger(); // Itt választhatjuk a logolás módját
$app = new Application($logger);
$app->run();

Ebben a példában a LoggerInterface biztosítja, hogy az alkalmazás bármilyen logolási mechanizmust támogathasson, de nem függ konkrét implementációktól. A logoló mechanizmus (ConsoleLogger vagy FileLogger) dinamikusan injektálható az Application osztályba, így könnyedén tesztelhetjük vagy módosíthatjuk a logolási stratégiát futásidőben anélkül, hogy a Application osztályon belül változtatásokat kellene végezni.

Ez a megoldás biztosítja a nagyobb rugalmasságot és karbantarthatóságot, mivel a logolás kimenete egyszerűen cserélhető, és az osztályok felelősségei jól el vannak választva egymástól.

Összegezve:

A $this->method(); használata mindig procedurális programozást jelent, mert a metódus implementációja nem helyettesíthető futásidőben, ami jelentősen korlátozza az alkalmazás rugalmasságát. Az ilyen metódushívások láncolása a felelősségek rossz szétválasztásának tünete. Ehelyett célszerű áthelyezni az implementációt egy másik osztályba, hogy futásidőben könnyen helyettesíthető legyen.

Ez nem jelenti azt, hogy a $this->method(); használata mindig rossz. Ha egy privát metódust hívunk, amely adatstruktúrát épít fel vagy csökkenti a kód ismétlését egy feladat elvégzése érdekében, akkor a $this->method() hívás valószínűleg megfelelő. Azonban ha a $this->method(); segítségével láncolunk akciókat és módosítjuk a program áramlását, akkor szinte biztos, hogy valamit rosszul csinálunk, és szükségtelenül korlátozzuk a kódunk rugalmasságát.

A problémás $this->method(); hívások jelei közé tartoznak:

  • A metódus hívása állapotváltozást okoz, de a method() nem egy egyszerű setter.
  • A metódus egy szülőosztályban van definiálva, de azt csak az alosztályok hívják meg.
  • A $this->method(); hívása akkor, amikor a method() nem ad vissza értéket.
  • A metódushívás visszatérési értékének közvetlen visszaadása: return $this->method();
  • A $this->method(); használata különböző viselkedések láncolására (pl. adatbázisba írás majd megerősítő e-mail küldése, vagy űrlap feldolgozása majd átirányítás végrehajtása).
  • Egy olyan szülőosztály metódusának meghívása, amit csak az alosztályok használnak (pl. $this->redirect() vagy $this->set() kontroller osztályokban).

Nem minden $this->method(); hívás problémás, de sok esetben ugyanazon osztályon belüli metódushívás a felelősségek rossz szétválasztására utal.

Jó példák a $this->method(); hívás használatára:

  • Nyilvános getter/setter metódusok hívása, amelyeket más kód is használ (ha ezek csak az alosztályok számára készültek, az a felelősségek rossz szétválasztását jelzi).
  • Privát metódusok hívása, amelyek csökkentik az ismétlést, vagy segítenek egy problémát felbontani, anélkül hogy módosítanák az objektum állapotát (bár gyakran jobb, ha óvatosak vagyunk, és ezt egy külön osztályba helyezzük).

A $this->method(); hívásának potenciálisan jó használata a következő esetben fordulhat elő:

class Product
{
  private $price;
  private $taxRate;

  public function foo()
  {
    $this->price = $this->getTotal();
  }

  public function getTotal()
  {
    return $this->price * $this->taxRate;
  }
}

Általánosságban elmondható, hogy a $this->method(); hívás negatív hatása minimális, és az egyetlen közvetlen következménye a rugalmasság korlátozása. Azonban ez a korlátozott rugalmasság egy sokkal nagyobb és problémásabb kérdés tünete: rossz felelősség-szétválasztás.

A rugalmasság korlátozásának problémája az, hogy nehéz lesz kikerülni, ha később szükség van rá. Ha már telepítettél egy alkalmazást, amely korlátozott rugalmassággal rendelkezik, akkor sokkal nehezebb a rugalmasságot visszaállítani, mint ha ezt már az elején figyelembe vetted volna.