Variablenname / Konstantenname / Variable und Konstanten / Kommentare / Datentypen / logische Operatoren / Vergleichsoperatoren...

 

Konstanten

Wie in jeder Programmiersprache können Daten in Variablen oder Konstanten abgelegt werden,
die für den Programmablauf nötig sind.

Im Programm wird auf die "Daten" somit über den Variablen- bzw. Konstantennamen zugegriffen.

Variablen können während des Programmablaufes neue Werte erhalten,
Konstante behalten ihren Wert über den gesamten Programmablauf hinweg - unveränderlich.

 

Konstante sind "Objekte", deren Wert sich im ganzen Skript, in dem sie definiert wurden, nicht mehr verändern kann.
Definiert werden Konstante über den Befehl define:

define("MYPI", 3.14159);
define("BEST_FILM", "Rosencrantz and Guildenstern Are Dead");

NB. Auf Konstante kann im gesamten Quellcode zugegriffen
werden (siehe auch: Geltungsbereich von Variablen - globale/lokale Variablen).

Von PHP vordefinierte Konstanten: http://php.net/manual/de/reserved.constants.php

Vielleicht lassen sich Konstante auch besser als “Platzhalter” vorstellen, deren Platz später durch den zugehörigen Wert einfach “ersetzt” wird. Konstante werden im Gegensatz zu Variablen direkt über den Namen ohne das Dollar-Zeichen $Zeichen angesprochen (siehe Variablen).

echo "PI ist " . MYPI;
echo BEST_FILM;

Konstanten können in jedem Teil des Skripts und auch in eingebundenen externen Dateien/Funktionen
verwendet werden. Sie sollten der Konventionen wegen immer in GROSSBUCHSTABEN geschrieben werden.
So wird sofort deutlich, dass hier eine KONSTANTE verwendet wird.

Es gibt aber auch in PHP vordefinierte Konstanten wie zB.

__FILE__;

Diese Konstante beinhaltet zB. den Pfad und Dateinamen des Skripts, das gerade abgearbeitet wird.

Variablen

Variablen sind Objekte (Container), die einen beliebigen Wert repräsentieren (innehaben)
und diesen während des Programmablaufs bei Bedarf jederzeit ändern können – wie der Name sagt,
sie sind “variabel”. Dar Variablenname ist dabei während des Programms unveränderlich.

Erstellen einer Variablen
Es sollte zuerst ein passender Name gefunden werden zB.

filmtitel

Um den Namen zu einem Variablennamen zu machen, muss man den “Identifier” für Variablen,
das ist in PHP das Doller-Zeichen ($) voranstellen:

$filmtitel

Einen Wert weist man Variablen durch das Ist-Gleich Zeichen (=) zu:

$filmtitel =

Den Wert der Variablen gibt man rechts vom Istgleich-Zeichen an (bekommt
die Variable bei der Erstellung gleich einen Wert, nennt man dies Variableninitialisierung);

$filmtitel = "BadTaste"

Wie jedes PHP-Statement wird auch die Variablendefiniton
mit einem Strichpunkt ( ; )abgeschlossen:

$filmtitel = "BadTaste"; // Variabledefinition und Initialisierung

Nachdem man der Variablen einen Wert gegeben hat, kann man sie genauso verwenden
wie den zugewiesenen Wert selbst.

echo $filmtitel; // gibt BadTaste aus
echo "BadTaste"; // gibt BadTaste aus

// Variablendefinition ohne Wertzuweisung.

$filmtitel_xy;

$i_am  = "Bart";
$iLike = "call Moe";
$satz  = $i_am . ' likes to ' . $iLike; // Satz: Bart likest to call Moe
$age   = 10;
$i_am  = "gone";
$iLike = "to be upset";
$age   = NULL;

 

Regeln zur Benennung

Variable beginnen mit einem $ Zeichen. So weiß PHP, dass ein Variablennamen folgt.
Ein Name besteht aus einer Folge von Buchstaben, Ziffern und Unterstrichen (_). Deutsche
Umlaute und das ß sind nicht erlaubt; das erstes Zeichen muss ein Buchstabe oder ein Unterstrich (_)sein.
Groß-/Kleinschreibung ist von Bedeutung, d.h. $test; ist ein anderer Variablen-Namen als $Test; und
kann somit auch einen Unterschiedlichen Wert haben (case-sesitiv).

Es ist auch möglich Variablen mit dem Befehl unset($VariablenName); wieder aus
dem Speicher zu löschen. Der für die Variable belegte oder reservierte Speicher wird dadurch freigegeben.
Nach dem Löschen kann die Variable natürlich nicht mehr eingesetzt werden.

Datentyp
Variablen haben einen bestimmten Daten-Typus (datatype), d.h. unterschiedliche Variablen können einen bestimmten Wert (innerhalb eines Wertebereichs) annehmen. Der Variablentyp sollte im Programm möglichst nie geändert werden und kann es in manchen Scriptsprachen auch nicht. PHP verwendet automatisch den Typ, der laut Zuordnung passend ist (PHP-Variablen sind an sich untypisiert und haben eben eine dynamische Typisierung, dh der Typ der Variablen kann sich im Laufe des Programmes ändern: $i = 1; $i++; $i = "99"; $i++; Das letzte $i++ führt dennoch nicht zu einer Fehlermeldung, obwohl der Typ nicht mehr "integer", sondern "string"(Zeichenkette) ist!. Der Typ von Variablen sollte möglichst nicht gewechselt werden, besser ist es zB $s = (String) $i; zu verwenden und $s verwenden, wenn eine Zeichenkette verlangt wird bzw. $i, wenn ein nummerischer Wert gefordert ist.

$i = 1;
$i++;
$i = 99;
$s = (string) $i;
var_dump($i);
var_dump($s);
?>  

Programmausagabe:

int(99)
string(2) "99"

 

$variable_a = "1";  // Datentyp: String (Zeichenkette), Zeichen zwischen “ oder '
$variable_b = 1;    // Datentyp "Integer" (Ganzzahl)
$hofer      = 1.99; // Datentyp "Float" (Gleitkommazahl)

Variablen können verschiedenste Datentypen wie Zeichen, Zahlenwerte
(Fließkomma- und Ganzahl), Arrays, Booleanwerte (boolsche Werte) und Objekte beinhalten.

 

Zusatz/Spezialfall (nur in den seltensten/seltsamsten Fällen zu empfehlen):
Den Variablennamen kann man indirekt mit folgendem Konstrukt "ändern":

$filmtitel    = "BadTaste";
$neuevariable = "filmtitel";
echo "${$neuevariable}"; // $neuevariable wird substituiert mit filmtitel,
                                     // daraus folgt wieder: echo "$filmtitel";
so folgt Programm-Ausgabe: BadTaste

Referenzierte Variablen

Es gibt auch sogenannte referenzierte Variablen, das sind Variablen, die selbst keinen Speicherplatz für Daten anlegen,
sonder nur auf den Speicherplatz “hinzeigen” (also eine Referenz darauf bilden), an dem bereits Daten einer Variablen vorhanden sind.

$variableDieSpeicherplatzbelegt = "1234567890";
// Im Speicher wird für die Daten “1234567890”
// Speicherplatz reserviert, auf den wie üblich über den
// Variablennamen zugegriffen werden kann

$gleicheDaten = &$variableDieSpeicherplatzbelegt;
// Die Variable $gleichDaten zeigt nur an die
// Speicherstelle an der die Daten der Variablen $variableDieSpeicherplatzbelegt // stehen.

Sie hat somit den gleichen Wert, aber belegt nicht extra noch mal so viel Hauptspeicher wie die Variable selbst.

 

echo $variableDieSpeicherplatzbelegt . ';
echo $gleicheDaten;

gibt beidemale 123456789 aus.

 

 

 

 

Datentypen

PHP verwendet “lose Datentypen” (loose type), d.h. der Datentyp einer Variablen stellt sich erst bei der Zuweisung heraus.

z.B.
$myVar = 7;     // Datentyp: Ganzzahl(Integer)
$myVar = ”7”;   // Datentyp: Zeichenkette(String)
$myVar = TRUE;// Datentyp: Wahrheitswert/Boolean (TRUE oder FALSE)
$myVar = 0.7;   // Datentyp: float (Gleitkommazahl)

Wenn möglich sollte man also folgendes vermeiden, da sich hier der Datentyp der
variable implizit ändert. Bei umfangreichen Projekten oder bei gemeinschaftlicher Projektarbeit
kann dies relativ schnell zu Fehlern fürhren:

$age = 10;
$age = "10"; // nicht vorteilhaft; man sollte den Typ der Variablen
// im Programm möglichst nicht verändern (zB hier der Wechsel von “Zahl” auf
// “Zeichenkette”.

Gängige Datentypen sind zB:

Integer	10	eine Ganzzahl
Double	3.14159	eine Gleitkommazahl
String	“Bart	eine Zeichenkette
Boolean	TRUE/FALSE	“Wahrheitswerte”: Falsch oder Richtig für logische Operationen
Array und Objekt

Statements (Befehlszeilen) werden in PHP wie gesagt immer mit einem Strichpunkt
abgeschlossen ';' und setzen sich hauptsächlich aus Konstanten, Variablen und Operatoren zusammen, z.B.

$kreisflaeche_weniger_eins = 2 * r * PI - 1;

Konstante	PI
Variable	$kreisflaeche_weniger_eins
Operatoren	* und – (Multiplikation und Subtraktion) dabei gilt, wie allgemein in der Mathematik zB Punkt- vor Strichrechnung, außer es wird natürlich dezitiert geklammert: zB 2*r*(PI-1)

Im Gegensatz zu Zeichenketten (Strings), stehen nummerische Werte (z.B. auch obiger Wert 10) nicht unter Anführungszeichen ".

 

 

 

Kommentare

Sie können durch einen zweichfach-Forward-Slash

// 

hinter einem Befehl oder in einer neuer Zeile angebracht werden.

Alles nach // wird von Interpret bist zur Zeilenschaltung (RETURN) ignoriert und dient rein zur Dokumentation.

Eine zweite Möglichkeit den Kommentar über mehrer Zeilen zu schreiben ist /* und */. Vergleichbar mit in Javascript.

Der Kommentar darf aber nicht verschachtelt sein, also wäre dies ein Fehler:
/* Summer's /* almost */ gone */

 

 

Logische Operatoren

Logische Operatoren prüfen ebenso wie Vergleichsoperatoren den Wahrheitswert (TRUE oder FALSE) von Konstrukten.

Folgende logische Operatoren werden meist verwendet:

&&	UND
||	ODER
!	NICHT

 

Auf diese Weise können Programmverzweigungen von logischen Bedingungen abhängig gemacht werden.

Die logischen Operatoren heißen auch boolsche Operatoren.

UND (&&)

UND-Operator "&&" liefert genau dann WAHR (TRUE) (1), wenn beide
Operaden WAHR sind, sonst liefert er 0 (=FALSCH) (FALSE).

Beispiel:

(($x < $max) && ($y > 0))
Dies trifft nur zu, wenn der Wert der Variablen $x kleiner ist als der der Variablen $max UND $ygrößer als 0 ist.

Statt dem &&-Operator kann in PHP auch “and ” verwendet werden (eher unüblich).

if ((7 == 7) and (10 / 2 == 5))
    echo "Dies stimmt, da beim logischen UND (&&) BEIDE Ausdrücke 
TRUE(1) zurueckliefern müssen.";

 

 ODER (||)
(Das | Zeichen erreicht man auf der Tastatur durch gedrückt halten von AltGr und > Taste)

 

Der ODER-Operator "||" liefert genau dann WAHR (1), wenn
mindestens 1 Operand WAHR ist. Nur wenn beide Operandenbeziehungen
FALSCH (FALSE, 0) sind, liefert der oder-Operator "FALSCH" (FALSE) zurück.

Beispiel:

(($laenge < 0.2) || ($laenge > 9.2))

Diese Bedingung ist WAHR, wenn die Länge kleiner als 0.2 ($laenge < 0.2) ist oder wenn
die Länge größer als 9.2 ($lange > 9.2) ist. Wäre die Länge 2, so wäre die Bedingung
FALSCH, da: (2 < 0.2) => FALSCH und (2 > 9.2) => FALSCH.

Die Bedingung wäre aber WAHR, sobald nur eine der beiden Bedingungen zutreffen würde.

Auch wenn mehr als zwei Bedingungen gegeben sind, muss immer nur eine den Wahrheitswert
TRUE liefern um die ODER-Bedingungen zu erfüllen.

 

Statt dem ||-Operator kann auch “or” verwendet werden.

if ((7 == 99) or (10 / 2 == 5))
    echo "Das stimmt, da beim logischen OR (||) nur einer aller Ausdrücke 'wahr  sein' muss. um insgesamt TRUE (wahr) nach der oder-Verknüpfung zu werden.";

 

NICHT (!)

Der NICHT-Operator "!" liefert genau dann WAHR (1), wenn sein Operand
FALSCH (0) ist. Enthält die Variable $flag den Wert 1, so liefert

!$flag den Wert 0.

  // => !true == false
  $falsch   =  !true;
  //  => !false == true
  $richtig  =  !false;
?>

Exkurs "Digitaltechnik", Quelle: Wikipedia

TRUE = 1, FALSE = 0

AND, OR, XOR, NOT

Das Und-Gatter (engl. AND)	Das Oder-Gatter (engl. OR)	Das XOR-Gatter	Das Nicht-Gatter (engl. NOT)
Das Und-Gatter (die Verknüpfung von Leitungen mittels Und-Gattern wird Konjunktion genannt) ist ein wichtiges Element der Schaltungslogik. Im Gegensatz zum Nicht-Gatter hat ein Und-Gatter jedoch mindestens zwei Eingänge, die es vergleicht. So stellt sich die Schaltfunktion anders dar als die des Nicht-Gatters: Wahrheitstabelle x1 x0 y 0 0 0 0 1 0 1 0 0 1 1 1 Um eine logische 1 am Ausgang y zu erreichen, müssen also beide Eingänge auf logisch 1 sein.	Auch das Oder-Gatter (die Verknüpfung von Leitungen mit Oder-Gattern wird Disjunktion genannt) hat mind. zwei Eingänge, welche es vergleicht. Im Gegensatz zum Und-Gatter folgt aber bereits durch eine logische 1 an einem Eingang automatisch eine logische 1 am Ausgang. y = x1 + x0 Wahrheitstabelle x1 x0 y 0 0 0 0 1 1 1 0 1 1 1 1 Um eine logische 1 am Ausgang y zu erreichen, müssen also ein oder beide Eingänge auf logisch 1 sein.	Das XOR-Gatter (von engl. eXclusive OR - exklusives Oder, entweder oder) ist ein Gatter mit mehreren Eingängen und einem Ausgang, bei dem der Ausgang genau dann logisch „1“ ist, wenn an einer ungeraden Anzahl von Eingängen „1“ anliegt und an den restlichen „0“. Die XOR-Verknüpfung wird auch als Anti- oder Kontravalenz bezeichnet. Wahrheitstabelle x1 x0 y 0 0 0 0 1 1 1 0 1 1 1 0	Das Nicht-Gatter (auch Komplement-Gatter oder Inverter genannt) ist die elementarste digitale Logikfunktion. Es besitzt lediglich einen Eingang. Der Ausgang dreht dabei den logischen Zustand des Eingangs um. (gesprochen: y ist x nicht) Wahrheitstabelle x y 0 1 1 0 Somit ist der Ausgang y das Komplement des Eingangs x.

Vergleichsoperatoren

Vergleichsoperatoren führen zu einem boolschen Ergebnis, d.h. entweder der Vergleich stimmt (TRUE) oder er ist falsch (FALSE).

Mit Vergleichsoperatoren lassen sich Aussagen über die Wahrheit von Ausdrücken feststellen.zB.

$ist = (7 == 5);	// da 7 nicht 5 ist wird in $ist der Wert FALSE (falsch, 0) zurückgeliefert.
$ist = (10 / 2 == 5);	// da 10 dividiert durch zwei 5 ergibt und 5 gleich 5 ist wird TRUE (wahr,1) zurückgeliefert.

 

ist gleich	==	$x == $y ist $x gleich $y? (Achtung! Zwei Istgleichzeichen == sind nötig)
ungleich	!=	$x != $y ist $x ungleich $y?
kleiner	<	$x < $y ist $x kleiner als $y?
größer	>	$x > $y ist $x größer als $y?
größer-gleich	>=	$x >= $y ist $x größer gleich $y?
kleiner-gleich	<=	$x <= $y ist $x kleiner gleich $y?

 

 

Operatoren

Um nun Manipulationen mit den Daten, die in den Variablen oder Konstanten, Arrays etc.
gespeichert sind durchzuführen benötigt es Operatoren.
Kurz gesagt sind Operatoren Symbole, die meist aus zwei oder mehreren Werten einen neuen erschaffen (errechnen).

Je nach Datentyp gibt es meist noch spezielle(re) Operatoren. Das “+” Symbol ist zB sehr universell einsetzbar:
Folgendes Beispiel funktioniert natürlich mit numerischen Werten, aber auch mit Zeichenketten.

 

 

$a = 1;	// Variable $a erhält den numerischen Wert 1
$b = 2;	// Variable $b erhält den numerischen Wert 2
$c = $a + $b;	// $a und $b nennt man Operanden, das Pluszeichen nennt man Operator // das Ergebnis dieser “Operation” landet durch das Zuewisungszeichen in $c
echo $c;	// 3 wird ausgegeben
$a = "1";	// Variable $a erhält das Zeichen “1”
$b = "2";	// Variable $b erhält das Zeichen “2”
$c = $a + $b;	// $a und $b nennt man Operanden, das Pluszeichen nennt man Operator // das Ergebnis dieser “Operation” landet durch das Zuewisungszeichen in $c // Ausdruck nennt man eine Zusammensetzung aus Operanden und Operatoren // hier wäre: $a+$b; der Ausruck (expression)
echo $c;	// “12” wird ausgegeben, da Variablen die Zeichen beinhalten mit dem Operator “+” // zusammengefügt werden.

 

gängige Operatoren sind:

+	Addition x + y
-	Subtraktion x - y
*	Multiplikation x * y
/	Division x / y
%	Modulus Operation (Restwert der Division) x % y

 

Einschub: Arrays / "Datentypen"

 

Ein Array ist eine Datenstruktur, die mehrere Daten des gleichen Typs aufnehmen soll -
wer mit anderen Programmiersprachen programmiert, für die/den sind gleiche Datentypen (integer oder zB string) je "Array" ohnehin meist Pflicht.

Es ist auch sinnvoll nicht alle "Features" die möglich wären auszunutzen, so fällt ein Umstieg auf eine Programmiersprache, die strengeren Gepflogenheiten folgt / strenger typisiert ist auch wohl einfach leichter.

$doNotDo = array(      // "wirrwarr"
    "days" => array(
        6 => 6,
        // fehlerträchtig
        0 => "So",
        "Mo" => 0
    )
);

echo $doNotDo["days"][0]; 
echo $doNotDo["days"]['Mo'];

// Ausgabe: 
// So
// 0

 

Über den "Arrayindex", ersichtlich durch die eckigen Klammern [ ], wird auf die einzelnen Elemente des Arrays zugegriffen.
Zu beachten ist, dass das erste Element eines Arrays den Indexwert 0 hat.

 

 

Die Ausgabe ist wie folgt:

 

 

"Speicherverbrauch"

Mit unset($arraynamen); wird ein Array wieder aus dem Cpmputer-Hauptspeicher entfernt.

Ein neues Element kann man mit $arrayNamen[] = neuesElement; anfügen.
Will man wissen, wie viele Elemente letztendlich im Array sind, lässt sich das über

$anzahl_der_elemente = sizeof($arrayNamen);

herausfinden; diesen Wert kann man natürlich zB in einer for-Schleife auch gleich verwenden:

$filme[] = "Brain Dead";
$filme[] = "Dogma";
sort($filme); // sortieren
echo "
 Schleife nach Sortieren: 
";
for ($i = 0; $i <= sizeof($filme); $i++) {
    echo $filme[$i];
    echo "
";
}