PHP

Grundlagen

Installation und Umgebung prüfen

PHP-Version prüfen:

php --version

# oder kurz:
php -v

# PHP-Pfad anzeigen:
which php

# Über den Paketmanager prüfen, ob PHP installiert ist:
dpkg -l | grep php

PHP installieren:

sudo apt update && sudo apt install php

# Optional zusätzlich explizit das CLI-Paket installieren:
sudo apt update && sudo apt install php php-cli

In den meisten Fällen enthält sudo apt install php bereits php-cli als Abhängigkeit. Die explizite Angabe macht die Absicht aber klarer.

PHP-Code ausführen

# PHP kann interaktiv im Terminal gestartet werden:
php -a

# Beenden mit:
Ctrl + C

# Eine PHP-Datei kann direkt über die Kommandozeile ausgeführt werden:
php name.php

# PHP bringt außerdem einen eingebauten Entwicklungsserver mit:
php -S localhost:8000

# Danach kann die Seite im Browser geöffnet werden:
http://localhost:8000

Dateibenennung

// Der Standardname für PHP-Startseiten ist:
index.php

// Dieser Name wird von Webservern häufig automatisch als Startdatei erkannt.
// Für Demo- oder Testdateien sind zum Beispiel möglich:
demo.php
intro.php
test.php
playground.php

// Weniger üblich, aber möglich:
app.php

PHP-Tags

PHP-Code wird zwischen speziellen PHP-Tags geschrieben:

<?php
echo "Hello World!"; ?>

// PHP kann auch innerhalb von HTML verwendet werden:
<h1>
    <?php echo "Hello World!"; ?>
</h1>

// Für kurze Ausgaben gibt es die Kurzschreibweise:
<?= "Hello World!" ?>

// Diese Kurzschreibweise entspricht ungefähr:
<?php echo "Hello World!"; ?>

Ausgabe erzeugen

Die häufigste Möglichkeit, Text auszugeben, ist echo:

<?php
echo "Hello World!";

// Mehrere Werte können nacheinander ausgegeben werden:
echo "Hello", " ", "World";

// Auch Variablen können direkt ausgegeben werden:
$name = "Alice";
echo $name;

Variablen und Datentypen

Variablen

Variablen beginnen in PHP immer mit einem Dollarzeichen:

<?php
$name = "Alice";
$age = 25;
$isStudent = true;

// PHP erkennt Datentypen automatisch:
$thing = "Hello";
$thing = 42;
$thing = true;

// PHP ist dynamisch typisiert. 
// Das bedeutet, dass eine Variable ihren Typ im Laufe des Programms ändern kann.

Datentypen

Häufige Datentypen in PHP sind:

<?php
// string
$string = "Hello";
// int
$number = 42;
// float
$float = 3.14;
// bool
$bool = true;
// array
$array = ["Apple", "Banana"];
// object
$user = new User();
// null
$value = null;

// Mit var_dump() kann ein Wert inklusive Datentyp angezeigt werden:
var_dump($string); // string(5) "Hello"

Strings

Variablen können innerhalb von Strings mit doppelten Anführungszeichen direkt eingesetzt werden:

<?php
$name = "Alice";
echo "Hello $name";

// Strings können außerdem mit dem Punkt . verbunden werden:
echo "Hello " . $name;
// Der Punkt ist in PHP der Operator zur String-Verkettung.

Truthy und Falsy

<?php
// Falsy-Werte in PHP:
false
0
0.0
""
"0"
[]
null

// Alles andere gilt als truthy, zum Beispiel:
"hello"
1
-1
[1, 2, 3]
new User()

Kontrollstrukturen

Bedingungen

<?php
// Eine einfache if-Bedingung:
$age = 20;

if ($age >= 18) {
    echo "Adult";
}

// Eine if / else-Bedingung:
if ($age >= 18) {
    echo "Adult";
} else {
    echo "Minor";
}

// Eine if / elseif / else-Bedingung:
$grade = 2;

if ($grade == 1) {
    echo "Excellent";
} elseif ($grade == 2) {
    echo "Good";
} else {
    echo "Keep practicing";
}

Vergleichsoperatoren

<?php
// Wichtige Vergleichsoperatoren:
==   // gleich, nur Wert
===  // strikt gleich, Wert und Typ
!=   // ungleich
>    // größer als
<    // kleiner als
>=   // größer oder gleich
<=   // kleiner oder gleich
   
// Beispiel:
$a = 5;
$b = "5";

var_dump($a == $b);  // true
var_dump($a === $b); // false
      
// == vergleicht nur den Wert.
// === vergleicht Wert und Datentyp.

Schleifen und Scope

PHP hat kein Block Scope für if, for oder while.

Eine while-Schleife:

<?php $count = 0;

while ($count < 5) {
    echo $count;
    $count++;
}
                  
// Die Variable $x ist auch außerhalb des if-Blocks verfügbar.

// Eine for-Schleife:
for ($i = 0; $i < 5; $i++) {
    echo $i;
}

// Eine foreach-Schleife:
$names = ["Alice", "Bob", "Charlie"];

foreach ($names as $name) {
    echo $name;
}

// foreach wird in PHP sehr häufig verwendet, besonders bei Arrays.

Datenstrukturen

Arrays

Ein einfaches Array:

<?php
$fruits = [
    "Apple",
    "Banana",
    "Orange"
];

// Ein Element wird über seinen Index gelesen:
echo $fruits[0]; // Apple
// Arrays beginnen bei Index 0.

Assoziative Arrays

<?php
// Assoziative Arrays verwenden benannte Schlüssel:
$user = [
    "name" => "Alice",
    "age" => 25
];

echo $user["name"];

// Assoziative Arrays ähneln einfachen Objekten in JavaScript.

Funktionen

<?php
// Eine Funktion definieren:
function greet($name) {
    return "Hello " . $name;
}

// Eine Funktion aufrufen:
echo greet("Alice");

// Variablen innerhalb einer Funktion haben ihren eigenen Scope:
$name = "Alice";

function greet() {
    global $name;
    echo $name;
}

greet();

// Funktionen können nicht automatisch auf globale Variablen zugreifen. 
// Dafür ist global notwendig.

Typisierte Funktionen

<?php
// Parameter und Rückgabewerte können typisiert werden:
function add(int $a, int $b): int {
    return $a + $b;
}

// Aufruf:
echo add(2, 3);

Closures

Moderne PHP-Versionen unterstützen Closures, also anonyme Funktionen:

<?php
$message = "Hello";

$fn = function () use ($message) {
    echo $message;
};

$fn();

// Das use (...) ist nötig, damit die Closure auf eine Variable außerhalb der Funktion zugreifen kann.

Referenzen

Mit & kann eine Referenz erzeugt werden:

<?php
$a = 10;
$b = &$a;

$b = 20;

echo $a; // 20

// $b verweist hier auf dieselbe Stelle wie $a.
// Arrays werden nicht automatisch als Referenz gespeichert.
// Objekte werden hingegen als Referenz-ähnliche Werte behandelt.

Objektorientierte Programmierung

Objekte und Klassen

<?php
// Echte Objekte entstehen in PHP normalerweise aus Klassen:
class User {
    public string $name;
    public int $age;
}

$user = new User();

$user->name = "Alice";
$user->age = 25;

// Der Zugriff auf Eigenschaften erfolgt mit dem Objekt-Operator ->.
echo $user->name; // Alice

// Sichtbarkeit von Eigenschaften und Methoden:
public    // von überall zugreifbar
protected // innerhalb der Klasse und in Unterklassen zugreifbar
private   // nur innerhalb der Klasse zugreifbar

Typangaben wie string oder int sind optional, werden in modernem PHP aber häufig verwendet.

Scope Resolution Operator ( :: )

// Wird verwendet, um auf statische Methoden, statische Eigenschaften oder Konstanten einer Klasse zuzugreifen

class Math {
    public static function add($a, $b) {
        return $a + $b;
    }
}

echo Math::add(3, 4); // 7

// Bei nicht-statischen Methoden wird stattdessen der Objektoperator -> verwendet
class Math {
    public function add($a, $b) {
        return $a + $b;
    }
}

$math = new Math();
echo $math->add(3, 4); // 7

Dateiverarbeitung

Dateien lesen

Datei mit PHP einlesen:

<?php
$content = file_get_contents("names.txt");
echo $content;

// file_get_contents() liest den gesamten Inhalt einer Datei als String ein.

CSV-Dateien lesen

<?php
// CSV-Datei mit PHP öffnen und zeilenweise lesen:
$file = fopen("data.csv", "r");

while (($data = fgetcsv($file)) !== false) {
    echo $data[0] . " " . $data[1];
}

fclose($file);

// fopen() öffnet die Datei.
// fgetcsv() liest eine CSV-Zeile als Array.
// fclose() schließt die Datei wieder.

Praktische Werkzeuge

Zufallszahlen

Eine zufällige Zahl zwischen 1 und 100 erzeugen:

<?php
$number = rand(1, 100);
echo $number;

// Beispiel mit Bedingung:
if ($number > 50) {
    echo "Lucky!";
}

Debugging

<?php
// Einen einfachen Wert ausgeben:
echo $a;

// Alternative Schreibweise:
echo("Hello World");

// Datentyp und Wert anzeigen:
var_dump($value);

// Array lesbar anzeigen:
print_r($array);

// var_dump() ist besonders hilfreich, weil es zusätzlich den Datentyp anzeigt.

JavaScript vs. PHP

JavaScript	PHP
let name = "Alice"	$name = "Alice"
const PI = 3.14	const PI = 3.14
Block Scope mit let	Kein Block Scope
Function Scope	Function Scope
Closures greifen automatisch zu	use(...) notwendig
Dynamisch typisiert	Dynamisch typisiert

Beispiel zum fehlenden Block Scope in PHP:

<?php
for ($i = 0; $i < 5; $i++) {}

echo $i;
                    
// Ausgabe: 5
// Viele JavaScript-Entwickler erwarten hier einen Fehler. 
// In PHP bleibt $i aber nach der Schleife im aktuellen Scope verfügbar.