IT08 - Blogs

Unaxus der guenstige Webhoster

Tue, 26 Apr 2011 20:14:39 +0200

Hallo Leute heute möchte ich euch mal einen guten und günstigen Webhoster empfehlen unaxus.com, ich bin schon seit Jahren Kunde bei unaxus. für kleine Sachen reicht das locker aus.

Folgende Ausstattungen und Webhosting Features bietet unaxus.com für einen Preis von 4,99 Euro pro Monat an, eine Setupgebühr gibt es nicht, zuzahlen ist im vorraus für ein Jahr.

Web Features

50 GB Speicherplatz
50 Domainaccounts
UNAXUS Control Panel
Traffic Flat Rate
Unlimitiert FTP Accounts
Unlimitiert MySQL Datenbanken

Mail Features

Unlimitiert Mail Adressen
POP3 / SMTP / IMAP ready
WEBMAIL PRO (Horde und SquirrelMail vorinstalliert)
SPAM Schutz
MX Eintrag Editierbar

Technische Features

Schnelle Rackserver von HP (Intel Quad XEON Prozessoren, 12+ GB Ram, RAID Festplatten, Gbit NIC)
High Secure Rechenzentrum
Disaster Recovery
24/7 Server Monitoring
Performante Backbone
Linux OS

Script Features

PHP ready ( Version 5.2x PHP 5.3 kommt demnächst)
Flash ready
Joomla ready
Wordpress ready
Drupal ready
Typo3 ready
vBulletin ready
PHPBB ready
Ruby on Rails
mod_rewrite
Passwort Schutz
GD Unterstützung
XML Unterstützung

Weitere Features

Kostenfreier Support per Telefon
24/7 Support per E-Mail
Web Disk Pro
Unlimited Subdomains
Cron Jobs
Web Statistiken
DNS Management Plus
Business Option erhältlich (kostenpflichtig)
Web Site Builder

Schaut einfach rein unaxus.com

OOP Registry Pattern (Entwurfsmuster) in PHP

Thu, 21 Apr 2011 02:14:38 +0200

Das Registry Pattern

Um aus verschiedenen Klassen oder Funktionen auf "globale" Objekte und Variablen zuzugreifen, gibt es das Registry-Entwurfsmuster, man trifft es sehr häufig neben dem Singleton Pattern.
Eine Registry ist streng gesehen nur eine Verschiebung des globalen Gültigkeitsbereiches.
Die Registry kann als abstract deklariert werden, da nur statische Attribute und Methoden verwendet werden.

so zu erst die Klasse/n

Variante mit Exceptions

PHP CODE

abstract class Registry
{
    /**
    * Object registry provides storage for shared objects
    *
    * @var array 
    */
    private static $_registry = array();
 
    /**
    * Adds a new variable to the Registry.
    *
    * @param string $key Name of the variable
    * @param mixed $value Value of the variable
    * @throws Exception
    * @return boolean
    */
    public static function set( $key, $value ) {
        if ( !self::has($key) ) {
            self::$_registry[$key] = $value;
            return true;
        } 
        else {
            throw new Exception( 'Unable to set variable `' . $key . '`. It was already set.' );
        }
    }
 
    /**
    * Adds a new variables from an array to the Registry.
    *
    * @param array $array The list of variabls
    * @throws Exception
    * @return boolean
    */
    public static function setFromArray( array $array = null ) {
 
        if ( !empty( $array ) ) {
            foreach( $array as $key => $value ) {
                self::set( $key, $value );
            }
            return true;
        }
        else {
            throw new Exception( 'Array of Variabls was empty.' );
        }
    }
 
    /**
    * change a variable to the Registry.
    *
    * @param string $key Name of the variable
    * @param mixed $value Value of the variable
    * @throws Exception
    * @return boolean 
    */
    public static function change( $key, $value ) {
        if ( self::has($key) ) {
            self::$_registry[$key] = $value;
            return true;
        } 
        else {
            throw new Exception( 'Unable to change variable `' . $key . '`. It was not set.' );
        }
    }
 
    /**
    * Tests if given $key exists in registry
    *
    * @param string $key
    * @return boolean
    */
    public static function has( $key ) {
        return isset( self::$_registry[$key] );
    }
 
    /**
    * Returns the value of the specified $key in the Registry.
    *
    * @param string $key Name of the variable
    * @return mixed Value of the specified $key
    */
    public static function get( $key )  {
        if ( self::has( $key ) ) {
            return self::$_registry[$key];
        }
        return null;
    }
 
    /**
    * Returns the whole Registry as an array.
    *
    * @return array Whole Registry
    */
    public static function getAll() {
        return self::$_registry;
    }
 
    /**
    * Removes a variable from the Registry.
    *
    * @param string $key Name of the variable
    * @return boolean
    */
    public static function remove( $key ) {
        if ( self::has( $key ) ) {
            unset( self::$_registry[$key] );
            return true;
        }
        return false;
    }
 
    /**
    * Removes all variables from the Registry.
    *
    * @return boolean
    */
    public static function removeAll() {
        self::$_registry = array();
        return true;
    }
 
    /**
    * Gets the number ob variables in the Registry
    *
    * @return integer
    */
    public static function size() {
        return sizeof( self::$_registry );
    }
 
}

Variante 2 ohne Exceptions

PHP CODE

abstract class Registry
{
    /**
    * Object registry provides storage for shared objects
    *
    * @var array 
    */
    private static $_registry = array();
 
    /**
    * Adds a new variable to the Registry.
    *
    * @param string $key Name of the variable
    * @param mixed $value Value of the variable
    * @throws Exception
    * @return boolean
    */
    public static function set( $key, $value ) {
        if ( !self::has($key) ) {
            self::$_registry[$key] = $value;
            return true;
        } 
        else {
            echo 'Unable to set variable `' . $key . '`. It was already set.';
            exit;
        }
    }
 
    /**
    * Adds a new variables from an array to the Registry.
    *
    * @param array $array The list of variabls
    * @throws Exception
    * @return boolean
    */
    public static function setFromArray( array $array = null ) {
 
        if ( !empty( $array ) ) {
            foreach( $array as $key => $value ) {
                self::set( $key, $value );
            }
            return true;
        }
        else {
            echo 'Array of Variabls was empty.';
            exit;
        }
    }
 
    /**
    * change a variable to the Registry.
    *
    * @param string $key Name of the variable
    * @param mixed $value Value of the variable
    * @throws Exception
    * @return boolean 
    */
    public static function change( $key, $value ) {
        if ( self::has($key) ) {
            self::$_registry[$key] = $value;
            return true;
        } 
        else {
            echo 'Unable to change variable `' . $key . '`. It was not set.' ;
            exit;
        }
    }
 
    /**
    * Tests if given $key exists in registry
    *
    * @param string $key
    * @return boolean
    */
    public static function has( $key ) {
        return isset( self::$_registry[$key] );
    }
 
    /**
    * Returns the value of the specified $key in the Registry.
    *
    * @param string $key Name of the variable
    * @return mixed Value of the specified $key
    */
    public static function get( $key )  {
        if ( self::has( $key ) ) {
            return self::$_registry[$key];
        }
        return null;
    }
 
    /**
    * Returns the whole Registry as an array.
    *
    * @return array Whole Registry
    */
    public static function getAll() {
        return self::$_registry;
    }
 
    /**
    * Removes a variable from the Registry.
    *
    * @param string $key Name of the variable
    * @return boolean
    */
    public static function remove( $key ) {
        if ( self::has( $key ) ) {
            unset( self::$_registry[$key] );
            return true;
        }
        return false;
    }
 
    /**
    * Removes all variables from the Registry.
    *
    * @return boolean
    */
    public static function removeAll() {
        self::$_registry = array();
        return true;
    }
 
    /**
    * Gets the number ob variables in the Registry
    *
    * @return integer
    */
    public static function size() {
        return sizeof( self::$_registry );
    }
 
}

Welche Variante ihr benutzt liegt an euch solltet ihr aber die Exceptions Variante nutze bedenkt die Exceptions auf zufangen mit

Auffangen der Exeptions mit der Exception Variante

PHP CODE

try {
    // ausführen von Registry::set( $key, $value ); 
    // oder von Registry::setFromArray( array( 'val1' => 'abc' ) );
    // oder von Registry::change( $key, $value );
}
catch ( Exception $e ) {
    echo $e->getMessage();
    $traceArray = $e->getTrace();
    // macht was ihr wollt mit dem Trace ;) :D
}

File ambesten speichern als class.Registry.php

Der include der Klasse

PHP CODE

include( 'path_to_class' . DIRECTORY_SEPARATOR . 'class.Registry.php' );

um die Klasse zu nutzen geht man wie folgt vor

Eine Variable in die Registry schreiben

PHP CODE

Registry::set( 'test', 'Ich bin ueberall verfuegbar.' );

Variable aus einem Array in die Registry schreiben

PHP CODE

$array = array( 'value1' => 'ich', 'vaule2' => 'du' );
Registry::setFromArray( $array );

Eine Variable aus der Registry lesen

PHP CODE

$test = Registry::get( 'test' ); // Output: ich bin ueberall verfuegbar.
echo $test;

Alle Variablen aus der Registry als array geben lasse

PHP CODE

$all = Registry::getAll(); 

Eine Variable aus der Registry entfernen

PHP CODE

Registry::remove( 'test' );

Alle Variablen aus der Registry entfernen

PHP CODE

Registry::removeAll();

Eine Variable aus der Registry ändern

PHP CODE

Registry::change( 'test', 'ich bin immer noch ueberall verfuegbar' );

Prüfen ob eine Variable in der Registry gesetzt ist

PHP CODE

Registry::has( 'test' );

Die Anzahl aller Variablen aus der Rigistry geben lassen

PHP CODE

$registrySite = Registry::size();
echo $registrySize;

Das Registry Pattern läst sich wunderbar mit den Singleton Pattern Verbinden

PHP CODE

class singletonExample
{
    ......
 
    // Singleton instance
    public static function getInstance()
    {
        if ( Registry::has( 'singletonExample' ) === false ) {
            Registry::set( 'singletonExample', new self() );
        }
 
        return Registry::get('singletonExample');
    }
 
    ......
}

OOP Das Singleton Pattern

Mon, 28 Mar 2011 20:36:39 +0200

Design Pattern (Entwurfsmuster)

Pattern sind eine Möglichkeit, um optimale Verfahren und gute Entwürfe zu beschreiben. Sie zeigen eine flexible Lösung für verbreitete Programierprobleme.

Kategorie

Das Singleton Pattern wird zu den "Creational Patterns" gezählt, da es Objekte erzeugt und zurückliefert.

Der Einsatzbereich des Singleton Patterns

Das Einzelstück (Singleton) Pattern greift in Situationen, in denen es nur eine Instanz einer Klasse geben darf, dabei wird die direkte Instanziierung des Objekts über den Standardkonstuktor verhindert, in dem dieser den modifier private verwendet.
Damit aber auch außerhalb der Klasse eine Instanz angefordert werden kann wird eine statische Methode namens getInstance() beireitgestellt, diese Methode liefert dann die einzige Instanz der klasse zurück

Das gebräuchlichste Beispiel ist eine Datenbankverbindung. Die Implementierung dieses Musters erlaubt dem Programmierer diese einzige Instanz leicht für viele andere Objekte zugänglich zu machen.

Vorteile

Zugriffskontrolle kann realisiert werden.
Das Einzelstück kann durch Unterklassenbildung spezialisiert werden.
Welche Unterklasse verwendet werden soll, kann zur Laufzeit entschieden werden
Die Einzelinstanz muss nur erzeugt werden, wenn sie benötigt wird.

Nachteile

Es besteht die große Gefahr, durch exzessive Verwendung von Singletons quasi ein Äquivalent zu globalen Variablen zu implementieren und damit dann prozedural anstatt objektorientiert zu programmieren.
Abhängigkeiten zur Singleton-Klasse werden verschleiert, d. h. ob eine Singleton-Klasse verwendet wird, erschließt sich nicht aus dem Interface einer Klasse, sondern nur anhand der Implementierung. Zudem wird die Kopplung erhöht, was Wiederverwendbarkeit und Übersichtlichkeit einschränkt.

Beispiele

lazy initialization

Das Konzept der lazy initialization, d.h. das Objekt wird erst instanziiert, wenn es erstmalig angefordert wird. Der Vorteil ist, daß, wenn das Singleton niemals verwendet wird, getInstance() also niemals aufgerufen wird, auch kein Speicher (und damit ggf. verbunde Resourcen) belegt wird.

JAVA ohne lazy initialization

JAVA CODE

public class SimpleSingleton {
    private static SimpleSingleton INSTANCE = new SimpleSingleton();
 
    //Marking default constructor private
    //to avoid direct instantiation.
    private SimpleSingleton() {
    }
 
    //Get instance for class SimpleSingleton
    public static SimpleSingleton getInstance() {
        return INSTANCE;
    }
}

JAVA mit lazy initialization

JAVA CODE

public class SimpleSingleton {
    private SimpleSingleton singleInstance = null;
 
    //Marking default constructor private
    //to avoid direct instantiation.
    private SimpleSingleton() {
    }
 
    //Get instance for class SimpleSingleton
    public static SimpleSingleton getInstance() {
        if(null == singleInstance) {
            singleInstance = new SimpleSingleton();
        }
        return singleInstance;
    }
}

So und da es ja nur eine Instanz des Objektes geben darf müssen das clonen der Instanz unterbinden, das geschieht wie folgt

JAVA CODE

public Object clone() throws CloneNotSupportedException {
      throw new CloneNotSupportedException();
}

und wenn das ganze multi-threaded fähig sein soll müsste die getInstance() Methode den modifier synchronized bekommen
also so

JAVA CODE

public static synchronized SimpleSingleton getInstance(){ .... }

Hier die PHP5 Variante mit lazy initialization

PHP CODE

<?php
class Beispiel
{
    // Speichert die Instanz der Klasse
    private static $instance = null;
 
    // Ein private-Konstruktor; verhindert die direkte Erzeugung des Objektes
    private function __construct() {
        echo 'Ich bin hergestellt';
    }
 
    // Die Singleton-Methode
    public static function singleton() {
        if ( self::$instance === null ) {
            self::$instance = new self();
        }
 
        return self::$instance;
    }
 
    // Beispielmethode
    public function bellen() {
        echo 'Wuff!';
    }
 
    // Halte Benutzer vom Klonen der Instanz ab
    public function __clone() {
        trigger_error( 'Klonen ist nicht erlaubt.', E_USER_ERROR );
    }
}
?>

Japan wir sind bei dir

Mon, 14 Mar 2011 14:34:15 +0100

Es regiert zurzeit sämtliche Medien, das Erdbeben in Japan und der darauf folgende Tsunami, es ist wohl das schlimmste Unglück Japans seit 65 Jahren.

Aus diesem Anlass möchte ich drauf aufmerksam machen das der Internet-Konzern Google eine Personen-Suche in Japanisch und Englisch gestartet hat, wo unter anderem gespendet werden kann, aber auch eine Suche nach vermissten Personen ist möglich.

Zu finden ist der Dienst von Google unter folgender Adresse
http://www.google.com/crisisresponse/japanquake2011.html

Eigentlich brauche ich dazu gar nicht viel sagen da dieses schlimme Ereignis die Medien seit dem 11.03.2011 anführt.

Aber eines kann ich tun wozu ich alle anderen Aufrufen
Spendet Mitgefühl und Ehrfurcht für Japan, und hofft das Japan diese Tragödie gut übersteht.
Mein herzliches Beileid Japan.

Japan wir sind bei dir

Normalisierung Teil 5 Eine normalisierte Datenbank

Sun, 27 Feb 2011 23:34:41 +0100

1. Da fehlt noch was

Bei der Erläuterung der zweiten Normalform habe ich noch nichts zur Tabelle Bestellungen gesagt, da es dort keine Rolle spielte. Darum hole ich das hier nach. Bis jetzt haben wir drei Tabellen und zwar produkt, kunde und hersteller. Um nun eine Beziehung/Relation zu den Bestellungen herzustellen, müssen wir die IDs der einzelnen Datensätze zusammen mit der gewünschten Anzahl in einer weiteren Tabelle zusammenfassen. Die Sache mit den Paketlieferanten vergessen wir erst mal.

2. Unsere bisherigen Tabellen

produkt

+--+------------+------+------+

|id|produkt     |preis |nummer|

+--+------------+------+------+

| 1|Schlagbohrer|199.95|1000-1|

| 2|Zement      |  5.95|1000-2|

| 3|Kneifzange  | 19.95|1000-3|

| 4|Brecheisen  | 49.95|1000-4|

| 5|Hammer      | 19.95|1000-5|

+--+------------+------+------+

kunde

+--+------------+-------+-------+------------+-----+------------+

|id|doktor      |telefon|fax    |strasse     |plz  |ort         |

+--+------------+---------------+------------+-----+------------+

| 1|Blutgesicht |123-550|123-551|Kariesweg 1 |12345|Zahnstein   |

| 2|Quälstein   |456-777|456-778|Lochpfad 23 |23458|Schmerzstadt|

| 3|Eisenfaust  |789-250|789-251|Zahnwurzel 3|87454|Dolomostadt |

| 4|Rostzange   |234-100|234-101|Peinweg 5   |74512|Reissheim   |

| 5|Frankenstein|567-200|567-201|Am Dom 5    |50670|Köln        |

+--+------------+-------+-------+------------+-----+------------+

hersteller

+--+-----------+-------+-------+------------+-----+------------+

|id|zulieferer |telefon|fax    |strasse     |plz  |ort         |

+--+-----------+---------------+------------+-----+------------+

| 1|Hilti      |111-345|111-346|Bohrweg 25  |70001|Keine Ahnung|

| 2|Hoch & Tief|211-100|211-110|Schlammweg 2|50041|Wasweissich |

| 3|Eisen-Karl |504-561|504-562|Kruppstr. 57|43254|Bochum      |

| 4|Stahl AG   |600-400|600-410|Alfred-Weg 4|47847|Dortmund    |

+--+-----------+-------+-------+------------+-----+------------+

3. Unsere angepasste Tabelle bestellung

+--+------+-----+-----+-----+

|id|anzahl|pr_id|kd_id|hr_id|

+--+------+-----+-----+-----+

| 1|1     |1    |1    |1    |

| 2|5     |2    |2    |2    |

| 3|3     |3    |3    |3    |

| 4|7     |4    |4    |3    |

| 5|4     |5    |5    |4    |

| 6|9     |2    |3    |2    |

| 7|2     |4    |1    |3    |

+--+------+-----+-----+-----+

Wir legen drei neue Spalten an, in denen wir die IDs als so genannte Fremdschlüssel hinterlegen. Ach ja, so ein Konstrukt nennt man auch Relationstabelle, da sie die Beziehungen der Datensätze untereinander abbildet.
pr_id -> id der Tabelle produkt
kd_id -> id der Tabelle kunde
hr_id -> id der Tabelle hersteller

zu Teil 1 Normalisierung
zu Teil 2 1. Normalform
zu Teil 3 2. Normalform
zu Teil 4 3. Normalform

Normalisierung Teil 4 die 3. Normalform

Sun, 27 Feb 2011 10:32:40 +0100

1. Bedingung

Eine Datenbank/Relation befindet sich dann in der dritten Normalform (3NF), wenn die zweite Normalform erfüllt ist und keine so genannten transitiven Abhängigkeiten bestehen. Ins Hochdeutsche übersetzt bedeutet es folgendes:
Irgendein Feld eines Datensatzes ist von einem anderen Feld abhängig, das kein Primärschlüssel ist. Um euch das anschaulich zu erklären, erstellen wir mal eine Tabelle mit Lieferzeiten, den Firmen und deren Zuverlässigkeit.

2. Unsere Tabelle Lieferanten

+--+----------+----------------+--------+

|id|lieferzeit|firma           |verlass |

+--+----------+----------------+--------+

| 1|12h       |SupiTrans       |hoch    |

| 2|24h       |SupiTrans       |hoch    |

| 3| 8h       |HyperCompoGlobal|mittel  |

| 4| 4h       |SuperMegaNet    |saumäßig|

| 5|16h       |SuperMegaNet    |saumäßig|

| 6|irgendwann|Post AG         |saumäßig|

+--+----------+----------------+--------+

Man kann also eine Firma aus ihrer Lieferzeit ableiten. Die Zuverlässigkeit ergibt sich aber aus der Firma. Das Problem ist offensichtlich. Bietet eine Firma einen neuen Lieferservice an, so wird die Verlässlichkeit für diese Firma zweimal abgespeichert. Also wird die Tabelle aufgeteilt.

3. Die Aufteilung

Tabelle lieferzeit

+--+----------+

|id|zeit      |

+--+----------+

| 1|12h       |

| 2|24h       |

| 3| 8h       |

| 4| 4h       |

| 5|16h       |

| 6|irgendwann|

+--+----------+

Hier werden nur die Lieferzeiten abgespeichert und mit einer eindeutigen ID versehen.
Tabelle lieferfirma

+--+----------------+--------+

|id|firma           |verlass |

+--+----------------+--------+

| 1|SupiTrans       |hoch    |

| 2|HyperCompoGlobal|mittel  |

| 3|SuperMegaNet    |saumäßig|

| 4|Post AG         |saumäßig|

+--+----------------+--------+

An dieser Stelle speichern wir die Firma und ihre Verlässlichkeit ab.

Tabelle auswahl

+--+-------+

|id|auswahl|

+--+-------+

| 1|1      |

| 2|1      |

| 3|2      |

| 4|3      |

| 5|3      |

| 6|4      |

+--+-------+

Die ID der Tabelle Auswahl bezieht sich auf die ID der Tabelle Lieferzeit und der Wert der Auswahl auf die entsprechende Firma.

Merksatz 3. Normalform

In der 3. Normalform darf es keine transitiven Abhängigkeiten geben.

zu Teil 1 Normalisierung
zu Teil 2 1. Normalform
zu Teil 3 2. Normalform
zu Teil 5 Eine normalisierte Datenbank

Normalisierung Teil 3 die 2. Normalform

Sun, 27 Feb 2011 10:28:56 +0100

1. Bedingung

Eine Datenbank/Relation befindet sich dann in der zweiten Normalform (2NF), wenn die erste Normalform erfüllt ist und für jeden Primärschlüssel eindeutige Attributwerte vorhanden sind. Schauen wir uns mal an, was von unserer ursprünglichen Tabelle noch übrig geblieben ist.

2. Unser Tabelle Bestellung

+--+------------+------+------+------+

|id|produkt     |preis |nummer|anzahl|

+--+------------+------+------+------+

| 1|Schlagbohrer|199.95|1000-1|1     |

| 2|Zement      |  5.95|1000-2|5     |

| 3|Kneifzange  | 19.95|1000-3|3     |

| 4|Brecheisen  | 49.95|1000-4|7     |

| 5|Hammer      | 19.95|1000-5|4     |

| 6|Zement      |  5.95|1000-2|9     |

| 7|Brecheisen  | 49.95|1000-4|2     |

+--+------------+------+------+------+

Sofort erkennt das geübte Auge, dass wir bestimmte Artikel (Zement, Brecheisen) doppelt eingetragen haben. Damit verstoßen wir gegen die zweite Normalform. Also gliedern wir die Produkte in eine separate Tabelle aus. Damit können wir jedem Primärschlüssel eindeutige Attribute zuordnen.

Tabelle Produkt

+--+------------+------+------+

|id|produkt     |preis |nummer|

+--+------------+------+------+

| 1|Schlagbohrer|199.95|1000-1|

| 2|Zement      |  5.95|1000-2|

| 3|Kneifzange  | 19.95|1000-3|

| 4|Brecheisen  | 49.95|1000-4|

| 5|Hammer      | 19.95|1000-5|

+--+------------+------+------+

3. Redundanzfreiheit

Der ein oder andere wird jetzt einwenden, dass wir aber doppelte Preise haben, also bei der Kneifzange und beim Hammer. Das stimmt, aber ist es sinnvoll, die Preise noch mal in eine eigene Tabelle zu packen? Bei 500 Produkten mit 400 verschiedenen Preisen? Was passiert zum Beispiel, wenn der Schlagbohrer auf einmal 209,95 kostet. Dann müssten wir erst die Tabelle Preise durchwühlen, sehen, ob der entsprechende Eintrag vorhanden, wenn ja, neue Verknüpfung, wenn nein, Preis anlegen und dann verknüpfen. Und erst die Abfragen. Redundanzfreiheit bedeutet auch immer ein Verlust von Geschwindigkeit.

4. Denormalisierung

Das ist ein gebräuchliches Mittel, um Performance-Verbesserungen bei der Datenbank zu erzielen. Man nimmt dabei bewusst Redundanzen in Kauf. Aber wann tut man das? Gute Frage, da weiß ich selber keine genaue Antwort. Ich glaube, dass es eine Frage der Erfahrung ist. Im Laufe der Zeit entwickelt man genug Routine, um das zu entscheiden. Bei Produktpreisen oder zum Beispiel beim Bestelldatum kann man aber getrost solche Redundanzen in Kauf nehmen.

Merksatz 2. Normalform

Die zu speichernden Daten sind so in Tabellen aufzuteilen, dass jedes Nichtschlüsselattribut voll von einem Primärschlüssel abhängig ist.

zu Teil 1 Normalisierung
zu Teil 2 1. Normalform
zu Teil 4 3. Normalform
zu Teil 5 Eine normalisierte Datenbank

Normalisierung Teil 2 die 1. Normalform

Sun, 27 Feb 2011 10:25:48 +0100

1. Bedingung

Eine Datenbank (genauer gesagt Relation) befindet sich in der ersten Normalform (1NF), wenn in keinem Feld innerhalb der Tabellen mehrere Werte eingetragen sind.

2. Unser Beispiel

Dort haben wir ein Feld telefon_fax, das mehrere Einträge enthält. Das ist ein Verstoß gegen die 1NF. Dasselbe gilt für die Adresse und den Hersteller. Das Prinzip nennt sich "atomar".

Atomare Attributwerte
Wow, klingt wie eine Mischung aus thermonuklearem Krieg und erster Vorlesung "Einführung in die theoretische Mathematik für Informatiker". Die Erklärung selber ist sehr einfach. Atomar bedeutet in diesem Zusammenhang einzigartig und Attributwerte sind die Daten, die einzelne Spalten einer Tabelle enthalten. Es werden also z.B. nicht die Straße und der Ort in einem Feld gespeichert, sondern in zweien.

3. Erste Verbesserung

Wir müssen die Adressdaten der Kunden und Hersteller in separate Tabellen auslagern und in entsprechenden Feldern verteilen. Dabei bekommt jeder Datensatz wieder eine eindeutige ID (Identifier).

Tabelle Kunde

+--+------------+-------+-------+------------+-----+------------+

|id|doktor      |telefon|fax    |strasse     |plz  |ort         |

+--+------------+---------------+------------+-----+------------+

| 1|Blutgesicht |123-550|123-551|Kariesweg 1 |12345|Zahnstein   |

| 2|Quälstein   |456-777|456-778|Lochpfad 23 |23458|Schmerzstadt|

| 3|Eisenfaust  |789-250|789-251|Zahnwurzel 3|87454|Dolomostadt |

| 4|Rostzange   |234-100|234-101|Peinweg 5   |74512|Reissheim   |

| 5|Frankenstein|567-200|567-201|Am Dom 5    |50670|Köln        |

+--+------------+-------+-------+------------+-----+------------+

Tabelle Hersteller

+--+-----------+-------+-------+------------+-----+------------+

|id|zulieferer |telefon|fax    |strasse     |plz  |ort         |

+--+-----------+---------------+------------+-----+------------+

| 1|Hilti      |111-345|111-346|Bohrweg 25  |70001|Keine Ahnung|

| 2|Hoch & Tief|211-100|211-110|Schlammweg 2|50041|Wasweissich |

| 3|Eisen-Karl |504-561|504-562|Kruppstr. 57|43254|Bochum      |

| 4|Stahl AG   |600-400|600-410|Alfred-Weg 4|47847|Dortmund    |

+--+-----------+-------+-------+------------+-----+------------+

4. Ein wichtiger Hinweis

Dies ist ein elementares Prinzip der Normalisierung und sollte daher ständig(!) beachtet werden.

Merksatz 1. Normalform

Die erste Normalform legt fest, dass Tabellen nur aus atomaren Werten bestehen und es keine Wiederholgruppen geben darf.

zu Teil 1 Normalisierung
zu Teil 3 2. Normalform
zu Teil 4 3. Normalform
zu Teil 5 Eine normalisierte Datenbank

Normalisierung Teil 1

Sun, 27 Feb 2011 01:42:34 +0100

1. Datenbankdesign

Bevor wir uns an gutes heranwagen, will ich erst mal zeigen, wie man es nicht macht und warum. Nehmen wir mal folgende Situation an. Wir sind ein Zwischenhändler, der Zahnärzte mit allem ausstattet, was die brauchen, um uns zu foltern. Wie ich auf diese Schnapsidee gekommen bin? Ganz einfach, ich war mal bei einer Zahnärztin, und die klagte mir, dass sie nicht mit Microsoft Access klarkommt. Ich habe dann auf der Fahrt zur Arbeit überlegt, wie man das am Besten erklären kann. Das Ergebnis seht ihr hier.

2. Entwurf

Man könnte nun auf die Idee kommen, alle Bestellungen, so wie man es normalerweise aus Excel gewöhnt ist, einfach in eine Tabelle zu packen. Die Spalten adresse und hersteller mußte ich aus Platzgründen nach unten stellen. Denkt euch einfach, dass sie neben der Spalte telefon_fax stehen. Natürlich sind die Angaben völliger Blödsinn.

Tabelle Bestellung

+--+------------+------+--------+------+----------+---------------+

|id|produkt     |preis  |nummer |anzahl|doktor   |telefon_fax     |

+--+------------+------+--------+------+----------+---------------+

| 1|Schlagbohrer|199.95|1000-1|1     |Blutgesicht |123-550,123-551|

| 2|Zement      |  5.95|1000-2|5     |Quälstein   |456-777,456-778|

| 3|Kneifzange  | 19.95|1000-3|3     |Eisenfaust  |789-250,789-251|

| 4|Brecheisen  | 49.95|1000-4|7     |Rostzange   |234-100,234-101|

| 5|Hammer      | 19.95|1000-5|4     |Frankenstein|567-200.567-201|

| 6|Zement      |  5.95|1000-2|9     |Eisenfaust  |789-250,789-251|

| 7|Brecheisen  | 49.95|1000-4|2     |Blutgesicht |123-550,123-551|

+--+------------+------+------+------+------------+---------------+

+-------------------------------+-----------------------+

|adresse                        |hersteller             |

+-------------------------------+-----------------------+

|Kariesweg 1, 12345 Zahnstein   |Hilti, Adresse...      |

|Lochpfad 23, 23458 Schmerzstadt|Hoch & Tief, Adresse...|

|Zahnwurzel 3, 87454 Dolomostadt|Eisen-Karl, Adresse... |

|Peinweg 5, 74512 Reissheim     |Eisen-Karl, Adresse... |

|Am Dom 5, 50670 Köln           |Stahl AG, Adresse...   |

|Zahnwurzel 3, 87454 Dolomostadt|Hoch & Tief, Adresse...|

|Kariesweg 1, 12345 Zahnstein   |Eisen-Karl, Adresse... |

+-------------------------------+-----------------------+

3. Problematik

Allerdings fällt sofort etwas auf. Wir haben etliche doppelte Einträge und das kann zu großen Problemen führen. Im Moment sieht alles noch sehr übersichtlich aus. Aber was passiert, wenn wir 10.000 Einträge haben?
Nehmen wir mal an, Dr. Frankenstein ginge wieder seiner ursprünglichen Profession nach und würde Menschen zusammenbauen. Er fiele als unser Kunde weg, und würde nur noch als Karteileiche in unserer Datenbank unnötig Speicherplatz belegen. Oder die Einkaufspreise steigen. Oder Eisen-Karl kann nicht mehr liefern, da er pleite ist. Und wo zum Teufel kommen eigentlich die Produkte her? Wie kann jemand etwas bestellen, wenn das nicht irgendwo zentral gespeichert ist?
Ihr habt also schon gemerkt, dass unser erster Entwurf ziemlicher Müll ist, da wir bei Änderungen immer wieder vor großen Problemen stehen. Gottlob stellen uns die Mathematik und Informatik ein Werkzeug zur Verfügung, mit der wir unsere Datenbanken so aufbauen, dass sie pflegeleicht und gut wartbar sind. Das nennt sich Normalisierung. Allerdings müssen wir vorher noch ein paar Begriffe klären.

4. Redundanzen, Anomalien, Inkonsistenzen

Hinter diesen Begriffen verbirgt sich alles, was den logischen Aufbau unserer Datenbank gefährden könnte. Einen ersten Einblick in die Problematik habe ich euch schon oben gegeben.
Redundanzen, Redundanzfreiheit
Redundanzen sind einfach ausgedrückt, doppelt gespeicherte Informationen. In unserem ersten Entwurf haben wird die zuhauf, bei den Produkten, Preisen, Doktoren oder Adressen. Redundanzfreiheit ist also nur das Gegenteil von Redundanz, also die Vermeidung doppelter Einträge. Die Vorteile liegen auf der Hand:
geringerer Speicherbedarf
Erhöhung der Wartbarkeit
Vermeidung von Inkonsistenzen und Anomalien
Inkonsistenzen, Anomalien
Sind widersprüchliche Daten oder logische Brüche innerhalb eine Datenbank. Sie treten sehr oft auf, wenn man zum Beispiel Änderungen an den Inhalten vornimmt und gewisse Relationen(!) vergisst.

5. Normalisierung

Dies ist eine Sammlung von Regeln, die eingehalten werden sollten, um obige Probleme zu vermeiden. Sie gliedert sich in fünf Normalformen plus vier Sonderformen. Für normale Anwendungen (und die Einführung) reichen die ersten drei Normalformen erst mal aus.

zu Teil 2 1. Normalform
zu Teil 3 2. Normalform
zu Teil 4 3. Normalform
zu Teil 5 Eine normalisierte Datenbank

Joins in MySQL Teil 2 die Joinarten

Thu, 17 Feb 2011 14:10:03 +0100

So hier Teil 2

Inner Join

1. Das Prinzip

Der Inner Join ist praktisch identisch mit dem Prinzip des Equi- bzw Non-Equi-Joins. Dabei
wird nach identischen Spalteneinträgen innerhalb mehrerer Tabellen gesucht.
Unsere Tabellen
Hier greifen wir mal in verkürzter Form auf unsere normalisierte Datenbank zurück und
nehmen als Beispiel zwei Tabellen, die ich der Übersichtlichkeit halber auf ein Minimum
reduziert habe.

Tabelle bestellung        Tabelle produkt 

+----+--------+-------+   +----+-------------+

| id | anzahl | pr_id |   | id | produkt     | 

+----+--------+-------+   +----+-------------+

|  1 |      1 |     1 |   |  1 | Schlagbohrer| 

|  2 |      5 |     2 |   |  2 | Zement      | 

|  3 |      3 |     3 |   |  3 | Kneifzange  | 

|  4 |      7 |     4 |   |  4 | Brecheisen  | 

|  5 |      4 |     5 |   |  5 | Hammer      | 

|  6 |      9 |     2 |   |  6 | bla         | 

|  7 |      2 |     4 |   +----+-------------+ 

+----+--------+-------+

Wenn wir nun die jeweilige Anzahl an verkauften Produkten und deren Namen auflisten
wollen, so gibt es zwei Möglichkeiten, die sich zwar in der Abfrage unterscheiden, aber
dasselbe Resultat liefern.

2. Möglichkeit 1

SQL CODE

SELECT  
  SUM(b.anzahl),  
  p.produkt 
FROM  
  bestellung b, 
produkt p   
WHERE 
  b.pr_id = p.id 
GROUP BY 
  p.produkt

Erläuterung
Die Verknüpfung der einzelnen Datensätze aus den zwei Tabellen läuft über die WHERE Klausel b.pr_id = p.id. Hier taucht zwar kein JOIN auf, es ist aber einer. Ach ja, das
GROUP BY wird wegen der SUM-Funktion benötigt, weil das so vorgeschrieben ist.

3. Möglichkeit 2

SQL CODE

SELECT  
  SUM(b.anzahl),  
  p.produkt 
FROM  
  bestellung b 
INNER JOIN  
  produkt p ON (b.pr_id = p.id) 
GROUP BY 
  p.produkt

Erläuterung
Hier arbeiten wir nun mit einem "echten" Inner Join. Dabei legt man bestellung als
"Suchtabelle" fest und mittels INNER JOIN produkt p ON (b.pr_id = p.id) verknüpft
man sie mit der Tabelle produkt. In diesem Fall (wie auch in obigem) ginge es natürlich
auch anders herum:

SQL CODE

SELECT  
  SUM(b.anzahl),  
  p.produkt 
FROM  
  produkt p 
INNER JOIN  
  bestellung b  ON (b.pr_id = p.id) 
GROUP BY 
  p.produkt

4. Das Ergebnis

Ist in allen Fällen identisch und so, wie wir es gewollt haben. Bei einem INNER JOIN ist es
somit auch unerheblich, welche Tabelle man wie mit einer anderen verbindet. Die Beziehung
muss nur EINDEUTIG sein.

+--------------+--------------+

| SUM(b.anzahl)| produkt      | 

+--------------+--------------+

|             9| Brecheisen   | 

|             4| Hammer       | 

|             3| Kneifzange   | 

|             1| Schlagbohrer | 

|            14| Zement       | 

+--------------+--------------+

Left/Right Join

1. Der feine Unterschied

Während ein INNER JOIN immer ein genaues Kreuzprodukt ergibt, so verhält es sich in
diesem Fall ein wenig anders. Dazu schauen wir uns mal die folgenden Tabellen an:

Tabelle 'hersteller'    Tabelle 'produkt' 

+----+--------------+   +---+--------------+--------+

| id | zulieferer   |   |id | produkt      |hs_link | 

+----+--------------+   +---+--------------+--------+

|  1 | Hilti bla    |   | 1 | Schlagbohrer |      1 | 

|  2 | Hoch & Tief  |   | 2 | Zement       |      2 | 

|  3 | Eisen-Karl   |   | 3 | Kneifzange   |      3 | 

|  4 | Stahl AG     |   | 4 | Brecheisen   |      3 |  

|  5 | Gähn & Söhne |   | 5 | Hammer       |      4 | 

+----+--------------+   +---+--------------+--------+

Die Verknüpfung erfolgt über die Spalte hs_link in der Tabelle produkt wo wir die IDs aus
der der Tabelle hersteller abspeichern. Wie das geübte Auge sofort erkennt, gibt es
einen Hersteller, für den offenbar kein Produkt existiert. Wenn wir jetzt alle(!) Hersteller
inklusive ihrer Machwerke auflisten wollen, so gibt es zwei Möglichkeiten.

2. LEFT JOIN

SQL CODE

SELECT 
  h.zulieferer, 
  p.produkt 
FROM 
  hersteller h 
LEFT JOIN 
  produkt p ON (h.id = p.hs_link);

Erläuterung
Bei einem LEFT JOIN werden alle Datensätze der "Haupttabelle" hersteller mit denen
der Tabelle produkt "links herum" (LEFT JOIN) verknüpft. Das bedeutet, dass alle
Datensätze der "linken" Tabelle auf jeden Fall angezeigt werden. Gibt es in der "rechten"
Tabelle keine entsprechende Relation, so wird der fehlende Teil der Spalte produkt einfach
mit einer NULL + aufgefüllt. Und das Ergebnis sieht so aus:

+--------------+--------------+

| zulieferer   | produkt      | 

+--------------+--------------+

| Hilti        | Schlagbohrer | 

| Hoch & Tief  | Zement       | 

| Eisen-Karl   | Kneifzange   | 

| Eisen-Karl   | Brecheisen   | 

| Stahl AG     | Hammer       | 

| Gähn & Söhne | NULL         | 

+--------------+--------------+

3. RIGHT JOIN

SQL CODE

SELECT 
  h.zulieferer, 
  p.produkt   
FROM 
  produkt p 
RIGHT JOIN 
  hersteller h ON (h.id = p.hs_link);

Erläuterung
Hier läuft es eigentlich nur anders herum. Hier wird die "Haupttabelle" produkt "rechts
herum" mit der Tabelle hersteller verbunden. Hier werden also alle Datensätze der
rechten Tabelle angezeigt und fehlende der linken mit NULL ausgefüllt.

Full Outer Join

1. Erklärung

Bei einem Full Outer Join handelt es sich um eine Kombination aus einem Left und einem
Right Join. Das Ziel dabei ist, Datensätze zu verknüpfen. Wenn es aber keine Beziehung
gibt, so sollen die entsprechenden Felder BEIDER Tabellen mit einem NULL gefüllt werden.
Dazu schauen wir uns mal die folgende Tabelle an. Achtet mal auf mögliche Verbindungen,
dann fällt euch auf, dass wir zwei Hersteller ohne Produkt und ein Produkt ohne Hersteller
haben.

Tabelle 'hersteller'    Tabelle 'produkt' 

+----+--------------+   +----+--------------+-------+

| id | zulieferer   |   | id | produkt      |hs_link| 

+----+--------------+   +----+--------------+-------+

|  1 | Hilti        |   |  1 | Schlagbohrer |     1 | 

|  2 | Hoch & Tief  |   |  2 | Zement       |     2 | 

|  3 | Eisen-Karl   |   |  3 | Kneifzange   |     3 | 

|  4 | Stahl AG     |   |  4 | Brecheisen   |     3 |  

|  5 | Gähn & Söhne |   |  5 | Hammer       |     7 | 

+----+--------------+   +----+--------------+-------+

2. Die Abfrage

Leider unterstützt MySQL kein FULL OUTER JOIN, daher muss man hier ein wenig tricksen,
indem man per UNION das Ergebnis zweier Abfragen miteinander verknüpft.
Hier konzentrieren wir uns nur auf das Wesentliche.

SQL CODE

SELECT 
  h.zulieferer, 
  p.produkt 
FROM 
  hersteller h 
LEFT JOIN 
  produkt p ON (h.id = p.hs_link) 
UNION 
  SELECT 
    h.zulieferer, 
    p.produkt 
  FROM 
    hersteller h 
  RIGHT JOIN 
    produkt p ON (h.id = p.hs_link);

Erläuterung
Zunächst nutzen wir den Left-Query aus dem vorherigen Abschnitt (SELECT ... FROM
LEFT JOIN ...). Damit holen wir uns alle Hersteller und, falls vorhanden, deren...
Produkt. Wenn es Letzteres nicht gibt, so wird die Spalte produkt mit NULL aufgefüllt.
Anschließend verbinden wir die erste Abfrage per UNION mit der zweiten. Dort drehen wir
den Spieß einfach um und holen uns auch noch die Produkte, zu denen es keinen Hersteller
gibt.

3. Das Ergebnis

sieht dann so aus. Ich hoffe, ihr habt das Prinzip verstanden ...

+--------------+--------------+

| zulieferer   | produkt      | 

+--------------+--------------+

| Hilti        | Schlagbohrer | 

| Hoch & Tief  | Zement       | 

| Eisen-Karl   | Kneifzange   | 

| Eisen-Karl   | Brecheisen   | 

| Stahl AG     | NULL         | 

| Gähn & Söhne | NULL         | 

| NULL         | Hammer       | 

+--------------+--------------+

4. Fazit

Da das Thema Joins doch ziemlich komplex ist, hoffe ich das ich euch
mit den grundsätzlichen Dingen vertraut machen konnte. Und wenn man das Prinzip verstanden hat,
so kommt der Rest (fast) von allein.

Joins in MySQL Teil 1 Grundlegendes und die Sache mit dem Alias

Wed, 16 Feb 2011 18:25:10 +0100

So wie versprochen hier ein bisschen was zu den Joins

Grundlegendes

1. Mathematik

SQL basiert auf der relationalen Algebra. Und darum werde
ich euch nun mit ein paar Prinzipien vertraut machen. Aber keine Angst,
dass ich euch mit irgendwelchen Formeln quälen
werde. Nein, ich werde versuchen, dass so einfach wie möglich zu erklären.

Grundsätzliche Unterscheidung
EINFACH gesagt unterscheidet man drei verschiedene Typen von Joins. Dabei geht es um
die Art und Weise, wie die Spalten von mehreren Tabellen verknüpft werden.

2. Einfacher Join

Dabei wird ein so genanntes kartesisches Produkt gebildet. Das bedeutet, dass jede Zeile
der Tabelle blubb mit jeder Zeile von blubber verknüpft wird.

SQL CODE

SELECT * FROM blubb, blubber;

'blubb'    'blubber'    Ergebnis 

+--+----+  +--+----+    +--+----+  +--+----+

|id|text|  |id|text|    |id|text|  |id|text| 

+--+----+  +--+----+    +--+----+  +--+----+

| 1|a   |  | 1|x   |    | 1|a   |  | 1|x   | 

| 2|b   |  | 2|y   |    | 1|a   |  | 2|y   |  

+--+----+  +--+----+    | 2|b   |  | 1|x   | 

                         | 2|b   |  | 2|y   | 

                         +--+----+  +--+----+

Natürlich ist dieses Ergebnis nicht zu gebrauchen, da es keinerlei Beziehungen zwischen den
Datensätzen gibt.

3. Equi/Non-Equi Join

Hier wird auf GleichHeit bzw. Ungleichheit zwischen einzelnen Spalten geprüft.
Equi Join

blubb.id = blubber.id 

'blubb'    'blubber'    Ergebnis 

+--+----+  +--+----+    +--+----+  +--+----+

|id|text|  |id|text|    |id|text|  |id|text| 

+--+----+  +--+----+    +--+----+  +--+----+

| 1|a   |  | 1|x   |    | 1|a   |  | 1|x   | 

| 2|b   |  | 2|y   |    | 2|b   |  | 2|y   | 

+--+----+  +--+----+    +--+----+  +--+----+

Non-Equi Join

blubb.id != blubber.id 

'blubb'    'blubber'    Ergebnis 

+--+----+  +--+----+    +--+----+  +--+----+

|id|text|  |id|text|    |id|text|  |id|text| 

+--+----+  +--+----+    +--+----+  +--+----+

| 1|a   |  | 1|x   |    | 1|a   |  | 2|y   | 

| 2|b   |  | 2|y   |    | 2|b   |  | 1|x   | 

+--+----+  +--+----+    +--+----+  +--+----+

4. Natural Join

In diesem Fall wird nach Spalten mit gleichem Namen und identischem Inhalt gesucht. Bei
einer Übereinstimmung werden sie zu einer Spalte zusammen geführt.
blubb.id = blubber.id

'blubb'    'blubber'      Ergebnis 

+--+-----+  +--+-----+    +--+-----+-----+

|id|text1|  |id|text2|    |id|text1|text2| 

+--+-----+  +--+-----+    +--+-----+-----+

| 1|a    |  | 1|x    |    | 1|a    |y    | 

| 2|b    |  | 2|y    |    | 2|b    |x    | 

+--+-----+  +--+-----+    +--+-----+-----+

Alias

1. Namen vergeben

Wenn man mit Abfragen über mehrere Tabellen arbeitet, so muss man sich über ein
paar Dinge im Klaren sein. Denn sonst kommt man später in die Bredouille.

2. Das Problem

Tabelle 'bla'   Tabelle 'laber' 

+---+-----+    +--+-------+

|id |blubb|    |id|blubber| 

+---+-----+    +--+-------+

|  1|a    |    | 1|x      | 

|  2|b    |    | 2|y      | 

+---+-----+    +--+-------+

Wenn man nun nach den Spalten blubb und blubber sucht, so reicht ein einfaches
SELECT blubb, blubber FROM ... völlig aus, da die beiden Spalten unterschiedliche
Namen haben. Es gibt nur ein Problem. Wenn man die Datenbankstruktur nicht auswendig
im Kopf hat, so weiß man auf Anhieb nicht, welche Spalte sich in welcher Tabelle befindet.
Und was passiert, wenn man die gleichnamigen Spalten id auch noch haben möchte? Dann
gibt es unter Umständen später Probleme.
Warum? Ganz einfach. Der Name einer Spalte wird bei einem mysql_fetch_assoc als
Wert für das entsprechende assoziative Array benutzt. Und wenn MySQL zwei Spalten
gleichen Namens zurückliefert, so kommt nur Letzteres bei an.

3. Lösungen

Möglichkeit 1
Man kombiniert die Spalten- mit den Tabellenamen, also

SQL CODE

SELECT 
  bla.id,  
  bla.blubb, 
laber.id, 
laber.blubber 
FROM 
  bla, laber

Möglichkeit 2
Man legt für den Tabellennamen einen Alias an. Da Programmierer eigentlich ziemlich
tippfaul sind, nimmt man gewöhnlich und so weit wie möglich den Anfangsbuchstaben der
Tabelle.

SQL CODE

SELECT 
  b.id,  
  b.blubb, 
l.id, 
l.blubber 
FROM 
  bla b,  
laber l

4. Gleichnamige Spalten

Wie ich schon sagte, gibt es in der Situation Probleme. Daher sollte man auch
gleichnamigen Spalten einen Alias verpassen. Im Gegensatz zu den Tabellen benötigt man
hier ein AS.

SQL CODE

SELECT 
  b.id AS b_id 
  b.blubb, 
  l.id AS l_id, 
l.blubber 
FROM 
  bla b,  
laber l

5. Wichtig

Wenn man sowohl den Tabellen als auch den Spalten einen Alias verpasst, so hat das
KEINE Auswirkung auf die tatsächliche Struktur einer Datenbank. Es geht ausschließlich um
die Namen der Rückgabewerte, die zum Beispiel von PHP verarbeitet werden müssen.

Teil 2 folgt Morgen.

PHP Debug Funktion, endlich ordentlich debuggen

Thu, 23 Dec 2010 15:13:27 +0100

Huhu Leute, ich will euch mal was überlassen, ist vor ein paar Jahre mal entstanden für was ich das damals brauchte keine Ahnung aber seit dem nutze ich sie.
Es eine Debug Funktion, die ihr mit einer Anzahl von X Argumenten füttern könnt, ist das letzte Argument true mach die Funktion kein echo sondern gibt den Dump per return zurück.

Die Funktion kann natürlich auch in einem eingenen Error Handler genutzt werden um sich zb bei einem Error alle zur Zeit definierten Vars auszugeben, wer dazu mehr wissen will oder sehen möchte wie ein eigene Error Handler mit dieser Funktion aussehen können sagt bescheid dann schreibe ich schnell eine.

Des weiteren könnt ihr per Konstante entscheiden ob ihr var_dump oder print_r nutzen wollt
es wird geprüft ob die Funktion nicht schon existiert wenn nein wird sie angelegt

Die Funktion

PHP CODE

if ( !function_exists('p') ) {
 
    define( 'TT2_DEBUG_USE_PRINTR', false );
 
    function p()
    {
        $r = $a = '';
        $params  = func_num_args();
        $args    = func_get_args();
        $return  = ( $params > 1 && $args[$params-1] === true ? true : false );
 
        for ( $i = 0; $i < $params; $i++ ) {
            $r .= '<pre>';
            if ( TT2_DEBUG_USE_PRINTR === true ) {
                $r .= htmlspecialchars( print_r( $args[$i] ,true ), ENT_QUOTES );
            }
            else {
                ob_start();
                var_dump( $args[$i] );
                $a = ob_get_contents();
                ob_end_clean();
                $r .= htmlspecialchars( $a, ENT_QUOTES );
            }
            $r .= '</pre>';
        }
 
        if ( $return === true ) {
            return $r;
        }
        else {
            echo $r;
        }
    }
}

Benutzung

Test Variablen

ich nutze für die Veranschaulichung folgende Vars

PHP CODE

class tt2_debug_test_class
{
    protected $classProtectedVar = 123456;
    private   $classPrivateVar   = 'I am private';
    public    $classPublicVar    = array( 1 => 'abcd', 
                                          'aaabbb', 
                                          array ( 'ccc' => 123,
                                                  'ddd' => 'xyz'
                                                )
                                        );
 
}
 
$varA = microtime();
$varB = 'abcd';
$varC = new tt2_debug_test_class();
$varD = 2010;
$varE = array( 0, 1 => 'a', 2 => array( 'a', 'b', 'c' ), 'z' );
 

der Aufruf

Ohne return

PHP CODE

p( $varA, $varB, $varC, $varD, $varE );

Mit return

PHP CODE

$dump = p( $varA, $varB, $varC, $varD, $varE, true );
echo $dump;

var_dump Ausgabe

Ausgabe wenn die Konstante TT2_DEBUG_USE_PRINTR === false ist also var_dump genutz wird

PHP CODE

string(21) "0.14732200 1293110747"
string(4) "abcd"
object(tt2_debug_test_class)#1 (3) {
  ["classProtectedVar":protected]=>
  int(123456)
  ["classPrivateVar":"tt2_debug_test_class":private]=>
  string(12) "I am private"
  ["classPublicVar"]=>
  array(3) {
    [1]=>
    string(4) "abcd"
    [2]=>
    string(6) "aaabbb"
    [3]=>
    array(2) {
      ["ccc"]=>
      int(123)
      ["ddd"]=>
      string(3) "xyz"
    }
  }
}
int(2010)
array(4) {
  [0]=>
  int(0)
  [1]=>
  string(1) "a"
  [2]=>
  array(3) {
    [0]=>
    string(1) "a"
    [1]=>
    string(1) "b"
    [2]=>
    string(1) "c"
  }
  [3]=>
  string(1) "z"
}

print_r Ausgabe

Ausgabe wenn die Konstante TT2_DEBUG_USE_PRINTR === true ist also print_r genutz wird

PHP CODE

0.57874200 1293110947
abcd
tt2_debug_test_class Object
(
    [classProtectedVar:protected] => 123456
    [classPrivateVar:tt2_debug_test_class:private] => I am private
    [classPublicVar] => Array
        (
            [1] => abcd
            [2] => aaabbb
            [3] => Array
                (
                    [ccc] => 123
                    [ddd] => xyz
                )
 
        )
 
)
2010
Array
(
    [0] => 0
    [1] => a
    [2] => Array
        (
            [0] => a
            [1] => b
            [2] => c
        )
 
    [3] => z
)

mfg tantetoni2

Stargate Universe wird abgesetzt

Fri, 17 Dec 2010 19:35:23 +0100

So mal was ganz anderes, aber Fan bleibt Fan :D

Wie der SciFi Channel jetzt berichtet, wird die bereits seit langen krieselnde Serie "Stargate Universe" nicht für eine dritte Season verlängert.

Stargate Universe, die inzwischen dritte Stargate Serie hatte bereits seit beginn mit massiver Kritik zu kämpfen, da sie sich drastisch von den beiden bisherigen Serien Stargate SG-1 und Stargate Atlantis unterschied. Viele kritisierten die Serie mit dem Vorwurf, das sie nichts anderes als eine Anleihe von Battlestar Galactica und Star Trek Voyager sei.

Die Quoten der Serie duchlebten eine ständige Berg und Talfahrt, die auch eine rasantere zweite Season nicht aufhalten konnte.
In der zweiten Season kamen vermehrt Alien Spezies vor, das Stargate wurde öfter benutzt, und Dr. Rush fand endlich die Brücke der Destiny, womit man das Schiff steuern konnte. Zudem entdeckte Rush einen Masterplan der Antiker, nachdem die Destiny nicht grundlos auf die Reise geschickt wurde.

SG:U wird damit wohl ein offendes Ende haben, da die Produzenten kürzlich verlauten ließen, das sie den Serien-Plot auf eine fünf-Jahres Mission ausgelegt hatten. Da bereits die erste Hälfte der zweiten Season im Fernsehen gelaufen ist, und die verbliebenden 10 Episoden zumindest größtenteils abgedreht sind, bleibt keine Möglichkeit ein vernümpftiges Ende zu schreiben.

Damit cancelt der amerikanische SyFy-Sender nun das zweite große Science Fiction Franchise nach dem Battlestar Galactica Ableger "Caprica" der sogar nur eine Staffel lang laufen durfte.

Quelle: treknews.de

Javascript Prüfung mit PHP so einfach gehts

Wed, 03 Nov 2010 20:04:02 +0100

Vorwort

Bekanntlich führen ja viele Wege zum Ziel, auch für die Prüfung in PHP ob Javascript aktiviert ist gibt es viele Wege, aber der folgende ist meiner Meinung nach der schnellste und simpelste.

Der Code

PHP CODE

<?php
if (isset($_POST['jstest'])) {
  $nojs = FALSE;
} 
else {
  // create a hidden form and submit it with javascript
  echo '<form name="jsform" id="jsform" method="post"
 style="display:none">';
  echo '<input name="jstest" type="text" value="true" />';
  echo '<script language="javascript">';
  echo 'document.jsform.submit();';
  echo '</script>';
  echo '</form>';
  // the variable below would be set only if the form wasn't submitted, hence JS is disabled
  $nojs = TRUE;
}
if ($nojs === TRUE) {
  //JS is OFF, do the PHP stuff
}
?>

Erklärung

Wie ihr am Code sehen könnt wird ein verstecktes Formular erstellt welches abgesendet wird wenn Javascript im Browser aktiviert ist.
Anhand von

PHP CODE

if (isset($_POST['jstest'])) {
  $nojs = FALSE;
}

wird geprüft ob das Formular abgesendet wurde ist dies der Fall wird die variable $nojs auf false gesetzt und somit ist Javascript im Browser aktiviert.

Sollte Javascript deaktiviert sein wird das Formular natürlich nicht automatisch abgesendet und somit ist die Variable $nojs true
An folgender Stelle kann bestimmter Code ausgeführt wenn Javascript deaktiviert ist

PHP CODE

if ($nojs === TRUE) {
// Code
}

Man könnte natürlich noch einen else Zweig nutzen und zB. das Ergebniss in einer Session speichern, damit die Prüfung nicht jedes mal durch geführt wird.
Diese Variante nutz zwar einen Request mehr dennoch finde ich sie als sehr effizient und simpel.

Kommentare dazu stehen natürlich offen.

mfg Toni

Objektorientierte Programmierung

Fri, 29 Oct 2010 22:15:01 +0200

Da unsere Klasse hauptsächlich mit JAVA programmieren wird und JAVA eine objektorientierte Programmiersprache ist, möchte ich den Begriff "Objektorientierte Programmierung" (kurz OOP) etwas unter die Lupe nehmen und versuchen diesen verständlich zu erläutern.

Vorwort

Vorweg ist zu sagen, dass objektorientierte Programmierung zum Standard geworden ist. In der Ausbildung zum Anwendungsentwickler wird i.d.R. von Anfang an nur dieser Ansatz der Programmierung unterrichtet. Die Entwicklung komplexer Softwaresysteme ohne objektorientierte Programmierung ist heutzutage eher eine Ausnahme.

Grundlegendes

Der Grundgedanke der OOP ist, Daten und Funktionen, die auf diese Daten zugreifen oder sie manipulieren, eng beieinander in sogenannten Objekten zu halten. Diese Objekte haben den Vorteil, dass die Daten innerhalb dieser nicht versehentlich von anderen Objekten bzw. Methoden manipuliert werden können.

Beispiel

Software an sich abstrahiert Arbeitsschritte die der Mensch in der realen Welt ausführt. Wenn wir uns jetzt z.B. ein Warenlager anschauen, dann erkennen wir, dass die einzelnen Schritte wie Wareneingang, Warenerfassung, Warenlagerung und Warenausgang in einem direkten Zusammenhang zueinander stehen. Jetzt stellen wir uns mal vor, dass das Lager direkt im Büro der Firma ist und alle zusammen in einem Raum arbeiten... wäre das nicht ein schönes Chaos?

Das Beispiel in OOP

Mit der OOP werden wir nun versuchen dieses Chaos zu optimieren. Der erste Schritt den wir machen, ist das Büro und das Lager zu trennen. Wir erstellen also zwei Klassen (wie es in der OOP genannt wird), die Klasse "Büro" und die Klasse "Lager". Die Büroklasse beschäftigt sich nun in einem separaten Raum ausschließlich mir der Büroarbeit, die Lagerklasse mit der Lagerarbeit.

Im Objekt Lagerklasse legen wir Methoden für den Wareneingang, die Warenerfassung, die Warenlagerung und den Warenausgang an. Diese stehen dann nur im Lagerklassenobjekt zur Verfügung und werden von der Büroarbeit nicht mehr behindert bzw. behindern diese auch nicht mehr.

Abschließendes

Ich hoffe ich konnte euch die Idee die hinter der OOP steht etwas näher bringen und wünsche euch eine geruhsame Nacht.

Dieser Beitrag ist auch in meinem Blog zu lesen:
raischblog.de/Objektorientierte-Programmierung/

Java - Standard Operatoren und Operanden Teil 1

Mon, 25 Oct 2010 17:50:46 +0200

Operatoren & Operanden

Dabei handelt es sich um Anweisungen, die auf der Basis von Werten mathematische Operationen durchführen.

Kategorisierung

Bevor wir uns nun den verschiedenen Operatoren widmen, wollen wir kurz einige wichtige Merkmale aller Operatoren beschreiben, durch die sie sich spezifizieren lassen. Dabei gibt es vier Kategorien zu nennen, die die Operatoren in ihrer Funktionalität beschreiben.

Die hier vermittelten Grundlagen werden später als entsprechende Spalten in den Operatortabellen wieder auftauchen, um alle Informationen übersichtlich und zusammenhängend darstellen zu können. Daher sollten Sie sich diese Punkte gut einprägen oder gegebenenfalls noch einmal nachschlagen.

Operanden

Jeder Operator hat eine bestimmte Anzahl von Operanden, die fest an der Operation beteiligt sind. Java kennt hier drei verschiedene Typen mit entweder einem, zwei oder drei Operanden. In den folgenden Beschreibungen der verschiedenen Operatoren werden wir daher jeweils angeben, um welchen Typ es sich handelt.

1 Operand = unärer Operator
2 Operanden = binärer Operator
3 Operanden = ternärer Operator

Typisierung

Alle Operanden werden eindeutig durch ihren Typ bestimmt. Dadurch wird festgelegt, mit welchen Typen ein Operator arbeiten kann. Folglich werder wir eine Tabelle mit allen acht möglichen Typen aufstellen. Die hier aufgestellten Bezeichnungen werden dann wieder in den Tabellen der entsprechenden Operatorbeschreibungen auftauchen.

N = numerischer Typ
I = integraler Typ
L = logischer Typ
P = primitiver Typ
A = alle Typen
S = String
R = Referenz
V = Variable

Priorität

Die Operatorpriorität stellt eine der wichtigsten Spezifizierungen dar. Sie legt fest, welche Operatoren in einer Anweisung Vorrang haben. Dadurch wird zum Beispiel sichergestellt, dass Anweisungen in einer logischen und korrekten Reihenfolge ausgeführt werden, sowie mathematische Grundregeln eingehalten werden.

In den entsprechenden Tabellen werden daher alle Operatoren durch ihre Priorität geordnet werden. Die Operatoren mit einer kleineren Zahl entsprechen dabei den am höchsten priorisierten Operatoren.

Assoziativität

Die Assoziativität beschreibt die Richtung der Ausführung von Operatoren, die die gleiche Prioritätsstufe besitzen. Diese kann entweder von links nach rechts oder umgekehrt verlaufen. So werden die mathematischen Rechenregeln sicher durchgeführt.

In komplexen Ausdrücken werden daher zunächst aller höher priorisierten Ausdrücke ausgeführt und erst danach werden auf Grund der Assoziativität alle Zwischenwerte zusammengefasst.

arithmetische Operatoren

Java kennt fünf arithmetische Operatoren für mathematische Berechnungen. Hinzu kommen zwei Operatoren für die Vorzeichenkennzeichnung.

Die arithmetischen Operatoren verwenden numerische Typen und liefern numerische Werte. Bei unterschiedlichen Datentypen entspricht der Ergebnistyp dem größeren der beiden Operanden. Die Umwandlung der Werte entspricht den Konvertierungsregeln.

+ = Verleiht einer Variable ein positives Vorzeichen.
- = Verleiht einer Variable ein negatives Vorzeichen.
+ = Führt eine Addition durch.
- = Führt eine Subtraktion durch.
* = Führt eine Multiplikation durch.
/ = Führt eine Division durch.
% = Führt eine Division durch, wobei nur der Restwert geliefert wird (Modulo).

Quelle: http://www.programmersbase.net

Teil 2 folgt demnächst.

Die Zeit ist reif Java kommt

Fri, 22 Oct 2010 22:38:46 +0200

Hallo Leute, da es ja ab nächste Woche dienstag mit der Java Programmierung los geht, habe ich mir gedacht ich stelle euch mal Java vor und zeige euch anschließend ein paar paar kleine Java codeschnipsel zu zeigen auch wenn die meisten damit noch nicht viel anfangen können.

Java ist eine objektorientierte Programmiersprache und eingetragenes Warenzeichen der Firma Sun Microsystems, welche Ende Januar 2010 von Oracle übernommen wurde. Die Programmiersprache ist ein Bestandteil der Java-Technologie.

Java-Programme werden in Bytecode übersetzt und dann in einer speziellen Umgebung ausgeführt, die als Java-Laufzeitumgebung oder Java-Plattform bezeichnet wird. Deren wichtigster Bestandteil ist die Java Virtual Machine (Java-VM), die die Programme ausführt, indem sie den Bytecode interpretiert und bei Bedarf kompiliert (Just-in-time-Kompilierung, häufig mit Hotspot-Optimierung).

Java-Programme sind plattformunabhängig, das heißt sie laufen in aller Regel ohne weitere Anpassungen auf verschiedenen Computern und Betriebssystemen, wenn für diese eine Java-VM existiert. Sun selbst bietet Java-VMs für die Betriebssysteme Linux, Solaris und Windows an. Andere Hersteller lassen ihre Java-VM für ihre Plattform zertifizieren, zum Beispiel die Firma Apple für Mac OS X.

Von Portierung spricht man bei Java in der Regel, wenn Quelltext oder Bytecode auf den Stand einer anderen Java-Version angepasst werden soll. Meistens sind Java-Programme nur für bestimmte Java-Versionen getestet oder zertifiziert.

Der Entwurf der Programmiersprache Java strebte im Wesentlichen fünf Ziele an:

Sie soll eine einfache objektorientierte, verteilte und vertraute Programmiersprache sein.
Sie soll robust und sicher sein.
Sie soll architekturneutral und portabel sein.
Sie soll sehr leistungsfähig sein.
Sie soll interpretierbar, parallelisierbar und dynamisch sein.

So hier hier mal ein paar Grundlegende Informationen zu Variablen die natürlich auch bei anderen Programmiersprachen gültig sind

Variablen und Operatoren

Variablen bezeichnen Werte, die sich während des Programmablaufs ändern. Operatoren sind Zeichen oder kleine Wörter, welche die Beziehung zwischen Variablen und Werten beschreiben.

Variablen

Eine Variable bezeichnet einen Wert, der sich während der Ausführung des Programms ändert. Beispiel: Unser Roboter soll jeweils 3 Autos nehmen. Am Anfang sind es 3, wenn er das erste genommen hat, nur noch 2, dann nur noch 1, dann 0. Wenn er sie verpackt hat und wiederkommt, sind es wieder 3, usw. Wieviel Autos er noch nehmen soll, merken wir uns in einer Variablen: Am Anfang sind es 3. Wir schreiben dazu die Anweisung

JAVA CODE

AutosGenommen = 3;

Später im Programm wird der Wert geändert:

JAVA CODE

AutosGenommen = 2;

usw.
Den Namen der Variablen können wir selbst festlegen. Erlaubt ist fast alles, ausser: Er darf kein Java-Wort sein, darf nur aus alphanumerischen Zeichen und dem Zeichen _ (Unterstrich) bestehen und nicht mit einer Ziffer beginnen. Bevor Java das Wort AutosGenommen als Variable akzeptiert, muss die Variable allerdings deklariert werden, das bedeutet sie muss dem Übersetzer "vorgestellt" werden, so wie man einen Menschen in seinem Bekanntenkreis vorstellt, damit er nicht als Fremder abgewiesen wird:

JAVA CODE

variablenTyp variablenName;
//In unserem Beispiel:
Byte AutosGenommen;
AutosGenommen = 3;

"Byte" ist der Variablentyp, in unserem Fall eine Zahl zwischen -128 und 127. Der Typ wird bei der Deklaration dem Namen vorangestellt.
Unser Programm besteht nun schon aus 2 Zeilen. Die erste Zeile ist die Deklaration einer Variablen, die zweite eine Wertzuweisung. Beides sind im weitesten Sinne Anweisungen. Das Gleichheitszeichen ist eine Wertzuweisung:

JAVA CODE

variablenName = variablenWert;

Der Variablen AutosGenommen wird hier also der Wert 3 zugewiesen.

Variablentypen

Boolean
Eine Variable vom Typ boolean kann nur den Wert true oder false annehmen. Die Anweisung dafür lautet zum Beispiel:

JAVA CODE

boolean wahrOderFalsch;
//oder:
boolean falschOderWahr = true;

Ganzzahl-Typen
Sie stehen für Zahlen ohne Kommastellen. Je nachdem, wie groß der Wertebereich sein muss, wählt man den passenden Typ:

Typ Speicherplatz Wertebereich
byte 8 Bit -128 und 127
short 16 Bit -32768...32767
int 32 Bit -2147483648...2147483647
long 64 Bit -9223372036854775808...9223372036854775807

boolean und die Ganzzahl-Typen nennt man auch "primitive" Typen.

Gleitkomma-Typen
Sie beinhalten Zahlen mit Stellen nach dem Komma. Wenn es viele Stellen nach dem Komma gibt, ist der Platz für die Anzahl der Stellen vor dem Komma kleiner - das Komma kann also "gleiteten" - daher das Wort "Gleitkomma":

Typ Speicherplatz Wertebereich
float 32 Bit Einfache Genauigkeit
double 64 Bit doppelte Genauigkeit

string
Ein String ist eine Gruppe von Zeichen hintereinander, also zum Beispiel ein Wort oder ein kleiner Text.

array
Ein array ist eine Gruppe von Werten, eine Liste. Ein eindimensionales Array kann man sich wie eine Spalte einer Tabelle vorstellen. Äußerlich erkennt man eine Arrayvariable an den eckigen Klammern:

JAVA CODE

Arrayvariable[]

So geschrieben ist das Array leer. Die einzelnen Elemente des Arrays kann man über ihre laufende Nummer ansprechen:

JAVA CODE

Array[0] = 20;
Array[1] = 10;

Zu beachten ist, dass das erste Element die laufende Nummer 0 hat, das 2. die laufende Nummer 1 usw. Der Datentyp der Elemente eines Arrays kann jeder beliebige Variablentyp sein. Wenn einmal ein Wert eines bestimmten Datentyps benutzt worden ist, muss man aber dabei bleiben; innerhalb einer Dimension dürfen nicht verschiedene Datentypen benutzt werden.
quelle:

Codeschnipsel

Zahlen

Erzeugen einer Zufallszahl

JAVA CODE

// Erzeugt eine Zufallszahl zwischen 0 und 9
new java.util.Random().nextInt(10);
 
// Wenn man das Paket java.util importiert hat, reicht natürlich auch:
new Random().nextInt(10);

Umwandeln einer Zeichenkette in eine Zahl

JAVA CODE

Integer.parseInt("42");     // Liefert die Zahl 42 zurück.

Ausgabe

Ausgabe von Text auf der Standardausgabe

JAVA CODE

System.out.println("Hallo Welt");

Grafische Ausgabe von Text

JAVA CODE

// Klasse JOptionPane aus Paket javax.swing
JOptionPane.showMessageDialog(null, "Hallo Welt");

Nützliches rund um GUI's

Icon der Taskleiste setzen

Um das Symbol, das in der Taskleiste erscheinen soll, zu setzen, kannst Du die Methode setIconImage der Klasse JFrame benutzen:

JAVA CODE

setIconImage(new ImageIcon(getClass().getResource("nameDerDatei")).getImage());

Programm beenden

Zum Beenden einer Anwendung gibt es die statische Methode static void exit(int status) in der Klasse System im Paket java.lang. Im Normalfall wird die Methode mit System.exit(0) aufgerufen.

Umwandlung von Zahlen und Strings

Bei der Programmierung von GUIs muss man oft Zeichenketten und Zahlen konvertieren, da Komponenten wie ein JLabel oder JTextField Strings anzeigen, aber eigentlich eine Zahl erscheinen soll, mit der z.B. auch gerechnet werden soll.

Um den ganzzahligen Wert einer Zeichenkette zu erhalten, gibt es in der Klasse Integer eine statische Methode parseInt(String s), die ein Objekt vom Typ String erwartet und dessen ganzzahligen Wert zurück gibt. Um eine ganze Zahl als Zeichenkette zu erhalten, kann man z.B. die statische Methode valueOf(int i) der Klasse String benutzen, oder die Zahl mit einer Zeichenkette verknüpfen.

JAVA CODE

Integer.parseInt("42");     // Liefert die Zahl 42 zurück.
String.valueOf(42);        // Liefert die Zeichenkette "42" zurück.
42 + " ist die Antwort";   // ergibt die Zeichenkette "42 ist die Antwort". 

Die Konvertierung zwischen anderen primitiven Datentypen - wie z.B. boolean oder double - und String erfolgt analog.

So ich denke das reicht erst einmal nicht das ihr noch Angst bekommt, ein schönes Wochenende euch allen.

mfg Toni

Der erste Beitrag

Mon, 18 Oct 2010 16:30:32 +0200

Zu aller erst, diese Seite befindet sich noch im Aufbau, hier entsteht ein kleines Lernportal mit Blog Funktion.

Was ist schon vorhanden:

1. Der Blog
Artikel können geschrieben werden, Kommentiert werden (dies auch von Gästen).
Über regelmäßige Einträge von euch würde ich mich freuen.
Was fehlt:
- Bewertungsfunktion
- Bearbeitungsfunktion
- Suchfunktion
- und bestimmt noch irgendwas
2. Der Multiple Choice Test
Ein kleiner Test wo ihr eure Bisherigen Leistungen prüfen könnt. Test und Auswertung funktionieren schon.
Was fehlt:
- Historiefunktion (Übersicht der bisherigen Ergebnisse)
- Integration in den Themenkatalog der Fächer des kommenden Lernportals, dann - auch Themenauswahl
- Helferlein die helfen Fragen und so einzutragen.

3. Informatikfunk
Hier könne ihr ein kleines Statement geben was ihr gerade macht, es werden die letzten 8 Einträge angezeigt und die Einträge sind auf 160 Zeichen begrenzt.

Was wird kommen:

1. Ein Eventplaner wird mit dem Kalender im Menü verknüpft, zZ. werden hier nur vorhandene Blogeinträge hervorgehoben, später wird bei einem klick auf einen Tag wo Ereignisse oder Einträge vorhanden sind eine extra Seite kommen mir einer Übersicht was los und was passiert ist.
2. Ein kleines Nachrichtensystem (Wird von einem anderen Projekt von mir an dieser Seite angepasst, also schon fertig bis auf die Änderungen, wird wohl als nächstes kommen.
3. Ein Diskussionsforum
4. und das wichtigste das Lernportal, hier kommen Arbeitsblätter, Tests, Mitschriften aus dem Unterricht rein und eventuell Downloads zu dem Themen
5. Eine Downloaddatenbank für später ( für Tools, Quellcodes usw.)
6. Eine Profilseite
7. und für zwischendurch ein MauMau Spiel welches ich mal geschrieben habe
8. und für Gäste ein Gästebuch
9. und ein Newsletter wer über aktuellen und Events informiert werden will

Diese Seite sollte in den nächsten zwei Jahre die erste sein die ihr besucht wenn ihr Zuhause euren Browser anschmeißt, ich weiß noch ist nicht viel möglich aber das kommt alles noch da die Seite ja von Grund auf neu gemacht wurde bist auf ein paar Backend Sachen wir die Klassen für das Usermanagement und der Datenbank und noch ein bisschen .

Ich bitte euch mir sämtliche Fehler und Kuriositäten zumelden.

So das wars erstmal wünsche euch schon mal viel Spaß hier

euer Toni