Variablen unter PHP

Eine Variable stellt unter PHP einen Speicherplatz dar, in dem Informationen abgelegt werden können. Damit das Ansprechen von Variablen nicht über den Zugriff auf bestimmte Adressen in einem festgelegten Speicherbereich erfolgen muss – was der Übersichtlichkeit nicht gerade zuträglich ist – hat der PHP Programmierer die Möglichkeit diesen im Speicher abgelegten Bereichen Namen zu geben. Über diesen Namen erhält der Entwickler Zugriff auf die dort abgelegte Speicherstruktur. Eine Variable – bzw. einen Zugriff auf eine solche – erkennt man an einem vorangestellten Dollar-Zeichen ($).

Der PHP-Entwickler kann also beliebige Informationen in Variablen ablegen, auf die er im Verlauf der Abarbeitung eines PHP-Scripts sowohl lesend als auch schreibend zugreifen kann. Hier werden dann etwa Zwischenergebnisse von Berechnungen oder String-Operationen gespeichert. Neben selbstdefinierten Variablen gibt es unter PHP einige vordefinierte Variablen, auf die später noch eingegangen wird.

PHP Var Beispiel: Definition von Variablen und Vergabe von Variablennamen

Im Prinzip kann der Name einer Variablen vom Programmierer frei gewählt werden. Der Name kann dabei – zumindest theoretisch – beliebig lang sein. Bei der Wahl eines Variablennamen ist allergings zu beachten, dass dieser grundsätzlich mit einem Unterstreicher-Zeichen (_) oder einem Buchstaben beginnen muss. Darauf können dann beliebig viele Buchstaben, Ziffern und bestimmte Sonderzeichen – nicht nutzbar sind beispielsweise das Dollar-Zeichen, Semikolon oder Operator-Zeichen – folgen. Dabei unterscheidet PHP zwischen Klein- und Großschreibung ($k ist nicht die selbe Variable, wie $K).

<?php
    // Definition von Variablen
    // Gültige Definitionen:
    $k;
    $_k;
    $k1;
    // Ein ausgesprochen aussagekräftiger Name für eine Variable
    $Am_besten_man_nimmt_einen_Namen_der_etwas_aussagt;
    // Sogar Umlaute sind erlaubt
    $übertrag;
    // Auch folgendes ist möglich (der Variablenname lautet $a)
    $$a;

    // Nicht gültig sind dagegen folgende Variablennamen:
    // 1. Zeichen darf keine Ziffer sein
    //$1ale;
    // Operator % ist wie alle anderen Operatoren nicht als Bestandteil eines
    // Variablennamen erlaubt
    //$%wert;
?>

PHP Variables: Initialisierung einer Variable und Typbestimmung

Zur Vermeindung unschöner Fehlermeldungen wie auch – was noch viel wichtiger ist – zur Vermeidung von Sicherheitsrisiken, ist das Initialisieren von Variablen unter PHP sinnvoll. Aber auch beim Zugriff auf Variablen kann man nie sicher sein welchen Datentyp der Inhalt der Variablen hat. Einer Variablen kann unter PHP immer irgendein Wert zugewiesen werden. Dies bedeutet, dass beispielsweise eine Variable, in der eine Zahl gespeichert ist (Typ Integer) nach der Zuweisung eines Strings auch ihren Typ entsprechend verändert. Da unter PHP bei der Definition einer Variablen keine entgültige Festlegung auf einen bestimmten Typ erfolgt, ist es manchmal nötig den Typ einer Variablen abzufragen. Zu diesem Zweck stehen in PHP einige spezielle Funktionen zur Verfügung, mit denen man herausfinden kann, welchen Typ der Inhalt einer Variable gerade hat.

<?php
    // Abfragen vor der Definition
    echo 'Betrag: ';
    var_dump ($betrag);
    echo '<br>';
    echo 'Isset sagt: ';
    var_dump (isset ($betrag));
    echo '<br>';

    // Definition und darauf folgende Abfragen der Variable
    $betrag;
    echo 'Betrag: ';
    var_dump ($betrag);
    echo '<br>';
    echo 'Isset sagt: ';
    var_dump (isset ($betrag));
    echo '<br>';
    echo 'Empty sagt: ';
    var_dump (empty ($betrag));
    echo '<br>';

    // Initialisierung und Ausgabe der Variablen
    // Achtung: Groß- und Kleinschreibung wird bei Variablennamen beachtet
    $Betrag = 120;
    $betrag = 60;
    echo 'Klein ' . $betrag . ' und gross ' . $Betrag . '<br>';

    // Und nochmal den Inhalt genauer unter die Lupe nehmen
    echo 'Betrag: ';
    var_dump ($Betrag);
    echo '<br>';
    echo 'Isset sagt: ';
    var_dump (isset ($Betrag));
    echo '<br>';
    echo 'Empty sagt: ';
    var_dump (empty ($betrag));
    echo '<br>';
?>

Betrag: NULL
Isset sagt: bool(false)
Betrag: NULL
Isset sagt: bool(false)
Empty sagt: bool(true)
Klein 60 und gross 120
Betrag: int(120)
Isset sagt: bool(true)
Empty sagt: bool(false)

<?php
    // Array mit Beispielwerten füllen
    $variables = array ('Zeichenkette', 17, 27.25, 1e-120, NULL, FALSE);

    // Einige Funktionen, die auf Datentypen bzw. auf den Wert NULL prüfen
    echo (is_string ($variables[0]) ? 'ist' : 'kein') . ' String<br>';
    echo (is_int ($variables[1]) ? 'ist' : 'kein') . ' Integer<br>';
    echo (is_float ($variables[2]) ? 'ist' : 'kein') . ' Float<br>';
    echo (is_double ($variables[3]) ? 'ist' : 'kein') . ' Double<br>';
    echo (is_numeric ($variables[2]) ? 'ist' : 'kein') . ' numerischer Wert<br>';
    echo (is_null ($variables[4]) ? 'ist' : 'nicht') . ' Null<br>';
    echo (is_bool ($variables[5]) ? 'ist' : 'kein') . ' Boolean<br>';
    echo (is_array ($variables) ? 'ist' : 'kein') . ' Array<br>';

    // Typen per gettype-Funktion ermitteln und ausgeben
    echo 'Typ von variables: ' . gettype ($variables) . '<br>';
    $i = 0;
    foreach ($variables as $val)
        echo 'Typ von Element ' . $i++ . ': ' . gettype ($val) . '<br>';
?>

ist String
ist Integer
ist Float
ist Double
ist numerischer Wert
ist Null
ist Boolean
ist Array
Typ von variables: array
Typ von Element 0: string
Typ von Element 1: integer
Typ von Element 2: double
Typ von Element 3: double
Typ von Element 4: NULL
Typ von Element 5: boolean

Variablen & References: Referenzieren von Variablen

Neben der normalen Zuweisung von Werten können Werte von Variablen durch Referenzierung zugänglich gemacht werden. In solch einem Fall wird keine Kopie des Inhalts einer Variablen erstellt und einer weiteren Variablen zugewiesen. Vielmehr wird die Variable unter einem anderen Namen (alias) Referenziert – der Zugriff erfolgt also über einen weiteren Variablennamen auf ein und denselben Speicherinhalt. Eine Referenz auf eine Variable ist also gewissermaßen ein Verweis auf einen Speicherbereich. Änderungen am Inhalt und lesende Zugriffe können gleichermaßen über die Referenz als auch über die ursprüngliche Variable realisiert werden.

<?php
    // Variable initialisieren
    $value = 42;
    // Neue Variable wird zur Referenz auf die bereits initialisierte
    // Variable. Jede Änderung über einen der beiden Variablennamen wirkt
    // sich ab jetzt auf ein und denselben Speicherplatz aus. Der
    // Speicherinhalt ist nun über zwei verschiedene Namen erreichbar.
    $sinn = &$value;
    // Ausgabe der unter den Namen gespeicherten Daten
    echo 'Sinn: ' . $sinn . ' und Unsinn: ' . $value . '<br>';
    // Änderung des Variableninhalts
    $sinn++;
    // Auswirkungen der Operation ausgeben
    echo 'Sinn: ' . $sinn . ' und Unsinn: ' . $value;
?>

Sinn: 42 und Unsinn: 42
Sinn: 43 und Unsinn: 43

Var in PHP: Sichtbarkeit einer Variable

Variablen sind in PHP immer nur in einem begrenzten Kontext sichtbar. Werden etwa innerhalb einer Funktion bestimmte Variablen definiert, so sind diese auch nur innerhalb der entsprechenden Funktion definiert und werden bei Verlassen der Funktion wieder zerstört. Ähnlich sieht es bei den im globalen Kontext erzeugten Variablen aus: Diese sind per Default nur auf der Ebene, auf der sie definiert wurden sichtbar – quasi im Hauptprogramm. Über das Keyword global können aber auch Variablen angesprochen werden, die im Aufrufenden Programmteil definiert wurden.

<?php
    // Definition einer Variablen im globalen Kontext
    $x = 1;
    // Zugriff klappt natürlich
    echo 'X: ' . $x . '<br>';

    // Funktion soll x ausgeben
    function echoX () {
        // x ist im Kontext der Funktion nicht definiert
        // Demnach klappt auch die entsprechende Ausgabe nicht
        echo 'X: ' . $x . '<br>';
    }
    // Funktion aufrufen
    echoX ();

    // Folgende Funktion funktioniert besser
    function echoX2 () {
        // x aus dem globalen Kontext bekannt machen
        global $x;
        echo 'X: ' . $x . '<br>';
    }
    echoX2 ();

    // Die nächste Funktion soll zeigen, dass global sich auch nur auf
    // im globalen Kontext definierte Variablen anwenden lässt. Global kann
    // keine in einer übergeordneten Funktionsebene definierten Variablen
    // sichtbar machen.
    function echoY () {
        function echoY2 () {
            // Y ist im globalen Kontext nicht definiert.
            // Aus diesem Grunde führt die folgende Zeile nicht zum
            // gewünschten Ergebnis.
            global $y;
            echo 'Y: ' . $y . '<br>';
        }
        $y = 2;
        // Klappt natürlich
        echo 'Y: ' . $y . '<br>';
        echoY2 ();
    }
    echoY ();
    // Auch von der globalen Ebene lässt sich echoY2 aufrufen, wenn echoY
    // bereits mindestens einmal aufgerufen wurde (aber nicht vorher).
    echoY2 ();
?>

X: 1
X:
X: 1
Y: 2
Y:
Y:

Static PHP Variables: Statische Variablen in PHP

Neben der normalen Definition von Varablen stehen in PHP auch statische Variablen zur Verfügung. Eine Variable kann als solche definiert werden, indem sie bei der Definition mit dem Schlüsselwort static definiert wird. Mit statischen Variablen können Variableninhalte, die innerhalb einer Funktion definiert werden, über die Lebenszeit der in der Funktion definierten Variablen hinaus erhalten werden. Dies kann beispielsweise dann sinnvoll sein, wenn eine Funktion gewissermaßen über ein Gedächtnis oder einen Zustand verfügen soll.

<?php
    // Funktion zum Zählen der Funktionsaufrufe
    function getCounter1 () {
        // Hier soll der Zustand des Counters in einer Variablen abgelegt
        // werden. Da sie aber bei jedem Aufruf initialisiert wird, ist
        // der Rückgabewert recht eintönig.
        $zustand = 0;
        // Rückgabe des in der Variable zustand gespeicherten Wertes
        return ++$zustand;
    }

    // Aufruf der Funktion und Ausgabe der von ihr gelieferten Funktionswerte
    for ($i = 0; $i < 10; $i++)
        echo getCounter1 () . '...';
    echo '<br>';

    // Mit folgender Funktion sollte der Counter sinnvollere Ergebnisse liefern
    // Mittels statischer Variable bekommt sie ein Gedächtnis bzw. einen
    // Zustand.
    function getCounter () {
        // Definition einer statischen Variable zur Realisierung eines
        // Zustands. Die Initialisierung von zustand wird nur beim ersten
        // Aufruf durchgeführt. Alle weiteren Aufrufe nutzen die bereits
        // initialisierte Variable bei Folgeaufrufen weiter.
        static $zustand = 0;
        // Inhalt der Variable um Eins erhöhen und den Wert zurückgeben
        return ++$zustand;
    }

    // Auch hier der Test
    for ($i = 0; $i < 10; $i++)
        echo getCounter () . '...';
    echo '<br>';
?>

1...1...1...1...1...1...1...1...1...1...
1...2...3...4...5...6...7...8...9...10...

PHP Variables: Vordefinierte Variablen

PHP kennt bereits einige vordefinierte Variablen. Zu nennen sind hier insbesondere eine Gruppe von Variablen, die in jedem PHP-Script definiert sind. Dazu gehören die Variablen _SERVER, _GET, _POST, _FILES, _COOKIE, _SESSION, _REQUEST und _ENV – die sogenannten Superglobals. Der Inhalt dieser als assoziative Arrays organisierten Variablen wird teils über Einstellungen des Webservers und zu einem anderen Teil durch den Request-/Response-Kontext bestimmt.

PHP Session Var: Informationen zur Session

Zu den in PHP vordefinierten Variablen gehört, wie bereits erwähnt, auch die Variable _SESSION. In dieser Variable stehen – auch hier wieder in einem assoziativen Array – alle an die Session gebundenen Variablen. Diesen sind solange die Session gültig ist bei jedem neuen Seitenaufruf weiterhin verfügbar. Welche Variablen gespeichert werden kann mit den Session-Funktionen festgelegt werden. Benötigt werden Session-Variablen beispielsweise zur Speicherung von Artikeln, die im Warenkorb des Nutzers eines Internet-Shop gelandet sind. Solange die Session gültig ist werden diese Daten über die einzelnen Seitenaufrufe hinweg gerettet – Ohne die Session-Variable gingen sie bei jedem Aufruf verloren.

Letzte Posts aus unserem Forum

Wer kennt .....

Hallo erstmal wer kennt von euch einen WEbprogrammieren,desginer der mir eine Seite erstellen kann ,Communityportal sowas in der art wie ... » mehr

von NCWebmaster am Mittwoch, 7. Oktober 2009 00:32 in PHP - bisher 2 Antworten
Letzter Beitrag: Montag, 17. Dezember 2012 16:57 von maharadja

...einen guten Onlineshop für Taufringe? Ich habe bisher Taufringe Direkt gefunden und wollte mal nachhaken, ob der Shop für Taufringe wirklich so ... » mehr

Webentwickler Konferenz in Hamburg

Hallo Zusammen, Am 20./21. Mai findet in Hamburg die erste Developer Conference 2011 statt. Wie der Name bereits verrät, handelt die Konferenz rund ... » mehr

von devcon-hamburg am Dienstag, 12. April 2011 16:50 in PHP - noch nicht beantwortet

bedingte Weiterleitung in Kontaktformularen

Hallo zusammen, ich habe ein kleines Problem: Ich brauche bei der Entwicklung eines Kontaktformulares für eine Website eine bedingte Weiterleitung ... » mehr

von scatha am Donnerstag, 10. März 2011 01:12 in PHP - noch nicht beantwortet

Gesucht: Auslesen einer externen Website

Mein vorhaben ist recht simpel aber ich bin php noob (hoffe das entschuldigt es nen bissl xD) und hab kp wie ichs anfangen soll. Und zwar möchte ich ... » mehr

von HeathenMan am Dienstag, 1. Februar 2011 22:57 in PHP - bisher 1 Antwort
Letzter Beitrag: Donnerstag, 3. Februar 2011 14:43 von alm

Hallo, am einfachsten und kompaktesten kann man das mit einem regulären Ausdruck machen. Einfach mal nach der Funktion preg_match_all suchen und den ... » mehr

Zeilenumbruch in der Bildergalerie-Beschriftung

Hallo, die Bildergalerie mit php und js ist super, jedoch möchte ich gern zu meinen Bildern verschiedene Bemerkungen machen und zwar untereinander, ... » mehr

von Sylma am Mittwoch, 26. Januar 2011 01:13 in PHP - bisher 1 Antwort
Letzter Beitrag: Freitag, 28. Januar 2011 10:16 von alm

Hallo, ich nehme an, dass \n im Beschreibungstext nicht funktioniert aber versuchen kann man es. Ansonsten: Schon mal mit einer UTF-Sequenz ... » mehr

¬ Tutorials



¬ Insolvenzrecht