Einführung

Codeigniter ist ein schlankes Open-Source PHP-Framework, dass das Model-View-Controller-Muster (MVC) implementiert. Dieses Tutorial behandelt ein paar ausgewählte Aspekte, um den Einstieg in Codeigniter zu erleichtern. Ein paar Minuten lesen können dabei ein paar Stunden try-and-error-Zeit sparen.

1. Controller-Konstruktor

Die Controller-Klassen befinden sich in diesem Verzeichnis: system\application\controllers. Es ist wichtig, dass alle Controller-Klassen immer das Controller-Interface des Frameworks erweitern und dass im Konstruktor immer der Parent-Konstruktor aufgerufen wird:

class My_first_controller extends Controller {
   function My_first_controller(){
      parent::Controller(); // <- don't forget this
      // here goes your code
   }
}

2. URL Parameter in Funktionen

Codeigniter verwenden einen interessanten Ansatz, um sprechende URLs zu generieren. URLs werden folgendermaßen zusammengesetzt:

.../My_first_controller/hello/world/en

Diese URL würde eine Funktion namens hello in der Controller-Klasse namens My_first_controller aufrufen und zwei Parameter an die Funktion weitergeben: world und en. Dieses Verhalten könnte man z.B. so nutzen:

class My_first_controller extends Controller {
   function hello( $who, $lang ){
      if ( $lang = "en" ){ echo( "Hello $who!" ); }
      if ( $lang = "de" ){ echo( "Hallo $who!" ); }
   }
}

Die Ausgabe wäre dann “Hello world!”. ABER man sollte natürlich nie echo in einem Controller aufrufen.

3. Post-Parameter holen

Post-Parameter mit reinem PHP einzulesen könnte so aussehen:

$user = isset( $_POST["user"] ) ? $_POST["user"] : "";

Diese etwas unkomfortable Art Post-Parameter einzulesen wird von Codeigniter abstrahiert:

$user = $this->input->post( "user" );

Zusätzlich kann man auch direkt einen XSS-Filter für Post-Parameter aktivieren:

$user = $this->input->post( "user", true );

Mehr Informationen über Parameter gibt es hier:

www.codeigniter.com/user_guide/libraries/input.html

4. Config-Dateien benutzen

Config-Dateien befinden sich immer im Ordner system\application\config. In diesem Verzeichnis kann man auch die Standard-Config-Datei finden: config.php. Der Zugriff auf Variablen in dieser Config-Datei funktioniert wie folgt:

$this->config->item( "base_url" );

Jedes Projekt wird früher oder später eigene Config-Dateien benötigen, um globale Variablen zu speichern. Mit Codeigniter ist es möglich eigene Config-Dateien im Config-Verzeichnis zu erstellen (in diesem Fall: custom.php). In einer Config-Datei können dann neue Werte im Config-Array gespeichert werden:

$config['version'] = "0.1.4";

Um auf diese Konfigurationen zuzugreifen muss die Config-Datei noch in der Controller-Klasse geladen werden:

$this->config->load('custom');

Die Versionsnummer ist in der Konfigurationsdatei gespeichert und kann so ausgelesen werden:

$this->config->item('version');

Mehr Informationen über Konfigurationsdateien:

www.codeigniter.com/user_guide/libraries/config.html

5. Basis-URL

In jedem Projekt ist eines der ersten Dinge,die erledigt werden müssen, die Anpassung der Basis-URL in der Standard-Config-Datei (system\application\config\config.php).

$config['base_url'] = "http://www.mydomain.tdl";

Jedes mal wenn das Projektverzeichnis verschoben wird, muss diese Konfiguration angepasst werden. Das folgende Snippet generiert den base_url-Wert und kann anstatt des statischen String verwendet werden:

$config['base_url'] = "http://".$_SERVER['HTTP_HOST'] .
   preg_replace('@/+$@','',
      dirname($_SERVER['SCRIPT_NAME'])).'/';

6. Eigene Bibliotheken erstellen

Ein weiteres Verzeichnis in dem Framework enthält die Bibliotheken (system\application\libraries). Diese Bibliotheken sind Klassen, die eine eher generelle Funktion haben. Die Datei, die die Bibliothek enthält, muss nach der Klasse die sie enthält benannt werden: Myfirstlib.php müsste also die Klasse Myfirstlib enthalten. Datei- und Klassennamen müssen mit einem Großbuchstaben beginnen. Um eine eigene Bibliothek in eine Controller-Klasse einzubinden ist nur eine Zeile Code notwendig:

$this->load->library('myfirstlib');

Dies erzeugt bereits eine Instanz der Bibliotheksklasse. Diese Instanz kann direkt verwendet werden:

$this->myfirstlib->helloworld();

Mehr Informationen zum Thema Bibliotheken:

www.codeigniter.com/user_guide/general/creating_libraries.html

7. Form Helper

In View-Klassen wird der finale HTML-Code generiert (system\application\views). Das ist das V in MVC. Codeigniter stellt dafür sogenannte Helper-Klassen zur Verfügung. Die Form-Helper-Klasse enthält z.B. Methoden um HTML-Form-Elemente zu erzeugen. Diese Helper-Klasse kann wie folgt im Konstruktor eines Controllers geladen werden:

$this->load->helper('form');

Das war's! Jetzt kann ein HTML-Formular - zum Beispiel um Spam zu abonnieren - mit Hilfe der Helper-Methoden erstellt werden:

echo form_open("spamsubscription/index");
echo form_input( array( "name" => 
   "email", "value" => "", "size" => "30" ) );
echo form_submit("submit", "Sign me up for spam!");
echo form_close();

Weitere Informationen über Form-Helper gibt es hier:

www.codeigniter.com/user_guide/helpers/form_helper.html

8. Header Library

Die Header Library 2.0 bietet nützliche Funktionalitäten, die nicht im Umfang von Codeigniter enthalten sind (Header Library v2.0). Diese Bibliothek hilft bei der Generierung des HTML-Headers - also alles zwischen <head>und </head> in einem HTML-Dokument. Sie bietet komfortable Funktionen, um z.B. Stylesheets, JavaScript und Meta-Tags einzubinden. Nachdem man die Bibliothek runtergeladen hat und in das Bibliotheksverzeichnis kopiert hat, kann man sie wie folgt einbinden:

$this->load->library('header');

So kann man dann in einer View-Datei die generierten Headerteile einbinden:

<?php echo $header["doctype"] ?>
<html>
  <head>
  <title><?php echo( $pageTitle ); ?></title>
  <?php 
     echo $header["stylesheets"];
     echo $header["javascript"]; 
   ?>
  </head>

Die header.php Datei kann hier runtergeladen werden:

www.daytonnolan.com/code_igniter/header-library-v20-codeigniter-extension

9. Mehrere Formulare auf einer Seite

Wenn man mehrere Formulare auf einer Seite realisieren möchte, kann folgender Routing-Ansatz verwendet werden, um sicher zu stellen, dass man ein klares Konzept in der Controller-Klasse beibehält:

class My_first_controller extends Controller {
 
   public function index(){
      if ( $this->input->post("submit_button_1") ){ 
         $this->form1(); 
      }
      if ( $this->input->post("submit_button_2") ){ 
         $this->form2(); 
      }
   }
 
   private function form1(){
      // react on form1 inputs here
   }
 
   private function form2(){		
      // react on form2 inputs here
   }
}

Wichtig ist, dass jedes Formular auf die index-Funktion verweisen muss. Von dort aus wird die Ausführung - abhängig vom Namen des verwendeten Submit-Buttons - in private Methoden weitergeleitet, die nicht über die URL aufgerufen werden können.

10. Statische Hilfsfunktionen

Letztlich ist es immer hilfreich, einige statische Hilfsfunktionen zur Verfügung zu stellen, die man überall aufrufen kann ohne sich über die Instanziierung eines Objekts Gedanken machen zu müssen:

class Utilities{
 
  public static function versionStr( $version ){
    return( "Version: $version" );
  }
 
  public static function getLogDateTime(){
    return( date("Y/m/d H:i:s") );
  }
 
}

Solche statischen Funktionen können folgendermaßen aufgerufen werden:

$log .= Utilities::getLogDateTime() . "something happened";

Jetzt bookmarken: