Typen und Funktionen

Frage: Welche Variablenarten gibt es in PHP und wie greife ich auf sie zu?

define(NAME, Wert); 

definiert eine Konstante. Diese Konstante ist überall gültig, also nicht nur im globalen Namensraum, sondern auch in Klassen und in Funktionen.

Eine globale Variable definiert man implizit durch ihre Benutzung innerhalb des globalen Namensraumes, also einfach durch

$a = 10; 

außerhalb jeder Klasse oder Funktion.

PHP unterhält einige Arrays, die es automatisch mit Werten befüllt. Diese Arrays sind global, und sie sind anders als normale globale Variablen automatisch auch in allen Funktionen und in Klassen sichtbar, ohne dass sie mit der Anweisung global importiert werden müssen.

Es sind dies die Felder $_GET (Get-Parameter des Scriptes), $_POST (Post-Parameter des Scriptes), $_COOKIE (Cookie-Parameter des Scriptes), $_SERVER (Serverdefinierte Variablen, CGI-Umgebung), $_ENV (Umgebungsvariablen), $_REQUEST , $_FILES und $_SESSION sowie $GLOBALS (ohne führenden Unterstrich, alle globalen Variablen).

In PHP hat jede Funktion ihren separaten Namensraum. In diesem Namensraum existieren nur diejenigen Variablen, die als Formalparameter der Funktion in die Funktion importiert worden sind oder die innerhalb der Funktion definiert worden sind. Diese Variablen haben die Lebensdauer des Funktionsaufrufes, d.h. sie verlieren beim Verlassen der Funktion ihren Wert.

Es ist möglich, in den Namensraum einer Funktion weitere Variablen hineinzuimportieren. Dies geschieht mit Hilfe der Anweisung global .

Beispiel:

function testfunc($para1) {
  global $glob1;

  $loc1 = 10;
  $glob1 = $glob1 + 1;

  return;
} 

Diese Funktion hat zunächst einmal die Variablen $para1 und $loc1 als Parameter bzw. als lokale Variable definiert. Diese Variablen verlieren mit der schließenden Klammer "}" ihren Wert. Außerdem wird die Variable $glob1 in den Namensraum der Funktion importiert. Der Wert von $glob1 ist auch außerhalb von testfunc() sichtbar und $glob1 bleibt für die gesamte Lebensdauer des Programmes bestehen.

Weiterhin kann man innerhalb einer Funktion noch lokale Variablen definieren, die nur innerhalb der Funktion sichtbar sind, deren Wert jedoch nach dem Ende der Funktion erhalten bleibt und bei einem erneuten Funktionsaufruf erneut sichtbar wird. Dies erfolgt mit Hilfe der Anweisung static .

function testfunc2($para1) {
  global $glob1;
  static $stat1 = 0;

  $loc1 = 10;
  $glob1 = $glob1 + 1;
  $stat1 = $stat1 + 1;

  printf("Die Funktion testfunc2() wurde %s mal aufgerufen.\n",
    $stat1);
} 

In diesem Beispiel ist die Anweisung static $stat1 dazu gekommen, die die Variable $stat1 als lokale, aber langlebige Variable in testfunc2() definiert und zur Vermeidung einer Warnung mit 0 initialisiert. Der Wert von $stat1 bleibt über einen einzelnen Funktionsaufruf erhalten. $stat1 zählt also im Beispiel oben die Anzahl der Aufrufe von testfunc2() .

PHP definiert die superglobale Variable $GLOBALS[] vom Typ Array/Hash. Es handelt sich um einen Namen fuer die globale Symboltabelle des Interpreters. Der Name ist in allen Namensräumen sichtbar. Entsprechend ist das Konstrukt

function testfunc3() {
  global $glob1;

  $glob1 = $glob1 + 1;

  return;
} 

gleichbedeutend mit

function testfunc3b() {
  $GLOBALS["glob1"] = $GLOBALS["glob1"] + 1;

  return;
} 

Die dritte Sorte Namensräume, die in PHP existiert, sind objects . Eine Klasse wird vereinbart mit der Anweisung

class MyClass {
  var $a;
  var $b;

  function c() {
    print("Der Wert von a ist %s\n", $this->a)
    $this->b = $this->b + 1;
    print("Der Wert von b ist %s\n", $this->b);
  }

  function MyClass() {
    $this->a = 10;
    $this->b = 0;
  }
} 

Nach dieser Definition ist KEINE Variable belegt, aber es existiert ein Bauplan fuer MyClass-Variablen. MyClass ist ein Typ, so wie integer, float oder string Typen in PHP sind. Mit Hilfe der Anweisung "new" kann man sich Variablen nach diesem Bauplan erstellen lassen. "new" ist also eine Fabrik, der man einen Bauplan mitgibt und die nach diesem Plan Variablen herstellt.

$o = new MyClass; 

Den Bauplan einer Variablen bezeichnet man als Klasse, hier der Klasse MyClass. Die nach diesem Plan gebaute Variable als ein Objekt der Klasse, hier also als das Objekt $o der Klasse MyClass. Manche Leute sagen zu dem Objekt $o der Klasse MyClass auch " $o ist eine Instanz der Klasse MyClass".

Nach einem Bauplan können mehrere Objekte gebaut werden, d.h. eine Klasse kann mehrere Instanzen haben.

$p = new MyClass; 

Die Variablen mit den Namen "a" und "b" in einem Objekt der Klasse MyClass werden in PHP als Slots oder Instanzvariablen bezeichnet. Man spricht sie immer über den Namen des Objektes an:

$o->a = 17;
$p->a = 31; 

Dadurch werden sie unterscheidbar, d.h. es ist erkennbar, ob man den Slot mit dem Namen "a" des Objektes $o oder des Objektes $p meint. Das kann man sich vorstellen wie Pfadnamen: In unterschiedlichen Verzeichnissen eines Dateisystems kann man ja auch Dateien mit demselben Namen liegen haben, aber diese Variablen unterscheiden sich im Pfadnamen.

Eine Klasse kann nicht nur Instanzvariablen definieren, sondern auch Instanzfunktionen, hier die Funktionen mit den Namen "c" und "MyClass". Sie werden genauso angesprochen wie die Instanzvariablen:

$o->c();
$p->c();
$o->MyClass();
$p->MyClass(); 

Manche Leute nennen die Funktionen eines Objektes auch "Methoden" und reden dann von "Instanzmethoden" statt "Instanzfunktionen". Das hat keinen praktischen Zweck und dient nur der Förderung der allgemeinen Verwirrung.

Beim Funktionsaufrufen gilt die folgende Sonderregel: Eine Funktion, die exakt denselben Namen hat wie die Klasse, in der sie enthalten ist, wird auch dann aufgerufen, wenn das Objekt von new gebaut wird. Diese Funktion kann also verwendet werden, um die Slots des Objektes mit Defaultwerten zu initialisieren:

$c = new MyClass; 

Hier wird also die Funktion $c->MyClass() automatisch aufgerufen. Weil diese Funktion aufgerufen wird, während das Objekt nach dem Bauplan gebaut wird, nennt man eine solche Funktion einen Konstruktor. Ein Konstruktor könnte auch optionale Parameter erwarten und man könnte der Funktion dann beim Zusammenbau diese Parameter mitgeben:

class MyClass2 {

  ...

  function MyClass2($p1 = "") {
    if ($p1 != "") {
      $this->...
    }
  }
}

$mc1 = new MyClass2("beispielwert");
$mc2 = new MyClass2(); 

Wenn der Bauplan einer Variablen erstellt wird, wenn wir also die Klasse MyClass definieren, dann wissen wir noch nicht, unter welchen Namen die Slots und Instanzfunktionen des Objektes einmal angesprochen werden. Daher können wir in der Funktion nicht $o->a oder $p->c() schreiben, sondern müssen irgendetwas allgemeineres als Platzhalter notieren.

Die Pseudovariable $this steht dabei in einer Instanzfunktion als Platzhalter für den tatsächlichen Namen dieses Objektes. Innerhalb des Objektes $o steht $this->a also als Platzhalter fuer $o->a , innerhalb des Objektes $p steht $this->a jedoch als Platzhalter fuer $p->a . Man kann $this auch als "meine" lesen, also ist $this->a "mein Slot a" und $this->c() "meine Instanzfunktion c".

In PHP ist es so, dass jede Zuweisung eine Kopie der angesprochenen Variablen erzeugt:

$a = 10;
$b = 20;
$c = 30;

$arr = array( $a, $b, $c );

$arr[1] = 22; 

Dies verändert den Wert von $arr[1] auf 22, aber der Wert von $b ändert sich nicht. Dies gilt auch bei Funktionsaufrufen:

function m($p1) {
  $p1 = 22;
}

m($b); 

Dies setzt den Wert von $p1 auf 22, aber $p1 ist eine Kopie von $b und $b verändert den Wert nicht. Da beim Aufrufen ("Call") einer Funktion der Wert von $b in $p1 kopiert, also der Wert von $b an $p1 übergeben wird, nennt man dies "Call by value".

Man könnte auch eine Funktion schreiben, die den Namen der Variablen übergeben bekommt und dann mit Hilfe dieses Namens auf die globale Variable dieses Namens zugreift:

function m2($p1) {
  $GLOBALS[$p1] = 22;
}

m2("b"); 

Da in diesem Fall der Name der Variablen übergeben wird und mit Hilfe dieses Namens dann die originale Variable dieses Namens verändert wird, nennt man diese Art des Funktionsaufrufes "Call by name" (obwohl bei richtigem Call by Name noch viel obskurere Dinge möglich sind)..

Schon in PHP3 ist es so, dass man eine Funktion als "Call by Reference" definieren kann. In diesem Fall wird keine Kopie des Variablenwertes übergeben, sondern der Formalparameter p1 wird zu einem alternativen Namen für den übergebenen Wert. Wieder wird der Wert der originalen globalen Variablen verändert:

function m3(&$p1) {
  $p1 = 22;
}

m3($b); 

Hier ist $p1 in m3() ein alternativer Name fuer die Variable, die beim Aufruf genennt wird. In m3($b) wird die Variable $b benannt, also ist $p1 in diesem Aufruf ein alternativer Name fuer $b . Immer wenn innerhalb dieses Aufrufes von m3() $p1 verwendet wird, wird $b angesprochen.

Seit PHP4 ist es nun so, dass man Referenzen auch an anderer Stelle verwenden kann, zum Beispiel in der o.a. Arraydefinition:

$a = 10;
$b = 20;
$c = 30;

$arr = array( &$a, &$b, &$c );

$arr[1] = 22;

print $b; 

Dieses Beispiel druckt den Wert 22. In diesem Beispiel sind $arr[0] , $arr[1] und $arr[2] keine Kopien der Werte von $a , $b und $c , sondern die $arr -Variablen werden zu alternativen Namen fuer $a , $b und $c . Jeder Zugriff auf $arr[1] spricht also in Wirklichkeit $b an.

Man liest " $arr[1] = &$b " als " $arr von Eins ist eine Referenz auf $b ".

Wenn man eine Klasse definiert, kann man in PHP3 mit dieser Klasse nichts anderes machen als mit Hilfe von "new" Objekte dieser Klasse zu erzeugen.

In PHP4 kann man jedoch nicht nur Funktionen eines Objektes aufrufen, sondern auch schon Funktionen einer Klasse. Das sind also nichts anderes als gewöhnliche Funktionsaufrufe, nur dass die Funktionsnamen sehr seltsam aussehen:

class MyClass3 {
  function c() {
    print "Ich bin Funktion c() in der Klasse MyClass\n";
  }
}

MyClass3::c(); 

Dieses Stück Code haette man so auch schreiben koennen und es wäre leichter zu verstehen gewesen:

function c() {
  print "Ich bin die stinknormale Funktion c()\n";
}

c(); 

Man kann dies verwenden, um in abgeleiteten Klassen Funktionen gleichen Namens in Oberklassen aufzurufen.

Frage: Welche Datentypen gibt es in PHP?

Dadurch, dass PHP allen Variablenbenutzungen das Markierungszeichen $ (Dollar) voranstellt, ist es möglich, Variablen in Stringkonstanten zu interpolieren, wie man es von der Unix-Shell her kennt. Will man das Markierungszeichen selbst ausgeben, kann man ihm es durch einen vorangestellten \ (Backslash) entwerten. Einen Backslash gibt man aus, indem man ihn entwertet: \\ (Backslash Backslash).

In PHP gibt es die folgenden Datentypen:

# Zuweisung
$mybool  = true;
$myint   = 1;
$myfloat = 3.14;
$mystring= "hallo";

# Verwendung
$yourbool  = not $mybool;
$yourint   = $myint * 2;
$yourfloat = $myfloat * 2.71828;
$yourstring= $mystring . " du da!";

# Ausgabe
print "$yourbool\n";
print "$yourint\n";
print "$yourfloat\n";
print "$yourstring\n"; 

Der Gebrauch von Feldern ist im Kapitel arrays ausführlicher erläutert.

PHP unterscheidet nicht zwischen Feldern (Arrays) mit Integer-Index und Hashes (Assoziativen Arrays) mit beliebigen Indices.

# Arrays

# Zuweisung
$a1    = array( 10, 20, 30);
$a2[0] = 10;
$a2[2] = 30;
$a2[1] = 20;

# Verwendung
$a3[0] = $a1[0] + $a2[2]; // $a3[0] ist 40
$a3[]  = $a1[1] + $a1[0]; // $a3[1] ist 30, Index autom. vergeben

# Ausgabe
printf("A1: %s %s %s\n", $a1[0], $a1[1], $a1[2]);

# Aufzählung
for ($i=0; $i<=2; $i++) {
  printf("%s: %s\n", $i, $a1[$i]);
} 

# Hashes

# Zuweisung
$a1    = array( "peter" => 10, "paul" => 20, "mary" => 30);
$a2["peter"] = 10;
$a2["mary"]  = 30;
$a2["paul"]  = 20;

# Verwendung
$a3["peter"] = $a1["peter"] + $a2["mary"]; // $a3["peter"] ist 40

# Ausgabe
printf("A1: %s %s %s\n", $a1["peter"], $a1["paul"], $a1["mary"]);

# Aufzählung
foreach($a1 as $k => $v) {
  print("%s: %s\n", $k, $v);
} 

Der Gebrauch von Objekten ist im Kapitel objects ausführlicher erläutert.

Eine Resource ist eine spezielle Variable, die eine Referenz auf eine externe Resource enthält. Resourcen werden von bestimmten Funktionen erzeugt und benutzt. Wenn man zum Beispiel mit $db = mysql_connect(...) eine Datenbankverbindung herstellt, dann ist $db vom Typ Resource.

Der spezielle NULL Wert steht dafür, dass eine Varaiable keinen Wert hat. NULL ist der einzig mögliche Wert des Typs NULL.

Eine Variable wird als NULL interpretiert, wenn

• ihr die Konstannte NULL als Wert zugewiesen wurde.

• ihr bis jetzt kein Wert zugewiesen wurde.

• sie mit unset() gelöscht wurde.

Frage: Was muss ich bei der automatischen Typ-Konvertierung beachten?

PHP konvertiert Typen für manche Funktionen, ohne dass der Programmierer darauf Einfluss nehmen kann. Hier ein Beispiel, wie der Stringvergleich mit strcmp() intern funktioniert:

wenn is_numeric($a) und is_numeric($b),
  dann vergleiche $a und $b als Zahlen, auch wenn die Variablen
  den Typ String haben (und kein Cast der Welt kann das verhindern),
    dabei verwende BC-Math wenn notwendig und vorhanden,
    sonst float
    sonst integer
  sonst
    mache einen Stringvergleich wie jedermann erwartet haette. 

Also ist

kk@kris:~/Source/php4/Zend> php
<?php
  $a = "2";
  $b = "10";
  echo "a ist ".gettype($a)."\n";
  echo "b ist ".gettype($b)."\n";
  if ($a > $b)
    echo "stringvergleich\n";
  else
    echo "numerischer vergleich\n";
?>
a ist string
b ist string
numerischer vergleich 

Das ist nicht zu ändern. $a und $b sind Strings und werden als Zahlen verglichen, weil sie wie welche aussehen, und man kann es nicht verhindern, noch kann man die Zahldarstellung wählen, in der verglichen wird. Will man einen Stringvergleich erzwingen, muss man schreiben:

kk@kris:~/Source/php4/Zend> php
<?php
  $a = "2";
  $b = "10";
  echo "a ist ".gettype($a)."\n";
  echo "b ist ".gettype($b)."\n";
  if ("x$a" > "x$b")
    echo "stringvergleich\n";
  else
    echo "numerischer vergleich\n";
?>
a ist string
b ist string
stringvergleich 

Hier bewirken die führenden Buchstaben x, dass die Konvertierung in Zahldarstellung fehlschlägt und ein Stringvergleich wird erzwungen.

Frage: Wie schreibe ich eine Funktion mit einer variablen Anzahl von Argumenten?

In PHP kann man Funktionsparameter mit Default-Werten versehen. Läßt man die Argumente der Funktion von hinten nach vorne weg, werden stattdessen die Defaults eingesetzt. Defaultwerte müssen skalare Konstanten sein. Variable Ausdrücke (Variablen, Funktionsaufrufe) oder nichtskalare Werte (Arrays, Objekte) sind nicht gestattet.

function beispiel($p = "default") {
  printf("Der Parameter p hat den Wert %s\n", $p);
}

beispiel("hallo");
beispiel(); 

Auf diese Weise kann man jedoch keine echten variadischen Funktionen schreiben. So ist es zum Beispiel nicht möglich eine Funktion wie printf() in PHP3 zu schreiben. Man kann variadische Funktionen jedoch durch die Übergabe eines Array- oder Hashparameters simulieren.

function beispiel2($p) {
  if (!isset($p) or !is_array($p))
    # Defaults setzen
    $p = array("para1" => "bla", "para2" => "fasel");

  if ($p["para1"])
    machdies();

  if ($p["para2"])
    machdas();
}

beispiel2(array("para1" => "laber", "para2" => "lall")); 

Seit PHP4 sind auch echte variadische Funktionen möglich. Dort gibt es die drei Funktionen

Diese Funktion liefert die Anzahl der Funktionsargumente als Integer.

Diese Funktion bekommt eine Argumentnummer als Parameter und liefert des Wert des Funktionsargumentes mit diesem Index zurück.

Diese Funktion liefert alle Argumente einer Funktion als Array zurück.

Eine echte variadische Funktion kann also in PHP4 folgendermaßen geschrieben werden:

function beispiel3() {
    $args = func_get_args();
    for($i=0; $i<count($args); $i++) {
         print($args[$i]."\n");
    }
}

beispiel3("das", "ist", "ein", "test"); 

Frage: Wie gebe ich mehrere Werte mit einer Funktion zurück?

PHP kann nur einen Wert mit return() zurückgeben.

Wie bei der Übergabe von Funktionsargumenten, kann man aber auch hier beliebige Werte in einem Array zusammenfassen und so eine Rückgabe mehrerer Werte simulieren:

function beispiel() {
    $ret = array(1, 2, 3);

    return($ret);
} 

Im Funktionsaufruf kann man list() verwenden, um Variablen die Elemente des zurückgelieferten Arrays zuzuweisen:

list($var1, $var2, $var3) = beispiel(); 

Wenn man nicht tatsächlich mehrere Werte zurückgeben möchte, sondern lediglich mehrere Werte in einem Funktionsaufruf beeinflussen möchte, dann kann stattdessen auch mit Referenzparametern arbeiten.

Frage: Wie schreibe ich ein Script, das beliebige Parameter verarbeitet?

Manchmal möchte man ein Script zu schreiben, das beliebige Parameter verarbeitet - etwa ein Script, das alle gegebenen Parameter in eine Mail verpackt und diese dann versendet.

Vollständiges Beispiel:

<?php
  $msg = "";

  $msg .= "Alle GET-Parameter\n";
  $msg .= "==================\n";
  $msg .= "\n";
  foreach ($_GET as $k => $v) {
    $msg .= sprintf("%s\n  %s\n\n", $k, $v);
  }

  $msg .= "Alle POST-Parameter\n";
  $msg .= "===================\n";
  $msg .= "\n";
  foreach ($_POST as $k => $v) {
    $msg .= sprintf("%s\n  %s\n\n", $k, $v);
  }

  // Hier kann $msg per Mail versendet werden.
?> 

Will man einfach nur alle Parameter haben, kann man statt $_GET und $_POST auch einfach $_REQUEST verwenden.

Frage: Variable Variablen

Manchmal möchte man auf Variablen zugreifen, deren Namen variabel sind. Zum Beispiel könnte man die Variablen mit den Namen $myvar1 , $myvar2 , $myvar3 , ... , $myvar9 haben.

Am günstigsten wäre es, in so einem Fall ein Array zu nehmen.

for ($i=0; $i<10; $i++)
	echo $myvar[$i]; 

Wenn es unbedingt skalare Variablen sein müssen, kann man stattdessen über das $GLOBALS[] -Array zugreifen:

for ($i=0; $i<10; $i++) {
  if (isset($GLOBALS["myvar$i"]))
    printf("Variable var%d existiert und ihr Wert ist %s<br />\n",
      $i, $GLOBALS["myvar$i"]);
} 

Statt echo $GLOBALS[$lall]; kann man auch die zwei Befehle global $$lall; echo $$lall; verwenden. Empfohlen ist jedoch das Konstrukt mit $GLOBALS[] , weil es leichter zu lesen und zu verstehen ist. Das gilt besonders bei Dateinamen, die sich aus einem konstanten Stamm und einem variablen Anteil zusammensetzen.

Eine weitere alternative Schreibweise für variable Variablen ist ${$lall}; für zusammengesetzte Variablennamen entsprechend beispielsweise ${"datei_$lall"}.

Frage: Was ist der Unterschied zwischen isset() und einem Vergleich auf den Leerstring?

if($var) evaluiert nur dann zu true , wenn $var keinen der folgenden Werte darstellt: false , 0 , 0.0 , "" oder "0" , NULL , array() oder new stdClass . Alle diese Werte bedeuten false in ihrem jeweiligen Typ (Bool, Integer, Float, String, Null, Array, Object).

if(isset($weiter)) evaluiert immer zu true , wenn $weiter nicht undefined ist.

Im ersten Fall wird der Inhalt, im zweiten Fall die Existenz der Variablen bewertet.

Ein ähnliches Problem tritt bei Vergleichen auf: if($var == false) evaluiert immer dann zu true , wenn $var einen der obigen Werte darstellt. PHP führt hier eine automatische Typenkonvertierung durch, wodurch die beiden Variablen als äquivalent angesehen werden.

Diese Typkonvertierung kann mit den Vergleichsoperatoren === (drei Gleichheitszeichen) und !== vermieden werden. Der Vergleich === ist nur dann wahr, wenn die beiden Operanden den gleichen Typ und den gleichen Wert haben.

Frage: Wie kann ich JavaScript-Funktionen aus PHP heraus aufrufen?

JavaScript läuft auf dem Client (im Browser), PHP läuft auf dem Server, also genau am anderen Ende der Welt; wenn die HTML-Seite beim Browser ankommt, ist PHP mit der Arbeit schon fertig. Der Aufruf einer JavaScript-Funktion aus PHP ist also prinzipiell unmöglich.

Allerdings kann man Werte von PHP an JavaScript übergeben; um eine in PHP vorhandene Variable in JavaScript verwenden zu können, muss man sie innerhalb eines <script> -Bereiches ausgeben:

<script type="text/javascript" language="JavaScript">
<?php
printf("js_var = '%s';\n",
        strtr(addslashes($php_var),
        array("\r" => '\r', "\n" => '\n'))
      );
?>
</script> 

Auf diese Weise wird die JavaScript-Variable js_var mit dem Wert der PHP-Variable $php_var vorbelegt. Natürlich kann man so auch beliebigen ausführbaren JavaScript-Code ausgeben, den der Browser anschließend verarbeitet. Wichtig ist nur zu verstehen, dass ein logischer, räumlicher und auch zeitlicher Schnitt zwischen PHP- und JavaScript-Code vorhanden ist.

Frage: Wie kann ich PHP-Funktionen aus JavaScript heraus aufrufen?

Da JavaScript auf dem Client und PHP auf dem Server läuft, kann man aus JavaScript auch keine PHP-Funktionen direkt aufrufen. PHP wird immer als das Resultat eines HTTP-Requests ausgeführt, also beim Holen einer Seite mit GET oder beim Verarbeiten eines Formulares mit POST. Es ist also nicht möglich, aus JavaScript heraus eine PHP-Funktion aufzurufen, außer durch Erzeugen eines HTTP-Requests (durch den von PHP eine neue Seite generiert wird).

Einen GET-Request mit JavaScript erreicht man prinzipiell durch

<script type="text/javascript" language="JavaScript">
window.location.href = "script.php?php_var=" + escape(js_var);
</script> 

Im dadurch aufgerufenen PHP-Skript script.php ist dann die Variable $_REQUEST['php_var'] mit dem Wert von js_var verfügbar. Einen POST- oder GET-Request mit einem Formular erreicht man durch

<script type="text/javascript" language="JavaScript">
document.formularname.submit();
</script> 

Weitere Informationen zur Variablenübergabe: siehe webvariablen in dieser FAQ.

Frage: Wie heißt die Variable, die ich suche?

Die Antwort auf diese Frage lautet ausnahmsweise nicht 42 , sondern phpinfo() . In der Ausgabe dieses Befehls finden sich neben Konfigurationsangaben sehr viele vordefinierte Variablen und deren Namen, einschließlich Umgebungsvariablen, übergebenen Parametern, Cookie-Werten etc. pp. (im unteren Drittel der Ausgabe).

Da sich die Namen der vordefinierten Variablen im Laufe der Entwicklung von PHP mehrmals geändert haben, und ihr Vorhandensein teilweise auch von der Umgebung abhängen kann (Webserver, Aufruf per Kommandozeile usw.), ist es immer ratsam, einen Blick in die Ausgabe von phpinfo() zu werfen. Man lege also eine Datei mit folgendem Inhalt an und rufe sie per Browser auf:

<?php
    phpinfo();
?> 

Gerade auch bei Problemen mit Formular-Variablen oder Cookies kann man in das Script den phpinfo()-Aufruf einbauen, um einen Einblick in die zur Verfügung stehenden Daten zu bekommen.