Database. Class med static functions.

Statiske metoder og attributter kan kaldes uden at initialisere et nyt objekt.
Syntaxen er lidt anderledes end normalt, du kalder en metode således: Class_Name::Method_name() - bemærk de to : istedet for ->.

Et klassisk eksempel er en Singleton, et design mønster der ofte er brugt i Database-klasser. Grunden til at man ofte bruger det her, er at man gerne vil holde antallet af forbindelser til databasen til et minimum. Se følgende kode:

class DB
{
  protected static $instance;

  public function __construct()
  {
    // Start forbindelse til database
  }
 
  public static function get_instance()
  {
    if(!isset(self::$instance))
    {
      self::$instance = new self();
    }
    return $instance;
  }
}

Forbindelsen til databasen bliver startet i __construct(), og for at sikre der ikke bliver lavet en ny forbindelse til databasen hver gang man skal bruge det, kaldes get_instance() istedet. Den statiske metode get_instance() tjekker om der allerede er lavet en instance af klassen, hvis der ikke er laves der et, ellers returneres det eksisterende.

Der var sgu en fejl, den er rettet her:

class DB
{
  protected static $instance;

  public function __construct()
  {
    // Start forbindelse til database
  }
 
  public static function get_instance()
  {
    if(!isset(self::$instance))
    {
      self::$instance = new self();
    }
    return self::$instance;
  }
}

Statiske metoder er rigtige fine til at udføre alle opgaver der har relation til et objekt uden at være et objekt.
Det kunne for eksempel være at du havde en klasse kaldet person der har forskellige data. Så du kan kalde metoder på dit objekt
$person->getFirstname();

Men når nu du vil oprette en ny person ville det give god mening at bruge netop statiske metoder.
Person::createPerson($firstname,$lastname);

Statiske variabler ser man for det meste som klasse konstanter, det vil sige faste værdier som klassen gør brug af. Som kan tilgåes via klassen. Selv har jeg brugt dette når jeg har givet numeriske værdier til nogle ting i en klasse. Eksempelvis har jeg i mit CMS en Media klasse som håndtere diverse typer af medier og her har typerne som konstanter.
Media::JPG;

Takker for svar. Hvornår er det en dårlig ide at static så evt ulemper ?

RETTELSE:

Takker for svar. Hvornår er det en mindre god ide at bruge static ?

Kan stadig ikke helt se fordelen ved at have en static DB. Nogen der kan hjælpe med at sætte en normal overfor en static for at vise forskellen.

Du bruger static i DB connections når du vælger at bruge Singleton designmønsteret.
Den eneste fordel der er ved dette er der ikke oprettes utilsigtede objekter/forbindelser.
Hvad der sker i den statiske metode er at den opretter et objekt hvis der ikke allerede findes et. Grunden til du gør det i en statisk metode er at constructoren er private.

Du skal undlade at tænke over hvornår du IKKE skal bruge statiske metoder, du skal tænke over hvornår det giver mening. Som forsøgt formuleret tidligere giver statiske metoder dig mulighed for at tilgå ting direkte på klasse altså non-objekter. Det vil altså sige at det giver mening når du har en metode som ikke skal kaldes direkte på et objekt men som stadig har en relation til klassens funktion.

Og så giver jeg dig lige min DB conn klasse. Så du kan se hvordan jeg selv har implementeret det.

<?php
/**
* PHP Mysql connection object, singleton pattern
*/


class dbHandler {
        private $dbuser = "***";
        private $dbPass = "***";
        private $dbHost = "***";
        private $dbName = "***";
    private static $Instance;

    private function __construct()     {
        mysql_connect($this->dbHost, $this->dbuser, $this->dbPass) or die(mysql_error());
                mysql_select_db($this->dbName) or die(mysql_error());
        }

        /**
        * Returns an object of the database connection
        * @return Mysql Connection object
        */
    public static function getInstance()    {
        if (!self::$Instance)
        {
            self::$Instance = new dbHandler();
        }
        return self::$Instance;
    }

    /**
        * Excutes a query with no need the returning data.
        * DML&DDL queries to be used:
        * CREATE, ALTER, DROP, UPDATE, INSERT, DELETE, TRUNCATE
        * @param $sql - THe sql string to be executed
        * @return Returns true if query was executed succesfully
        */
    public function oneWayQuery($sql){
                mysql_query($sql) or die("OneWay".mysql_error()." ".$sql);
                return mysql_insert_id();
    }

        /**
        * @param String $SQL is the SQL string to be parsed to the database
        * @return ResultSet returns a resultset
        */
        public function multipleRows($sql){
            $result = mysql_query($sql) or die("Mul ".mysql_error(). " ".$sql);
            return $result;
        }     
}
?>


Det vil altså sige at du bruger klassen således:

$db = dbHander::getInstance();
$result = $db->multipleRows("SELECT * FROM table");

"Du bruger static i DB connections når du vælger at bruge Singleton designmønsteret. "

Den DB Conn klasse du har skrevet er den så static?
Bliver lidt forviret.
Du bruger:
$db = dbHander::getInstance();
$result = $db->multipleRows("SELECT * FROM table");


http://stackoverflow.com/questions/2840912/php-a-db-abstraction-layer-use-static-class-vs-singleton-object

Tak for tålmodigheden :D

$db er et objekt du får tilbage, som du kan kalde ikke-statiske metoder på.

Af ren nysgerrighed.

Hvorfor vælger du at tage point selv?

Ja det er lort undskylder. Ville bare have den lukket. Kan man lave det om så du får dem ?