logo    OOP - Klasser / funktioner




Klasser

Alle klasser bør samles i en mappe.


Klasser
(mappenavn)		Abc.php
Bcd.php
...
Xyz.php
(klasseprogrammer)


Den ydre opbygning af en klasse følger et fast regelsæt bestående af 3 "niveauer:


  • Programnavn
    Hver klasse etableres i sit eget PHP-program.
  • Klasse- / Objektnavn
    Navn på den pågældende klasse (der her også kan kaldes et objekt). Klassen skal have samme navn som programmets prefix. Afsluttes med {}, hvori funktionerne placeres.
  • Egenskaber (properties) og funktioner
    De egenskaber (variabler) der er fælles for flere / alle funktioner i klassen. I visse tilfælde skal der også etableres en "__construct".


Abc.php         programnavn
<?php
class Abc{         Klasse- / objektnavn = programnavn
Egenskaber og funktioner
   egenskab 1
   egenskab ...
   egenskab n
   funktion a
   funktion b
   ...
   funktion n
}
?>


Nederst på siden er vist eksempler på to klassefiler, hhv:
Et almindeligt klasseprogram med __Construct
Et "static" klasseprogram


Efter filnavn og inde i "class objektnavn{}" består en klasse kun af egenskaber og funktiioner (og evt. en __construct).


Egenskaber / funktioner: typer


OOPtyper

OBS: Såfremt typeidenten undlades ved definitionen af egenskaber og funktioner betragtes de default som "public".


Egenskaberne og funktionerne kan være af tre (fire) forskellige typer:

Forskellen mellem dem er hvorfra og hvordan de kan bruges / udføres.


Alle fire typer egenskaber / funktioner kan forekomme i samme klasse.

Som hovedreggel vil en "static"-klasse kun indeholde "static".

Private, protected, public og public static kan som hovedregel forekomme blandet i en funktion.

Den enkelte funktion / egenskab typesættes efter hvor tilgængelig den skal være.


Egenskaber

Under brug inde i funktionernes kode (mellem { og }) identificeres egenskaberne ved IKKE at have $ som prefix.


En klasses egenskaber er dens egne variabler, der anvendes som "mellemlagre" for værdier, der anvendes i klassens funktioner. De kan være opdelt i 4 forskellige typer:

  • private
    Kan kun bruges i funktioner i den klasse, hvori den er defineret.
    Samme navn kan bruges i flere klasser.
  • protected
    Kan kun bruges i funktioner i den klasse, hvori den er defineret og i klasser extended dertil.
    Samme navn kan bruges i flere klasser. Der må dog ikke være sammenfald mellem navne i aktuel klasse og extended klasse.
  • public
    Kan bruges i funktioner udenfor den klasse, hvori den er defineret.
    Kræver navnemæssig entydighed på tværs af projektet for at undgå fejl.
  • public static
    Kan bruges i funktioner udenfor den klasse, hvori den er defineret.
    Kræver navnemæssig entydighed på tværs af projektet for at undgå fejl.


Egenskaberne defineres som oftest øverst i klassen. Det kan forsøges, at placere dem i sekvensrækkefølge. Ellers må der ty's til alfabetisk rækkefølge.


Funktioner

Funktioner er kodesekvenser, der kan udføre en eller anden aktivitet.

  • private
    Bruges i situationer som:
    Parametre
    DB-connect parametre
    Kaldenavne på DB-tabeller
    Paging (de fleste par)
    Paypal (de fleste par)
    Funktioner
    Opkobling til DB
    Paging (de fleste funkt)
    Paypal (de fleste funkt)

    "private"-funktioner kan kun udføres / bruges inde fra aktuel klasse og fra HTML-program hvortil klassen er instantieret.
    "private"-parametre kan kun bruges indenfor samme afgrænsning.
    private $_table = 'categories';
    private $_table_2 = 'products';
    public $_path = 'media/catalogue/';
    public static $_currency = '&pound;';

    public function getCategories() {
    $sql = "SELECT * FROM `{$this->_table}
    ` ORDER BY `name` ASC";
    return $this->db->fetchAll($sql);
    }
    ...
    ...


  • protected
    Bruges stort set ikke.
    "protected"-funktioner kan kun udføres / bruges inde fra aktuel klasse og fra HTML-program hvortil klassen incl. "extends" er instantieret..
    "protected"-parametre kan kun bruges indenfor samme afgrænsning.

  • public
    Bruges default "medmindre andet forekommer forkert".
    "public"-funktioner kan udføres / bruges fra andre klasser og fra HTML-program hvortil klasserne er instantieret..
    "public"-parametre kan kun bruges indenfor samme afgrænsning.

  • public static
    "public static"-funktioner kan udfør / bruges fra alle klasser / HTML-programmer uden at dens klasse er instantieret.
    public static $_page = "page";
    public static $_folder = PAGES_DIR;

    public static $_params = array();
    public static function getParam($par) {
    return isset($_GET[$par]) && $_GET[$par] != "" ?
    $_GET[$par] : null;
    }


Funktionerne kan forsøges placeret i sekvensrækkefølge. Ellers må der ty's til alfabetisk rækkefølge.


__construct()

__construct() er en såkaldt magisk PHP-funktion.


Fælles for alle funktioner er, at de skal startes "udefra". I visse klasser kan det imidlertid være hensigtsmæssigt at foretage en aktivitet straks klassen bliver instantieret. Det kan f.eks. være tilknytning af situationsafhængige værdier til parametre (f.eks. aktuelt programnavn). Denne "straksaktivitet" udføres med en __construct.


__construct() startes automatisk straks den klasse, hvori den er placeret, bliver instantieret. De relevante klasse-fælles parametre kan via __construct værdisætttes og være umiddelbart brugsklar uanset hvilken funktion, der skal bruge en eller flere af dem.


Funktioner kan startes fra __construct.

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

private function connect() {
$this->_conndb = mysql_connect($this->_host, $this->_user, $this->_password);
...


Det er normalt, at placere __construct umiddelbart efter de klassefælles egenskaber.




Funktioner: Struktur


Funktioner opbygges altid på basis af samme struktur:


funktionstype function funktionsnavn(evt. kommaseparerede parametre){
... diverse kode
}


For at undgå problemer - med især public og public static funktioner - bør alle funktioner tildeles individuelle rimeligt beskrivende navne. De enkelte elementer i navnet bør separeres med "_".


Parameter-() kan - afhængig af behovet for den enkelte funktion - enten indeholde ingen, et enkelt eller flere kommaseparerede parametre.


Parameter-() er bindeled mellem tilgængelige værdibærende parametre / variabler / konstanter defineret udenfor funktionen og anvendelsen af dem i koden inde i funktionen. Det eksterne navn

Parametre bør altid default anføres som "$parameternavn = null". De vil da have den værdi at validere på indtil den rigtige værdi er tilført.

Såfremt en funktion skal afgive data til efterfølgende brug andetsteds anvendes "return" til !!!!!

De aktuelle parameterværdier tilføres fra "funktionskaldet" i HTML eller en anden funktion. Samme sted afleveres evt. "return"-data.

private function addItems($order_id = null){
... diverse kode
return xxxx; }




Funktioner: cyklus

Funktionskald

For at en funktion (bortset fra __construct) kan udføres, skal den "kaldes" med en kode placeret udenfor funktionen. Funktionskald kan placeres både i HTML-koden og i koden inde i en funktion. Dette betyder, at den egentlige styring altid vil komme fra HTML-koden.

En funktion kaldt inde fra en funktion vil blive udført "på stedet", inden resten af koden i den kaldende funktion bliver udført.


Return

Efter at en funktion er blevet kaldt udføres den. Derefter vendes der:

med "return"
tilbage til kodelinien med funktionskaldet. Returnværdien indsættes i stedet for funktionskaldet, og udførelse fortsætter - som regel med at bruge returnværdien.
uden "return"
tilbage til kodelinien efter funktionskaldet, og udførelse fortsætter.

Udførelsen af en funktion kan derfor forenklet sammenlignes med et godt kast med en boomerang eller et loop.




Klasser: eksempler


Klasse med __construct

class Paging {
   private $_records;
   private $_max_pp;
   private $_numb_of_pages;
   private $_numb_of_records;
   private $_current;
   private $_offset = 0;
   public static $_key = 'pg';
   public $_url;

   public function __construct($rows, $max = 10) {
      $this->_records = $rows;
      $this->_numb_of_records = count($this->_records);
      $this->_max_pp = $max;
      $this->_url = Url::getCurrentUrl(self::$_key);
      $current = Url::getParam(self::$_key);
      $this->_current = !empty($current) ? $current : 1;
      $this->numberOfPages();
      $this->getOffset();
   }

   private function numberOfPages() {
      $this->_numb_of_pages = ceil($this->_numb_of_records / $this->_max_pp);
   }

   private function getOffset() {
      $this->_offset = ($this->_current - 1) * $this->_max_pp;
   }

   public function getRecords() {
   $out = array();
   if ($this->_numb_of_pages > 1) {
         $last = ($this->_offset + $this->_max_pp);
      for($i = $this->_offset; $i < $last; $i++) {
      if ($i < $this->_numb_of_records) {
      $out[] = $this->_records[$i];
      }
      }
   } else {
      $out = $this->_records;
   }
   return $out;
   }

   private function getLinks() {
   if ($this->_numb_of_pages > 1) {
      $out = array();
      // first link
      if ($this->_current > 1) {
         $out[] = "<a href=\"".$this->_url."\">First</a>";
      } else {
         $out[] = "<span>First</span>";
      }
      // previous link
      if ($this->_current > 1) {
         // previous page number
         $id = ($this->_current - 1);
         $url = $id > 1 ?
         $this->_url."&".self::$_key."=".$id :
      $this->_url;
         $out[] = "<a href=\"{$url}\">Previous</a>";
      } else {
         $out[] = "<span>Previous</span>";
      }
      // next link
      if ($this->_current != $this->_numb_of_pages) {
         // next page number
         $id = ($this->_current + 1);
         $url = $this->_url."&".self::$_key."=".$id;
         $out[] = "<a href=\"{$url}\">Next</a>";
      } else {
         $out[] = "<span>Next</span>";
      }
      // last link
      if ($this->_current != $this->_numb_of_pages) {
         $url = $this->_url."&".self::$_key."=".$this->_numb_of_pages;
         $out[] = "<a href=\"{$url}\">Last</a>";
      } else {
         $out[] = "<span>Last</span>";
      }
      return "<li>".implode("</li><li>", $out)."</li>";
      }
   }

   public function getPaging() {
      $links = $this->getLinks();
      if (!empty($links)) {
         $out = "<ul class=\"paging\">";
         $out .= $links;
         $out .= "</ul>";
         return $out;
      }
   }

}


Klasse med "static"

class Url {
   public static $_page = "page";
   public static $_folder = PAGES_DIR;
   public static $_params = array();

   public static function getParam($par) {
      return isset($_GET[$par]) && $_GET[$par] != "" ?
      $_GET[$par] : null;
   }

   public static function cPage() {
      return isset($_GET[self::$_page]) ?
      $_GET[self::$_page] : 'index';
   }

   public static function getPage() {
      $page = self::$_folder.DS.self::cPage().".php";
      $error = self::$_folder.DS."error.php";
      return is_file($page) ? $page : $error;
   }

   public static function getAll() {
      if (!empty($_GET)) {
         foreach($_GET as $key => $value) {
            if (!empty($value)) {
               self::$_params[$key] = $value;
            }
         }
      }
   }

   public static function getCurrentUrl($remove = null) {
      self::getAll();
      $out = array();
      if (!empty($remove)) {
         $remove = !is_array($remove) ? array($remove) : $remove;
         foreach(self::$_params as $key => $value) {
            if(in_array($key, $remove)) {
               unset(self::$_params[$key]);
            }
         }
      }
      foreach(self::$_params as $key => $value) {
         $out[] = $key."=".$value;
      }
      return "/?".implode("&", $out);
   }

   public static function getReferrerUrl() {
      $page = self::getParam(Login::$_referrer);
      return !empty($page) ? "/?page={$page}" : null;
   }

   public static function getParams4Search($remove = null) {
      self::getAll();
      $out = array();
      if (!empty(self::$_params)) {
         foreach(self::$_params as $key => $value) {
            if (!empty($remove)) {
               $remove = is_array($remove) ? $remove : array($remove);
               if (!in_array($key, $remove)) {
                  $input = '<input type="hidden" name="'.$key;
                  $input .= '" value="'.$value.'" />';
                  $out[] = $input;
               }
            } else {
               $input = '<input type="hidden" name="'.$key;
               $input .= '" value="'.$value.'" />';
               $out[] = $input;
            }
         }
      return implode("", $out);
      }
   }

}




















x
x