Array

Sortieren

`sort()` `rsort()`

Sortiert ein Array nach den Werten. Zuordnung von Schlüssel und Wert bleibt nicht erhalten,

Danger:

Ein assoziatives Array wird in numerisch indiziertes Array umgewandelt.
key-value Zuordnung bleibt nicht erhalten!

sort()
- sortiert aufsteigend
rsort()
- sortiert absteigend

$var = array("c", "b", "a");
sort($var);
print_r($var);

$var = array("a", "b", "c");
rsort($var);
print_r($var);

`asort()` `arsort()`

Sortierung nach den Werten (value) des Array

Info:

key-value Zuordnung bleibt erhalten, auch bei assoziativen Arrays

Aufsteigende Sortierung

$age = array("Peter" => "43", "Joe" => "35");

echo "Vor Sortierung: ";
echo print_r($age);

echo "<hr> Nach Sortierung: ";
asort($age);
print_r($age);

Absteigende Sortierung

$age = array("Joe" => "35", "Peter" => "43");

echo "Vor Sortierung: ";
echo print_r($age);

echo "<hr> Nach Sortierung: ";
arsort($age);
print_r($age);

`ksort()` `krsort()`

Sortierung nach den Schlüsseln (key) des Array

Info:

key-value Zuordnung bleibt erhalten, auch bei assoziativen Arrays

Aufsteigende Sortierung

$age = array("Peter" => "43", "Joe" => "35");

echo "Vor Sortierung: ";
echo print_r($age);

echo "<hr> Nach Sortierung: ";
ksort($age);
print_r($age);

Absteigende Sortierung

$age = array("Joe" => "35", "Peter" => "43");

echo "Vor Sortierung: ";
echo print_r($age);

echo "<hr> Nach Sortierung: ";
krsort($age);
print_r($age);

`array_merge()`

Verbindet mehrere Arrays zu einem Array.

Danger:

Assoziative Arrays: Bei gleichnamigen Indexnamen wird der Wert des ersten Array überschrieben

  $a1 = array("a" => 
                      "red", 
                              "b" => "green");
  $a2 = array("c" => "blue", 
                              "b" => "yellow");
  print_r(array_merge($a1, $a2));

  // -> Array ( [a] => red 
  //                        [b] => yellow 
  //                                       [c] => blue )

Numerische Arrays: Index wird neu vergeben und hochgezählt

$a = array(3 => "red", 4 => "green");
print_r(array_merge($a));

// -> Array ( [0] => red [1] => green )

  $a1 = array("red", "green");
  $a2 = array("blue", "yellow");
  print_r(array_merge($a1, $a2));

  // -> Array ( [0] => red [1] => green [2] => blue [3] => yellow )

`array_pop()`

Löscht das letzte Element des Array

Liefert NULL wenn kein Array vorliegt oder Array leer ist

  $a = array("red", "green", "blue");
  array_pop($a);
  print_r($a);

`array_push()`

Erweitert Array um Element(e), fügt diese ans Ende an

$a = array("red", "green");
array_push($a, "blue", "yellow");
print_r($a);

`array_rand()`

Syntax: array_rand(array, number)

zufällige Ausgabe von Arrayelementen
number bestimmt die Anzahl der Rückgabe (default = 1 Element)

  $a = array("Peter" => "35", "Ben" => "37", "Joe" => "43");

  print_r(array_rand($a));
// random -> 1 Element

  $a = array("Peter" => "35", "Ben" => "37", "Joe" => "43");

  print_r(array_rand($a, 2));
  // random -> 2 Elemente

`array_reverse()`

Gibt die Elemente des Arrays absteigend aus, das Array wird nicht verändert

$a = array("a" => "Volvo", "b" => "BMW", "c" => "Toyota");
print_r(array_reverse($a));

`array_search()`

Sucht nach einem Wert im Array, gibt den Index zurück

$a=array("a"=>"red","b"=>"green","c"=>"blue");
echo array_search("red",$a)

optional mit (strict) true

(default ist false)

liefert nur key deren Werte dem gesuchten Wert des Datentyps entsprechen

  $a = array("a" => "10", "b" => 10);
echo array_search(
                  "10",
                  $a,
                  true
);

// -> a

  $a = array("a" => "10", "b" => 10);
  echo array_search(
                    10,
                    $a,
                    true
  );

  // -> b

`array_shift()`

Entfernt das erste Element, Arraygröße wird verkleinert.

Bei numerischen Index werden die key neu vergeben

$a = array(0 => "red", 1 => "green", 2 => "blue");
echo "Vorher: ";
print_r($a);
echo array_shift($a);
echo "<hr>Nachher: ";
print_r($a);

// Array ( [0] => green [1] => blue )

bei assoziativen Index werden die key beibehalten

$a = array("a" => "red", "b" => "green", "c" => "blue");
echo "Vorher: ";
print_r($a);
echo array_shift($a);
echo "<hr>Nachher: ";
print_r($a);

// $a=array("a"=>"red","b"=>"green","c"=>"blue");

`array_slice()`

Ausgabe eines Teilbereichs des Array, Array wird nicht geändert

Syntax: array_slice(array, start, length, preserve)

Zeige alle Elemente ab Index 2

$a = array("red", "green", "blue", "yellow", "brown");
print_r(array_slice($a, 2));

// Array ( [0] => blue [1] => yellow [2] => brown )

Zeige nur Elemente 1 und 2 an

$a = array("red", "green", "blue", "yellow", "brown");
print_r(array_slice($a, 1, 2));

// Array ( [0] => green [1] => blue )

Zeige vom vorletzten Element alle an

$a = array("red", "green", "blue", "yellow", "brown");
print_r(array_slice($a, -2,));

// Array ( [0] => yellow [1] => brown )

Zeige nur das vorletzte Element an

$a = array("red", "green", "blue", "yellow", "brown");
print_r(array_slice($a, -2, 1));

// Array ( [0] => yellow )

preserve true indexiert nicht neu, sondern zeigt den Index des Arrays an

$a = array("red", "green", "blue", "yellow", "brown");
print_r(array_slice($a, 1, 2, true));
// Array ( [1] => green [2] => blue )

default ist false

$a = array("red", "green", "blue", "yellow", "brown");
print_r(array_slice($a, 1, 2, false));
// Array ( [0] => green [1] => blue )

bei assoziativen array werden die Index nicht verändert, unabhängig von preserve

$a = array("a" => "red", "b" => "green", 
           "c" => "blue", "d" => "yellow", "e" => "brown");

// Preserve parameter set to true:
print_r(array_slice($a, 1, 2, true));
// Array ( [b] => green [c] => blue )

// Preserve parameter set to false (default):
print_r(array_slice($a, 1, 2, false));
// Array ( [b] => green [c] => blue )

`array_sum()`

Summiert die Werte des Array. Rückgabe als int oder float

$a = array(5, 15, 25);
echo array_sum($a);

// -> 45

$a = array("a" => 52.2, "b" => 13.7, "c" => 0.9);
echo array_sum($a);

// -> 66.8

`array_unique()`

Entfernt doppelte Einträge, Array wird nicht modifiziert

$a = array("a" => "red", "b" => "green", "c" => "red");
print_r(array_unique($a));

// Array ( [a] => red [b] => green )

`array_unshift()`

Fügt neue Elemente am Anfang ein, vorhandene Elemente werden nach hinten geschoben.

Danger:

Es wird neu indexiert!

  $a = array("a" => "red", "b" => "green");
  array_unshift($a, "blue");
  print_r($a);

  // -> Array ( [0] => blue [a] => red [b] => green )

Rückgabe ist Anzahl der neuen Elemente

$a=array("a"=>"red","b"=>"green");
echo array_unshift($a,"blue");

// -> 3

`compact()`

Erstellt aus den Werten von Variablen (ohne $!) ein assoziatives Array.

  $firstname = "Peter";
  $lastname = "Griffin";
  $age = "41";

  print_r(compact("firstname", "lastname", "age"));
  // -> Array ( [firstname] => Peter [lastname] => Griffin [age] => 41 )

Es können auch nummerierte Arrays mit Variablennamen übergeben werden

$name = array("firstname", "lastname");
print_r($name);
// -> Array ( [0] => firstname [1] => lastname )

$firstname = "Peter";
$lastname = "Griffin";
$age = "41";

echo "<br>";
print_r(compact(
                $name, 
                "age"));
// -> Array ( [firstname] => Peter [lastname] => Griffin [age] => 41 )

Reihenfolge der assoziativen Indexe kann in den Parametern der Funktion angegeben werden

$name = array("firstname", "lastname");
print_r($name);
// -> Array ( [0] => firstname [1] => lastname )

$firstname = "Peter";
$lastname = "Griffin";
$age = "41";

echo "<br>";
print_r(compact(
                "age", 
                $name));
// -> Array ( [age] => 41 [firstname] => Peter [lastname] => Griffin )

Wird der Name des Array als string übergeben wird ein verschachteltes Array erzeugt

$name = array("firstname", "lastname");
print_r($name);
// -> Array ( [0] => firstname [1] => lastname )

$firstname = "Peter";
$lastname = "Griffin";
$age = "41";

echo "<br>";
print_r(compact(
                "age", 
                "name"));
// -> Array ( [age] => 41 [name] => Array ( [0] => firstname [1] => lastname ) )

`count()` `sizeof()`

Gibt die Anzahl der Elemente des Array an

$cars = array("Volvo", "BMW", "Toyota");
echo count($cars);

alternativ

$cars = array("Volvo", "BMW", "Toyota");
echo sizeof($cars);

`in_array()`

Syntax: in_array(search, array, type)

Suche nach einem Schlüsselwort

  $arr = array("Peter", 23);

  echo var_dump(in_array("23", $arr));
  // -> true

Mit der Option type = true muss auch der Datentyp übereinstimmen

$arr = array("Peter", 23);

echo var_dump(in_array(
                        "23", 
                              $arr, true)) . "<br>";
// -> false

echo var_dump(in_array(
                         23, 
                              $arr, true));
// -> bool(true)

`min()` / `max()`

Gibt das Minimum / Maximum der Werte eines Array aus

  echo (min(array(44, 16, 81, 12)));
  // -> 12
  echo (max(array(44, 16, 81, 12)));
  // -> 81

`range()`

Syntax: range(low, high, step)

Erzeugt ein Array vom Startwert bis Endwert

  $number = range(0, 5);
  print_r($number);

  // -> Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 )

Mit step kann optional die Schrittweite angegeben werden

$number = range(0, 50, 10);
print_r($number);

// -> Array ( [0] => 0 [1] => 10 [2] => 20 [3] => 30 [4] => 40 [5] => 50 )

`shuffle()`

Werte des Array werden zufällig durchmischt

Danger:

Assoziative Arrays werden in numerische Index gewandelt

$my_array = array("a" => "red", "b" => "green", "c" => "blue");

shuffle($my_array);
print_r($my_array);

// zufällige Sortierung!
// Array ( [0] => blue [1] => green [2] => red ) 

  $my_array = array("red", "green", "blue");

  shuffle($my_array);
  print_r($my_array);
  // zufällige Sortierung!
  // Array ( [0] => red [1] => green [2] => blue )

Schleifen

`foreach()`

indexiertes Array aufsteigend sortieren

$colors = array("red", "green", "blue");

foreach ($colors as $key => $value) {
  echo "$key = $value <br>";
}

/* 
0 = red
1 = green
2 = blue
*/

indexiertes Array absteigend sortieren

Info:

Option preserve_key muss auf true gesetzt werden, ansonsten werden die Index nicht beibehalten!

$colors = array("red", "green", "blue");

foreach (array_reverse($colors, 
                                true) 
                                      as $key => $value) {
  echo "$key = $value <br>";
}

/* 
0 = red
1 = green
2 = blue
*/

assoziative Array

`foreach()`

assoziatives Array aufsteigend sortieren

$age = array("Peter" => "35", "Ben" => "37", "Joe" => "43");

foreach ($age as $key => $value) {
  echo "$key = $value<br>";
}

/* 
Peter = 35
Ben = 37
Joe = 43
*/

assoziatives Array absteigend sortieren

$age = array("Peter" => "35", "Ben" => "37", "Joe" => "43");

foreach (array_reverse($age) as $key => $value) {
  echo "$key = $value<br>";
}

/* 
Joe = 43
Ben = 37
Peter = 35
*/

`while()`

assoziatives Array aufsteigend iterieren

  $age = array("Peter" => "35", "Ben" => "37", "Joe" => "43");

  $keys = array_keys($age);
  $values = array_values($age);

  $i = 0;
  while ($i < count($age)) {
    echo $keys[$i] . ": " . $values[$i] . "<br>";
    $i++;
  }

assoziatives Array absteigend iterieren

$age = array("Peter" => "35", "Ben" => "37", "Joe" => "43");

$keys = array_keys($age);
$values = array_values($age);

$i = count($age) - 1;
while ($i >= 0) {
  echo $keys[$i] . ": " . $values[$i] . "<br>";
  $i--;
}

`for()`

array_keys()

Syntax : array_keys(array, search_value, strict)

Gibt Schlüssel des Arrays zurück.

search_value liefert nur die gesuchten key

assoziatives Array aufsteigend iterieren

$age = array("Peter" => "35", "Ben" => "37", "Joe" => "43");

$keys = array_keys($age);
for ($i = 0; $i < count($keys); $i++) {
  $key = $keys[$i];
  $value = $age[$key];
  echo "$key: $value <br>";
}

assoziatives Array absteigend iterieren

$age = array("Peter" => "35", "Ben" => "37", "Joe" => "43");

$keys = array_keys($age);
for ($i = count($keys) - 1; $i >= 0; $i--) {
  $key = $keys[$i];
  $value = $age[$key];
  echo "$key: $value <br>";
}

iterieren ohne Index

next()
prev()
end()
reset()
current()

String

`implode()`

Syntax: implode(separator,array)

Konvertiert array zu string

separator als trennzeichen zwischen den Elementen angeben

$arr = array('Hello', 'World!', 'Beautiful', 'Day!');
echo implode(" ", $arr) . "<br>";
// -> Hello World! Beautiful Day!

echo implode("_x_", $arr);
// -> Hello_x_World!_x_Beautiful_x_Day!

Array

Sortieren​

sort() rsort()​

asort() arsort()​

ksort() krsort()​

array_merge()​

array_pop()​

array_push()​

array_rand()​

array_reverse()​

array_search()​

array_shift()​

array_slice()​

array_sum()​

array_unique()​

array_unshift()​

compact()​

count() sizeof()​

in_array()​

min() / max()​

range()​

shuffle()​

Schleifen​

foreach()​

assoziative Array​

foreach()​

while()​

for()​

iterieren ohne Index​

String​

implode()​

Sortieren

`sort()` `rsort()`

`asort()` `arsort()`

`ksort()` `krsort()`

`array_merge()`

`array_pop()`

`array_push()`

`array_rand()`

`array_reverse()`

`array_search()`

`array_shift()`

`array_slice()`

`array_sum()`

`array_unique()`

`array_unshift()`

`compact()`

`count()` `sizeof()`

`in_array()`

`min()` / `max()`

`range()`

`shuffle()`

Schleifen

`foreach()`

assoziative Array

`foreach()`

`while()`

`for()`

iterieren ohne Index

String

`implode()`