Bár az előző részben azt ígértem, hogy a JavaScript-re fogunk áttérni, de egy cikk erejéig még maradunk a PHP-nál, ugyanis egy fontos dologról még nem esett szó: a statikus függvényekről és változókról (igen, a cím alapján nem volt nehéz kitalálni, hogy erről lesz szó).

Hogy mik is azok a statikus tulajdonságok vagy függvények? Nos egy osztály egy tulajdonságát vagy függvényét statikusnak hívjuk, ha azt elérhetjük anélkül hogy ehhez szükség lenne az osztály példányosítására. Máshogy megfogalmazva: ezek a statikus dolgok nem objektumhoz, hanem az osztályhoz kötődnek. Nézzünk is egy példát:

 class test{
   public $data = 10;
   public function write(){
      echo 'Hello world! Data: '.$this->data;
   }
}


Ennek az osztálynak a változóit és függvényeit klasszikus módon így érnénk el:

 $object = new test();
$object->write();
$object->data = 12;

Azonban ha statikussá tesszük a változót és a függvényt, akkor a következő módon használhatjuk azokat:

 test::write();
test::$data = 12;

Osztályon belül pedig mindez egyetlen, plusz static kulcsszót jelent, illetve a $this helyett a self-el hivatkozhatunk az osztályon belüli statikus változóinkra.

 class test{
   public static $data = 10;
   public static function write(){
      echo 'Hello world! Data: '.self::$data;
   }
}
Felmerülhet a kérdés, hogy akkor most egy ilyen osztály statikus értékeivel mi történik, ha példányosítjuk? A nem statikus dolgoknál megszokhattuk, hogy egy-egy osztályon belüli változó más-más értéket vehet fel az egyes objektumain belül. Ellenben (mint ahogy az elején említettük) a statikus változók nem objektumhoz, hanem osztályhoz kötődnek, ennek megfelelően mindenhol ugyanaz a változó, ugyanazzal az értékkel lesz elérhető. Nézzük is meg egy példán át:

 class test{
   public static $staticData = 10;
   public $simpleData = 20;
   public static function staticWrite(){
      echo 'Hello world! static data: '.self::$staticData;
   }
   public function simpleWrite(){
      echo 'Hello world!static data: '.self::$staticData.', simple data: '.$this->simpleData;
   }
}
$a = new test();
$b = new test();
$a->simpleWrite();
$b->simpleWrite();
$a->simpleData = 22;
$b->simpleData = 24;
test::$staticData = 12;
test::staticWrite();
$a->simpleWrite();
$b->simpleWrite();


Jelen kódban látható, hogy a statikus változó - a normál társaikkal ellentétben - statikus függvényen, vagy egy tetszőleges objektumon át kiíratva is ugyanazt az értéket veszi fel. Ezt egyértelműsíti az is, hogy a statikus függvényre és változóra csak statikus módon hivatkoztunk, normál módon (objektumon át) nem - ellenben ez utóbbira is lenne lehetőség, (példánkban módosíthatnánk az 'a' vagy a 'b' objektumon át a staticData értékét) de ez a gyakorlatban csak félreértésekhez vezetne, így a legtöbb esetben nem szokás használni. Ellenben nem statikus függvényhez vagy változóhoz statikus függvényen át nem is férünk hozzá! (nyilvánvalóan azért, mert példányosítás nélkül is elérhetőek.)

És mire jó mindez? Természetesen arra, hogyha van egy olyan tulajdonságunk, ami nem 1-1 objektumhoz kötődik, hanem az adott osztályból származók közül mindegyikhez, akkor azt statikus változóban tudunk tárolni - illetve ennek megfelelően tudunk hozzájuk tartozó statikus függvényeket is létrehozni. Mindezek mellett általános osztályoknál is jól jöhet ez, például egy dátumkezelő osztály minden függvénye lehet statikus, és használható valahogy így:

 echo myDate::format($date);

Ezzel ennek a rövidebb cikknek a végére is értünk. Úgy hogy a következő részben már tényleg a JavaScript-el fogunk foglalkozni.