• www.lehrling
• Index PHP

• Einführung:
• Fehler:
• Sicherheit:
• Sprachelemente
• Variable und Arrays:
• • Array Numerisch
  • Array Assoziativ
  • Array ausgeben
  • Superglobale Variablen
  • Konstante
  • Funktion
  • Globale Variable in Funktion
  • Variable an Seite
  • if, else, switch Kontrollen
  • for, while Schleifen
  • Redirect
  • Header Info
  • Cookie
  • PHP in Javascript
• String:
• Zahlen:
• Formulare:
• Dateien und Ordner:
• MySQL:
• SQLite:
• WCMS

Array Assoziativ

Ein Array ist eine Sammlung von Variablen, in assoziativen Arrays haben die Variablen ansprechende Namen (Strings statt Zahlen).

Auf der Seite Numerische Arrays sind weitere Array Funktionen beschrieben.

Array konstruieren

Mit dem Konstruktor einen Array konstruieren

$Tier = array ("Ka" => "Katze", ...

Einer Variablen wird ein Array zugeordnet, in einer Klammer wird dem assoziativen Index mit einer Art Pfeil bestehend aus = und > ein Wert zugeordnet, mehrere Einträge werden durch Komma getrennt. Der Assoziative Index ist ein String, wird also angeführt.
Auch beim Aufruf eines Eintrages wird der Index als String behandelt, ohne Anführungszeichen würde PHP eine undefinierte Konstante melden.

<?php
  $Tier = array ("Ka" => "Katze", "Es" => "Esel", 
    "Hu" => "Hund", "Pf" => "Pferd", "Ha" => "Hahn",);

  echo "Das ".$Tier ["Pf"]." ist kein Bremer Stadtmusikant.<br>";
?>

Mit dem Identifizierer einen Array indizieren

[key]="value"

Wir schreiben den Array '$Tiere':
<?php
  $Tiere ['e'] = "Hahn";
  $Tiere ['b'] = "Katze";
  $Tiere ['c'] = "Zebra";
  $Tiere ['a'] = "Hund";
  $Tiere ['d'] = "Pferd";
  $Tiere ['f'] = "Esel";
  echo $Tiere ['b']."<br />"; // zur Auswahl muss man den Index kennen

  $Tiere ['z'] = "Kuh"; // hinzufügen geht ganz einfach
  echo $Tiere ['z']."<br />";

  $Tiere ['e'] = "Wolf"; // ändern geht ganz einfach
  echo $Tiere ['e'];
?>

Zu Beachten habe ich, dass der Identifizierer ein String ist und folglich 'angeführt' wird.
Würde ich $Tiere [e]; (ohne Anführungszeichen) aufrufen, dann generierte PHP eine Fehlernotiz, weil es keine Konstante e findet.

Array Analysieren

Alle Funktionen ausser isset() setzen voraus, dass die Variable existiert.
Falls eine Variable aufgerufen wird, die gar nicht gesetzt ist, gibt es eine Fehlermeldung.

Ist diese Variable überhaupt gesetzt?

isset();

isset() fragt: Gibt es diese Variable, diesen Array überhaupt? und gibt 1 für TRUE oder nichts für FALSE zurück.
echo isset($Tiere);
1 // 1 für TRUE wenn es $Tiere gibt

echo !isset($Tiere);
// Behauptung ist FALSE, dass es $Tiere nicht gäbe

Zwei Funktionen um komplexe Arrays komplett darzustellen sind: print_r() oder var_dump() auf einer eigenen Seite.

Total der Einträge im Array feststellen

count($ArrayName)

Es hat <?php echo count($Tiere); ?> Tiere im Array.

Es hat 7 Tiere im Array.

Den allerletzten Eintrag herausfinden

end($Tiere);

<?php echo end($Tiere); ?>
Letzte Kuh macht Türe zu.

Eintrag auf vorhanden sein eines Wertes überprüfen

in_array("Katze",$Tiere);

Ist ein bestimmter Eintrag in diesem Array enthalten? (gibt nichts wenn FALSE oder 1 wenn TRUE zurück):
echo in_array("Katze",$Tiere);
1 // 1 falls TRUE

Welchen Index im Array hat die Katze?

array_search("Katze", $Tiere);

Wo ist die Katze?: array_search() gibt den Index zurück
<?php
$finde = array_search ("Katze", $Tiere);
if ($finde) { echo $finde." ist der Key von "
. $Tiere[$finde]; } // wie echo $Tiere[b];
?>
b ist der Key von Katze

gibt es einen Index x im Array Tiere?

array_key_exists("x", $Tiere);

echo array_key_exists("x", $Tiere);
// nichts wenn kein Schlüssel x existiert

Welche Indizes gibt es im Array?

array_keys ($Tiere);

Der Rückgabewert ist ein numerischer Array mit allen Schlüsseln des fraglichen Arrays.

print_r(array_keys($Tiere));

Array
(
    [0] => e
    [1] => b
    [2] => c
    [3] => a
    [4] => d
    [5] => f
    [6] => z
)

Welche Werte gibt es im Array?

array_values ($Tiere);

Der Rückgabewert ist ein numerischer Array mit allen Werten des fraglichen Arrays.

print_r(array_values($Tiere));

Array
(
    [0] => Wolf
    [1] => Katze
    [2] => Zebra
    [3] => Hund
    [4] => Pferd
    [5] => Esel
    [6] => Kuh
)

foreach Schleife

foreach($Tiere as $temp)

Zum Abarbeiten von Arrays gibt es extra eine Schleife, diese wird für jeden Array-Eintrag erneut durchlaufen. Dabei werden temporäre Variablen erstellt bzw. benannt und bei jedem Durchgang überschrieben.

<?php
foreach($Tiere as $temp)
{
echo "$temp<br />";
}
?>

Nur die Werte:
Wolf
Katze
Zebra
Hund
Pferd
Esel
Kuh

foreach($Tiere as $key => $value)

Schlüssel und Werte:

<?php
foreach($Tiere as $key => $value) // => ist funktionierender Zuordner

{
  echo $key," => ", $value, "<br>"; //  => ist nur ein "String" in der Ausgabe
}
?>

e => Wolf
b => Katze
c => Zebra
a => Hund
d => Pferd
f => Esel
z => Kuh

Die Ausgabe erfolgt in der Reihenfolge des Array-Eintrages und nicht irgendwie alphabetisch!

Array sortieren

Array nach Werten aufsteigend sortieren

asort($Arrayname);

... und erneut ausgeben, die Reihenfolge hat geändert!

Esel : f
Hund : a
Katze : b
Kuh : z
Pferd : d
Wolf : e
Zebra : c

Absteigend hiesse der Befehl arsort($Arrayname); -mit 'r' wie rückwärts

Array nach Index (key) aufsteigend sortieren

ksort($Arrayname);

... und erneut ausgeben, die Reihenfolge hat wieder geändert!

a = Hund
b = Katze
c = Zebra
d = Pferd
e = Wolf
f = Esel
z = Kuh

Absteigend hiesse der Befehl krsort($Arrayname); -mit 'r'

2 Arrays miteinander vermengen

Ich habe zwei Arrays,der erste Array heist $Tier (siehe oben):

Und ich habe noch diesem neuen, zweiten Array $Viecher:

Mit Plus-Zeichen

Werden durch das Pluszeichen zwei Arrays zusammengesetzt, dann wird der vom zweiten Array übergebene Eintrag gelöscht, wenn der Index (nicht der Wert) im ersten Array schon vorhanden ist.
Der erste Index überlebt!

$zusammengesetzt = $Tier + $Viecher;
asort($zusammengesetzt);

print_r($zusammengesetzt);

array_merge()

Werden durch array_merge zwei assoziative Arrays in einen verwandelt, dann überschreibt der als zweiter Array übergebene den ersten dort, wo der Index (nicht der Wert) der Selbe ist.
Der zweite Index killt!

Würden hingegen durch array_merge zwei nummerische Arrays in einen verwandelt, dann würd der zweite Array an den ersten angehängt (hier ohne Beispiel).

$schmelz = array_merge($Tier,$Viecher);
asort($schmelz);

print_r($schmelz);

Wenn ich die beiden Arrays $Tiere und $Tier miteinander durch array_merge() vermenge, erhalte ich im Array $Tiermenge viele doppelte Einträge, da kein Index doppelt war:

Doppelte Werte löschen

array_unique ()

In einem Array werden alle doppelten Werte gelöscht. Der erste der doppelten Werte behält dabei seinen Index, der zweite wird gelöscht.

Check den Code.