Modul 295

Backend für Applikationen realisieren

02 - Variablen und Datentypen

Typumwandlung, Konstanten und Vergleichsoperatoren

Lernziele dieser Lektion

• Die wichtigsten Datentypen von PHP kennen
• "Type Juggling" und "lose Typisierung" verstehen
• Datentypen mit Funktionen prüfen können
• Datentypen gezielt umwandeln können (Type Casting)
• Konstanten mit define() und const definieren können
• Den Unterschied zwischen losem und striktem Vergleich (== vs. ===) kennen

Rückblick: Variablen

• Variablen beginnen in PHP immer mit einem $
• PHP ist lose typisiert - der Typ wird automatisch aus dem Wert bestimmt
• Eine Typangabe bei der Deklaration ist nicht nötig

                    
                        <?php
                        $name = "Anna";
                        $age = 24;
                    
                

Skalare Datentypen

PHP kennt vier skalare (einfache) Datentypen:

Verbund- und Spezial-Datentypen

array und object schauen wir uns in einer späteren Lektion genauer an.

Datentyp herausfinden

gettype() gibt den Datentyp einer Variable als String zurück.

                    
                        <?php
                        $price = 19.95;

                        echo gettype($price); // "double"
                    
                

Hinweis: PHP nennt den Typ float intern double.

Datentyp prüfen

Für jeden Datentyp existiert ausserdem eine eigene is_*()-Funktion, welche true oder false zurückgibt.

                    
                        <?php
                        $age = 24;

                        var_dump(is_int($age));    // bool(true)
                        var_dump(is_string($age)); // bool(false)
                        var_dump(is_float($age));  // bool(false)
                        var_dump(is_bool($age));   // bool(false)
                    
                

Type Juggling

• PHP wandelt Datentypen bei Bedarf automatisch um - das nennt sich Type Juggling
• Passiert z.B. bei Rechenoperationen oder Vergleichen mit ==

                    
                        <?php
                        $result = "10" + 5;   // int(15) - String wird zu int
                        $result = "10" . 5;   // string("105") - int wird zu string
                        $result = "3.5" + 1;  // float(4.5)
                    
                

Das kann zu unerwarteten Ergebnissen führen - deshalb ist es wichtig, Datentypen bewusst zu kennen.

Type Casting

Mit Type Casting wandeln wir einen Wert gezielt selbst in einen anderen Datentyp um.

                    
                        <?php
                        $input = "42";

                        $number = (int) $input;     // int(42)
                        $decimal = (float) $input;   // float(42)
                        $text = (string) 42;         // string("42")
                        $flag = (bool) 1;             // bool(true)
                    
                

Der gewünschte Zieltyp steht dabei in runden Klammern vor dem Wert.

Type Casting - Anwendungsfall

Formulareingaben aus $_GET/$_POST sind in PHP immer vom Typ string - selbst wenn eine Zahl eingegeben wurde.

                    
                        <?php
                        $quantity = "3"; // z.B. aus einem Formular
                        $price = 19.95;

                        $total = (int) $quantity * $price;
                        echo $total; // 59.85
                    
                

Wahrheitswerte anderer Typen

Jeder Wert lässt sich zu bool umwandeln. Als false gelten dabei:

Alle anderen Werte gelten als true - auch "false" als String!

Konstanten

• Eine Konstante speichert einen Wert, der sich zur Laufzeit nicht mehr ändern lässt
• Definition mit der Funktion define()
• Kein $ beim Namen, per Konvention in GROSSBUCHSTABEN

                    
                        <?php
                        define("VAT_RATE", 0.077);

                        echo VAT_RATE; // 0.077
                    
                

Konstanten mit const

Alternativ lassen sich Konstanten auch mit dem Schlüsselwort const definieren.

                    
                        <?php
                        const VAT_RATE = 0.077;
                        const COMPANY_NAME = "Modul 295 AG";

                        echo VAT_RATE;
                        echo COMPANY_NAME;
                    
                

const wird ausserhalb von Klassen meist bevorzugt, da es zur Kompilierzeit ausgewertet wird.

Vergleichsoperatoren

== vs. ===

                    
                        <?php
                        var_dump(0 == "abc");    // bool(false) 
                        var_dump("10" == 10);    // bool(true)  - Type Juggling
                        var_dump("10" === 10);   // bool(false) - unterschiedlicher Typ
                        var_dump(10 === 10);     // bool(true)  - Wert und Typ gleich
                    
                

Faustregel: In PHP möglichst immer === verwenden, um unerwartetes Type Juggling zu vermeiden.

TL;DR

• PHP kennt die Skalartypen string, int, float, bool sowie u.a. array und null
• gettype() und is_*() prüfen den aktuellen Datentyp
• Type Juggling wandelt Typen automatisch um, Type Casting (int) etc. macht dies gezielt
• Konstanten werden mit define() oder const definiert und sind unveränderlich
• === vergleicht Wert und Typ und sollte == vorgezogen werden