quakenet:#php Tutorial

1. Was sind Arrays?

Das Thema Array ist bezüglich PHP sehr wichtig. Ohne Arrays kommt ihr nicht weit, denn dann scheitert ihr schon am Auslesen der Formular- oder URL-Daten. Fast alle Daten sind in Arrays gespeichert. Arrays sind fast so wichtig wie die Tatsache, dass jede Anweisung mit einem Semikolon abgeschlossen wird.

Ein Array ist eine Gruppierung von Werten. Wir können in einem Array mehrere Daten speichern. Dies können wir mit unseren momentanen Wissen nur mit Hilfe eines Strings, wo wir die Daten mit einen Trennzeichen, z.B. mit einem Komma, trennen.

<?php
    $daten = "Hans,Klaus,Max,Heinz";
?>

Dies hat aber eine Menge Nachteile. Wir können nicht so einfach einen Namen löschen, bearbeiten oder einfügen. Hinzufügen würde ja noch gehen, da würden wir $daten .= ",Müller"; machen. Aber wir können diese Daten nicht so einfach sortieren. Und wenn statt Namen dort Zahlen ständen, könnten wir diese nicht so einfach addieren, oder die größte bzw. kleinste Zahl bestimmen. Dies ist alles nicht möglich, bzw. nicht einfach zu programmieren. Wenn wir diese Daten aber in einem Array speichern, können wir die oben genannten Sachen recht einfach durchführen.

2. Erstellen eines Arrays

Mit der Funktion array können wir ein Array erstellen und es in eine Variable schreiben. Als Parameter der Funktion array() geben wir die Werte an die wir in dem Array speichern wollen. Jeder Wert ist ein Parameter. Die Funktion array kann also beliebig viele Parameter haben. Wenn wir unsere Namen darin speichern wollen müssten wir das wie folgt tun:

<?php
    $daten = array("Hans", "Klaus", "Max", "Heinz");
?>

Dieses Array hat momentan 4 Arrayelemente, die Strings Hans, Klaus, Max und Heinz.

3. Ausgeben von Arrays

Auf die einzelnen Elemente des Arrays greifen wir mit $variablenname[nummer] zu. Für nummer setzen wir eine Zahl von 0-3 ein. Wir setzten keine Zahl von 1-4 ein. Denn PHP, sowie viele andere Programmiersprachen, fangen bei 0 an zu zählen. Da diese Array, was wir erstellt hat 4 Elemente hat, müssen wir also von 0-3 zählen. Allgemein gesagt müssen wir von 0 bis Anzahl der Elemente - 1 zählen.

In unserem Beispiel greifen wir auf die Elemente wie folgt zu.

<?php
    $daten = array("Hans", "Klaus", "Max", "Heinz");

    echo "Das 1. Element hat den Wert ".$daten[0]."<br />\n";
    echo "Das 3. Element hat den Wert ".$daten[2]."<br />\n";

?>

Dies gibt folgendes aus.

Das 1. Element hat den Wert Hans
Das 3. Element hat den Wert Max
        

Wenn wir statt $variablenname[nummer] nur $variablenname schreiben würde das Wort Array ausgegeben werden. Dies sagt uns dass die Variable ein Array ist und wir versucht haben diese falsch auszugeben. Ein Array kann man nicht mit echo $name; ausgeben, wir können nur Arrayelemente mit echo $name[zahl]; ausgeben. Die Ausgabe aller Array-Elemente können wir mit einer for-Schleife verwirklichen.

<?php
    $daten = array("Hans", "Klaus", "Max", "Heinz");

    for($i=0; $i<4; $i++) {
        echo "Das ".($i+1).". Element hat den Wert ".$daten[$i]."<br />\n";
    }
?>

Einmal sehen wir das ($i+1). Würden wir nur $i schreiben, würde an dieser Stelle die Zahlen von 0 bis 3 ausgegeben werden. Doch wir Menschen zählen von 1 an, müssen also zur Laufvariable 1 addieren, damit dann da 1., 2. usw. steht. Am Ende sehen wir den Variablennamen $daten und das $i in eckigen Klammern dahinter. Die Variable $i hat nun nacheinander die Werte 0, 1, 2 und 3. Und mit diesen Zahlen können wir dann auf die Arrayelemente zugreifen, indem wir dann $daten[0], $daten[1], $daten[2] und $daten[3] ausgeben. Wir erhalten mit dem Code folgende Ausgabe.

Das 1. Element hat den Wert Hans
Das 2. Element hat den Wert Klaus
Das 3. Element hat den Wert Max
Das 4. Element hat den Wert Heinz
        

4. Arrayelement bearbeiten

Da wir mit $name[nummer] auf ein Arrayelement zugreifen können, können wir auch damit den Wert des Arrayelements überschreiben. Wir weisen einfach einen Wert, wie bei jeder anderen Variable auch, zu.

<?php
    $daten = array("Hans", "Klaus", "Max", "Heinz");

    echo "Im ersten Arrayelement steht ".$daten[0]."<br />\n";

    $daten[0] = "Gustav";

    echo "Jetzt steht da ".$daten[0]."<br />\n";
?>

Dies erzeugt folgende Ausgabe.

Im ersten Arrayelement steht Hans
Jetzt steht da Gustav
        

Der alte Wert wurde überschrieben. Man hätte natürlich mit .= einen weiteren String an das 1. Arrayelement anhängen können. Man kann damit arbeiten als wäre es eine Variable für sich.

5. Arrayelement hinzufügen

Um ein neues Arrayelement hinzufügen, versuchen wir einfach in die Variable $name[] einen Wert zu speichern. Es wird dann ein neues Arrayelement hintendrangehängt, mit dem Wert der Zuweisung.

<?php                 
    $name = "Meier";
    $daten = array("Hans", "Klaus", "Max", "Heinz");

    $daten[] = "Gustav";
    $daten[] = "Günter";
    $daten[] = $name; // Auch die Werten von Variablen können wir
                      // in einem Array hinzufügen

?>

Dieses Array hat danach nun 7 Elemente. Einmal die 4 Elemente die in der Funktion array stehen, dann die 2 String und dann der Wert aus der Variable $name.

Wenn sie versuchen ein Arrayelement in ein Array hinzuzufügen, das es noch gar nicht gibt, wird ein neues Arrayelement erstellt. Wenn sie aber versuchen ein Arrayelement in eine Variable einzuzufügen, die kein Array ist, z.B. einen String, kommt eine Fehlermeldung.

<?php
    $var = "bla"; // Ein String
    $var[] = "blo";  // wird nicht gehen
?>

6. var_dump/print_r und Array

Mit var_dump können wir uns den Inhalt einer Variable beschreiben lassen. Welcher Typ, wie groß und welcher Inhalt. var_dump können wir aber auch auf Arrays anwenden. Wir erhalten dann eine schöne Übersicht des Arrays.

<?php
    $daten = array("Hans", "Klaus", "Max", "Heinz");

    var_dump($daten);
?>

Wir erhalten folgende Ausgabe.

array(4) { [0]=> string(4) "Hans" [1]=> ...
        

Hier sollten wir uns lieber den Code im Quelltext des Browsers angucken. Dort sieht er schöner aus.

array(4) {
  [0]=>
  string(4) "Hans"
  [1]=>
  string(5) "Klaus"
  [2]=>
  string(3) "Max"
  [3]=>
  string(5) "Heinz"
}
        

Hier sehen wir, dass das Array 4 Elemente hat, es steht in Klammern hinter dem array. Wir sehen auch dass an der Stelle 0 der String "Hans" ist, der eine Länge von 4 hat. Diese Funktion eignet sich besonders bei der Fehlersuche, um man eben zu gucken was in welchem Array ist. Diese Funktion liefert uns aber etwas viel Informationen. Es gibt eine Funktion die etwas weniger Informationen über eine Variable ausgibt, es ist die Funktion print_r.

<?php
    $daten = array("Hans", "Klaus", "Max", "Heinz");

    print_r($daten);
?>

Da diese Funktion wie var_dump wieder sowas, auf den ersten Blick, unleserliches ausgibt öffnen wir wieder den Quelltext im Browser und sehen folgendes.

Array
(
    [0] => Hans
    [1] => Klaus
    [2] => Max
    [3] => Heinz
)
        

Und wir sehen sofort, an Stelle 0 steht Hans, an Stelle 1 steht Klaus, an Stelle 2 steht Max und an Stelle 3 steht Heinz. Dies ist auch eher die gebräuchlichere Funktion wenn man sich ein Array angucken möchte. Möchte man doch etwas mehr Informationen über eine Array haben, benutzt man wieder var_dump.

7. Löschen von Arrayelementen

Manchmal möchte man in seinem Programm ein Arrayelement löschen. Dabei ist jetzt nicht gemeint, dass wir das Element mit "" oder 0 füllen, sondern wirklich aus der Array löschen, dass man nicht mehr darauf zugreifen kann. Dafür gibt es die Funktion unset. Als Parameter geben wir das Element an, welches wir löschen wollen.

<?php
    $daten = array("Hans", "Klaus", "Max", "Heinz");

    echo "<pre>\n";
    print_r($daten);
    echo "</pre>\n";
    // Mit dem <pre> müssen wir nicht immer im
    // Quelltext des Browsers gucken, sondern sehen
    // das Ergebnis sofort als lesbare Form im Browser.

    unset($daten[3]); // Löschen des Eintrags "Heinz"

    echo "<pre>\n";
    print_r($daten);
    echo "</pre>\n";

?>

Dies erzeugt folgende Ausgabe

Array
(
    [0] => Hans
    [1] => Klaus
    [2] => Max
    [3] => Heinz
)


Array
(
    [0] => Hans
    [1] => Klaus
    [2] => Max
)
        

Beim 1. Aufruf von print_r hat das Array 4 Elemente. Beim 2. Aufruf hat das Array nur noch 3 Elemente. Der letzte Eintrag wurde rausgelöscht.

8. Arrays etwas tiefer betrachtet

Wir haben vorhin ein Arrayelement gelöscht, welches am Ende des Arrays stand. Doch was passiert wenn wir ein Element aus der Mitte eines Arrays löschen? Was passiert mit den anderen Elementen?

<?php
    $daten = array("Hans", "Klaus", "Max", "Heinz");

    echo "<pre>\n";
    print_r($daten);
    echo "</pre>\n";
    // Mit dem <pre> müssen wir nicht immer im
    // Quelltext des Browsers gucken, sondern sehen
    // das Ergebnis sofortals lesbare Form im Browser.

    unset($daten[1]); // Löschen des Eintrags "Klaus"

    echo "<pre>\n";
    print_r($daten);
    echo "</pre>\n";

?>

Und erhalten folgende Ausgabe.

Array
(
    [0] => Hans
    [1] => Klaus
    [2] => Max
    [3] => Heinz
)


Array
(
    [0] => Hans
    [2] => Max
    [3] => Heinz
)
        

Wie wir sehen haben wir wirklich das 2. Feld gelöscht, aber so sehr, dass da jetzt eine Lücke ist. Die anderen Arrayelemente sind nicht nachgerutscht. Aber warum oder eher warum nicht?

Eigentlich wisst ihr nur die halbe Wahrheit über Arrays, das wichtigste wisst ihr noch gar nicht. Ein Arrayelement besteht nicht nur aus einem Wert, sondern besteht aus einem Wert (value) und einem Schlüssel (key). Erst die Kombination aus beiden ergibt ein Arrayelement. Ein Array sieht dann grafisch so aus.

Abb.: Aufbau eines Arrays

Außerhalb schwirren die normale Variablen, wie wir es sonst kennen. Hier in der Mitte dargestellt ist unser Array, das beliebig viele Arrayelemente haben kann, von 0 bis der Speicher platzt. Jedes Arrayelement besteht aus einem Schlüssel und einem Wert. Den Schlüssel und den dazugehörigen Wert sehen wir bei print_r. Dort 'zeigt' der Schlüssel 0 auf den Wert Hans, Schlüssel 2 auf den Wert Max und der Schlüssel 3 auf den Wert Heinz. Und mit unset($daten[1]); haben wir gar nicht das 2. Arrayelement gelöscht, sondern nur das Arrayelement mit dem Schlüssel 1.

Eigentlich ist das ja scheisse, denn man kann ja jetzt keine for-schleife benutzen, da ja dann ein Arrayelement fehlt. Aber für Arrays gibt es noch ein extra Schleifentyp.

Wir wissen das wir mit $array[] ein neues Arrayelement hinzufügen können. Dabei wird der Schlüssel automatisch festgelegt, und zwar auf eine Zahl, die um 1 größer ist als die größte Zahl der vorhandenen Schlüssel. Wenn also im Array der größte Schlüssel 10 ist, bekommt ein neues Arrayelement den Schlüssel 11. Dabei ist es egal ob vorher noch Platz für eine andere Zahl war oder nicht.

Wenn wir ein Arrayelement mit einem bestimmten Schlüssel (auch index genannt) erstellen wollen, geben wir den Schlüssel bzw. den gewünschten Index direkt in den Klammern an.

<?php
    $array[1337] = "ich";
?>

Wenn es noch kein Array gibt, wird es neu erstellt. Wenn es bereits ein Arrayelement mit diesem Schlüssel/Index vorhanden ist, wird der Wert mit den aktuellen überschrieben. Diese Form, wo die Schlüssel nur aus Integer-Zahlen bestehen, heißt numerisches Array.

9. String als Index/Schlüssel

Im Moment kennen wir nur Integer-Zahlen als Schlüssel/Indizes (=Mehrzahl von Index). In PHP ist es auch möglich Strings als Schlüssel/Indizes zu nehmen.

<?php
    $array['string']="bla";

    echo "<pre>\n";
    print_r($array);
    echo "</pre>\n";
?>

Hier sieht man das der Stringindex hier mit ' und nicht wie üblich mit " gekennzeichnet wird. Das ' hat sich bei Stringindizes 'eingebürgert'. Mit ' kann man auch einen String kennzeichnen, unterscheidet sich aber etwas von der Funktionsweise von ". Weitere Informationen zu Strings gibt es im PHP-Manual Eintrag Strings / Zeichenketten.

Wir erhalten folgende Ausgabe

Array
(
    [string] => bla
)
        

Hier sehen wir, dass das Array genau 1 Element hat (es wurde ja neu erstellt) und das Element hat den Schlüssel/Index string und den Wert bla. Darauf können wir, wie mit nummerischen Indizes, mit $array['string'] zugreifen.

Ein Array kann natürlich mehrere Elemente mit Stringindex besitzen.

<?php
    $array['id'] = 1;
    $array['titel'] = "Meine erste News";
    $array['datum'] = "2002-10-10 10:11:50";
    $array['text']  = "Dies ist meine erste News.\n";
    $array['text'] .= "Na bin ich nicht toll?";
    $array['poster'] = "Müller";

    echo "<pre>\n";
    print_r($array);
    echo "</pre>\n";
?>

Und erhalten folgende Ausgabe.

Array
(
    [id] => 1
    [titel] => Meine erste News
    [datum] => 2002-10-10 10:11:50
    [text] => Dies ist meine erste News.
Na bin ich nicht toll?
    [poster] => Müller
)
        

Die einzelnen Elemente kann man nun innerhalb einer kleinen Newstabelle eintragen und ausgeben lassen.

Ein Array, bei dem die Indizes nur aus Strings bestehen, nennt man assoziatives Array. Ein Array, dessen Indizes Strings und Integer-Zahlen sind, hat keinen speziellen Namen. Nur Integer-Zahlen und Strings sind als Indizes zulässig. Bei andere Variablentypen wird versucht sie in einen Interger-Wert oder in einen String umzuwandeln.

10. Index bei array() schon definieren

Um mit array() ein Array zu erzeugen, wo man selber die Indizes bestimmen kann, muss man folgende Syntax benutzen.

<?php
    $array = array( key => value, key2 => value2, ...);
?>

Also z.B.

<?php
    $array = array( -20 => "hi", "bla" => "du");

    echo "<pre>\n";
    print_r($array);
    echo "</pre>\n";
?>

Dies ergibt folgende Ausgabe.

Array
(
    [-20] => hi
    [bla] => du
)
        

Wenn man bei einem Parameter von array() den Schlüssel wegläßt wird, so wie bei $array[], für den Schlüssel eine Integer-Zahl eingesetzt, uns zwar die um eins größer ist als die momentan größte Schlüsselzahl im Array. Wenn die größte Schlüsselzahl negativ ist, wir als neuer Index die Zahl 0 genommen.

<?php
    $array = array( 5 => "hi", "ich");

    echo "<pre>\n";
    print_r($array);
    echo "</pre>\n";

    $array = array( -20 => "hi", "du");

    echo "<pre>\n";
    print_r($array);
    echo "</pre>\n";
?>

Dies gibt folgendes aus.

Array
(
    [5] => hi
    [6] => ich
)
Array
(
    [-20] => hi
    [0] => du
)
        

11. Die foreach-Schleife

Für Arrays gibt es in PHP ein extra Schleifentyp foreach. In dieser Schleife wird das komplette Array von oben bis unten durchgegangen und nacheinander der aktuelle Wert (und vielleicht auch der Schlüssel) vom Element in eine Zwischenvariable gespeichert. Diese Variable kann dann innerhalb der Schleife benutzt werden, z.B. zum Ausgeben.

Der Aufbau der foreach-Schleife ist wie folgt.

<?php
    foreach (das_array as zwischenvariable) {
        // PHP-Code
    }

    // bzw.

    foreach (das_array as zwischenvariable)
        ein_befehl();
?>

An der Stelle das_array schreiben wir die Variable des Arrays hin welches wir durchgehen wollen. An der Stelle nach dem as, da wo jetzt zwischenvariable steht, kommt dann eine Variable hin, wo dann nacheinander jeder Wert von jedem Arrayelement drinsteht. Dies konnte dann so aussehen.

<?php
    $array = array(1,30,35,74,14,63);

    foreach ($array as $wert) {
        // PHP-Code
    }
?>

Beim 1. Schleifendurchlauf hat $wert den Wert 1, beim 2. Durchlauf den Wert 30, beim 3. den Wert 35 usw. .

<?php
    $array = array(1,30,35,74,14,63);

    foreach ($array as $wert) {
        echo "Der Wert ist ".$wert."<br />\n";
    }
?>

Diese foreach-Schleife gibt folgendes aus.

Der Wert ist 1
Der Wert ist 30
Der Wert ist 35
Der Wert ist 74
Der Wert ist 14
Der Wert ist 63
        

Die Variable $wert ist nicht mit dem momentanen Arrayelement gekoppelt. Eine Zuweisung im Schleifen-Teil auf die Variable $wert wirkt sich nicht auf das momentane Arrayelement aus. Wenn man in der Schleife den Inhalt eines Arrayelement verändern will muss man wieder die übliche Schreibweise $array[index] verwenden.

12. foreach-Schleife mit Wert und Schlüssel

Es gibt auch die Möglichkeit bei jedem Schleifendurchlauf nicht nur den aktuellen Wert des Elements in eine Variable zu speichern, sondern auch den aktuellen Schlüssel des Elements in einer Variable zu speichern. Die Syntax ist so ähnlich wie bei der Funktion array.

<?php
    foreach (das_array as keyvar => wertvar) {
        // PHP-Code
    }

    // bzw.

    foreach (das_array as keyvar => wertvar)
        ein_befehl();
?>

An der Stelle keyvar kommt die Variable, in der der Schlüssel gespeichert wird, an die Stelle von wertvar kommt die Variable, in der dann der Wert des Elements gespeichert wird.

<?php
    $array['id'] = 5;
    $array['name'] = "Günter";
    $array['alter'] = 14;
    $array[3] = "bli";
    $array['pi'] = 3.1415;

    foreach($array as $key => $wert)
    {
        echo "Das Element \"".$key."\" hat den Wert \"".$wert."\".<br />\n";
    }
?>

Dies erzeugt folgende Ausgabe.

Das Element "id" hat den Wert "5".
Das Element "name" hat den Wert "Günter".
Das Element "alter" hat den Wert "14".
Das Element "3" hat den Wert "bli".
Das Element "pi" hat den Wert "3.1415".
        

$key und $wert haben nach und nach die entsprechenden Werte aus den Arrayelementen. Mit den $key hat man dann die Möglichkeit, in der Schleife den Inhalt des aktuellen Arrayelements zu bearbeiten.

<?php
    $array[4] = "Hi all";
    $array['bla'] = "Na wie gehts?";
    $array[] = "Wieder ein String";
    $array[] = "und noch einer";
    $array['xyz'] = "das ist der letzte";
                            
    /** Ausgabe des Arrays **/
    echo "<pre>\n";
    print_r($array);
    echo "</pre>\n";

    foreach ($array as $key => $wert) {
        $array[$key] = strtoupper($wert);
        // $array[$key] = strtoupper($array[$key]); wäre auch möglich
    }

    /** Ausgabe des Arrays **/
    echo "<pre>\n";
    print_r($array);
    echo "</pre>\n";
?>

Dies erzeugt folgende Ausgabe

Array
(
    [4] => Hi all
    [bla] => Na wie gehts?
    [5] => Wieder ein String
    [6] => und noch einer
    [xyz] => das ist der letzte
)


Array
(
    [4] => HI ALL
    [bla] => NA WIE GEHTS?
    [5] => WIEDER EIN STRING
    [6] => UND NOCH EINER
    [xyz] => DAS IST DER LETZTE
)
        

Bei jedem Schleifendurchlauf können wir mit den Schlüssel $key auf das aktuelle Arrayelement zugreifen. Hier verändern wir das Arrayelement so, dass alle Buchstaben großgeschrieben werden. Die Funktion strtoupper erwartet einen String als Parameter und liefert diesen String in Großbuchstaben zurück. Dieser Rückgabewert wird dann in $array[$key] gespeichert. Die print_r-Aufrufe zeigen auch dass die Werte des Array bearbeitet wurden.

13. Array in Array

In einem Element hatten wir nur so sachen wie Integer-Werte oder Strings. Es ist aber auch möglich das in einem Element noch ein Array ist. Dies könnte dann so aussehen.

<?php
    $array['id'] = 5;
    $array['text'] = "Mein Text";
    $array['comments'] = array(5,4,6,23);
    $array['autor'] = "ich";

    echo "<pre>\n";
    print_r($array);
    echo "</pre>\n";
?>

Dies gibt folgendes aus.

Array
(
    [id] => 5
    [text] => Mein Text
    [comments] => Array
        (
            [0] => 5
            [1] => 4
            [2] => 6
            [3] => 23
        )

    [autor] => ich
)
        

Im Element mit dem Schlüssel comments sehen wir, dass dort keine Zahl und kein String steht, sondern ein weiteres Array vorhanden ist, also ein Array im Array. Diese Array enthält in diesem Beispiel ganz normal Zahlen, kann aber auch wieder Arrays haben. Solche Arrays, die Arrays enthalten, nennt man verschachtelte Arrays.

Um ein Element eines Arrays zu verändern, welches seinerseits bereits in einem Array ist, müssen sie folgende Schreibweise benutzen.

<?php
    $array['id'] = 5;
    $array['comments'][] = "wert";  // neues Element erstellen
    $array['comments'][4] = "wert"; // bearbeiten des Elements
    unset($array['comments'][20]);  // löschen eines Elements
?>

Man ersetzt einfach das $array durch $array[index] um auf dieses innere Array zuzugreifen. Wir können auch diesen Zugriff in einer foreach schleife Benutzen.

<?php
    foreach ($array['comments'] as $key => $element) {
        echo "In '".$key."' steht '".$element."'<br />\n";
    }
?>

Wieviele Arrays sie in Arrays packen ist eigentlich nur durch den Speicher begrenzt, wenn sie aber 3 oder mehr Ebenen haben, sollten sie sich Gedanken über ihre Programmierweise machen.

Fragen zum aktuellen Thema

1. Welche Methoden gibt es ein Array zu bearbeiten?
2. Schreiben sie ein Script was die Zahlen 1-10 in ein Array schreibt

Welche Methoden gibt es ein Array zu bearbeiten?

Um ein Array zu bearbeiten, in welcher weise auch immer, gibt es eine Menge Methoden.

• <?php
      $array[] = "wert";
  ?>

  Dieser Befehl fügt an dem Array ein neues Element hinzu. Der Index ist um eins größer als der momentan größte Integer-Index. Ist kein Integer-Index vorhanden, wird 0 als Index für das neue Element genommen.

• <?php
      $array[key] = "wert";
  ?>

  Dieser Befehl bearbeitet das Arrayelement mit dem Index key entsprechend der Zuweisung. Ist kein Element mit diesem Index vorhanden wird ein neues Element mit diesem Index erstellt.

• <?php
      unset($array[key]);
  ?>

  Dieser Befehl löscht das Arrayelement mit dem Index key aus dem Array.

Schreiben sie ein Script was die Zahlen 1-10 in ein Array schreibt

Dies ist nur eine Lösung von vielen. Sie muss nicht mit eurem Code übereinstimmen.

<?php
   $array = array(); // ein leeres Array erzeugen

   for ($i=1; $i<=10; $i++) {
       $array[] = $i;
   }

   //print_r($array); // würde die Daten ausgeben.
?>

Hier kann man natürlich die Funktion range benutzen, die ist genau dafür geschaffen.