expressions.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: f4f96ef8b2a95283c92ea2183fe1dedf06f3ad22 Maintainer: sammywg Status: ready -->
<!-- Reviewed: no -->
<chapter xml:id="language.expressions" xmlns="http://docbook.org/ns/docbook">
 <title>Ausdrücke</title>
 <simpara>
  Ausdrücke (Expressions) sind die wichtigsten Bausteine von PHP. In
  PHP ist fast alles, was geschrieben wird, ein Ausdruck. Die einfachste,
  aber auch zutreffendste Definition für einen Ausdruck ist "alles, was
  einen Wert hat".
 </simpara>
 <simpara>
  Die grundlegendsten Formen von Ausdrücken sind Konstanten und Variablen.
  Wenn man <code>$a = 5</code> schreibt, weist man <varname>$a</varname> den
  Ausdruck <code>5</code> zu. <code>5</code> hat offensichtlich den Wert 5.
  Anders ausgedrückt: <code>5</code> ist ein Ausdruck mit dem Wert 5 (in
  diesem Fall ist <code>5</code> eine Integer-Konstante).
 </simpara>
 <simpara>
  Nach dieser Zuweisung würde man erwarten, dass der Wert von
  <varname>$a</varname> nun ebenfalls 5 ist; wenn man also
  <code>$b = $a</code> schreibt, sollte dasselbe dabei herauskommen, als hätte
  man <code>$b = 5</code> geschrieben. Anders ausgedrückt:
  <varname>$a</varname> ist ebenfalls ein Ausdruck mit dem Wert 5. Wenn alles
  richtig funktioniert, wird genau das passieren.
 </simpara>
 <para>
  Etwas kompliziertere Beispiele für Ausdrücke sind Funktionen.
  Betrachten wir zum Beispiel die folgende Funktion:
  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
function foo ()
{
    return 5;
}
?>
]]>
   </programlisting>
  </informalexample>
 </para>
 <simpara>
  Angenommen, Sie sind mit dem Konzept von Funktionen vertraut (wenn
  Sie es nicht sind, lesen Sie das Kapitel über
  <link linkend="language.functions">Funktionen</link>), dann würden Sie davon
  ausgehen, dass die Eingabe von <code>$c = foo()</code> grundsätzlich
  dasselbe bedeutet, als würde man <code>$c = 5</code> schreiben, und genau
  das trifft zu. Funktionen sind Ausdrücke mit dem Wert ihres Rückgabewertes.
  Da <code>foo()</code> den Wert 5 zurückgibt, ist der Wert des Ausdruckes
  '<code>foo()</code>' 5. Normalerweise geben Funktionen nicht einfach einen
  statischen Wert zurück, sondern berechnen etwas.
 </simpara>
 <simpara>
  Natürlich müssen Werte in PHP keine Integer-Zahlen sein, und oft sind
  sie es auch nicht. PHP unterstützt vier skalare Datentypen:
  <type>int</type> (Ganzzahlen), <type>float</type> (Fließkommazahlen),
  <type>string</type> (Zeichenketten) und <type>bool</type>
  (Wahrheitswerte). (Skalare sind Datentypen, die man, im Gegensatz zu zum
  Beispiel Arrays, nicht in kleinere Stücke 'brechen' kann.) PHP
  unterstützt auch zwei zusammengesetzte (nicht-skalare) Datentypen:
  Arrays und Objekte. Jeder dieser Datentypen kann Variablen zugewiesen
  und von Funktionen zurückgegeben werden.
 </simpara>
 <simpara>
  PHP fasst den Begriff Ausdruck aber noch viel weiter, wie es auch andere
  Programmiersprachen tun. PHP ist eine ausdrucksorientierte Sprache, in
  dem Sinne, dass fast alles einen Ausdruck darstellt. Zurück zu dem
  Beispiel, mit dem wir uns bereits beschäftigt haben: <code>$a = 5</code>. Es
  ist einfach zu erkennen, dass hier zwei Werte enthalten sind: Der Wert der
  Integer-Konstanten <code>5</code> und der Wert von <varname>$a</varname>,
  der ebenfalls auf 5 geändert wird. In Wirklichkeit ist aber noch ein
  weiterer Wert enthalten, nämlich der Wert der Zuweisung selbst. Die Zuweisung
  selbst enthält den zugewiesenen Wert, in diesem Fall 5. In der Praxis
  bedeutet dies, dass <code>$a = 5</code>, egal was es tut, immer einen
  Ausdruck mit dem Wert 5 darstellt. Folglich ist <code>$b = ($a = 5)</code>
  gleichbedeutend mit <code>$a = 5; $b = 5;</code> (ein Semikolon markiert das
  Ende einer Anweisung). Da Wertzuweisungen von rechts nach links geparst
  werden, kann man auch <code>$b = $a = 5</code> schreiben.
 </simpara>
 <simpara>
  Ein anderes gutes Beispiel für die Ausdrucksorientierung von PHP sind Prä-
  und Post-Inkrement sowie die entsprechenden Dekremente. Benutzer von PHP und
  vielen anderen Sprachen sind vermutlich mit den Notationen
  <code>variable++</code> und <code>variable--</code> vertraut. Dies sind
  <link linkend="language.operators.increment">Inkrement- und Dekrement-Operatoren</link>.
  In PHP gibt es, wie in C, zwei Arten von Inkrementen - Prä-Inkrement und
  Post-Inkrement. Grundsätzlich erhöhen sowohl Prä- als auch Post-Inkrement
  den Wert der Variable, und der Effekt auf die Variable ist derselbe. Der
  Unterschied liegt im Wert des Inkrement-Ausdruckes. Das Prä-Inkrement, das
  <code>++$variable</code> geschrieben wird, enthält als Wert den Wert der
  erhöhten Variable (PHP erhöht den Wert der Variablen, bevor es ihren Wert
  ausliest, daher der Name 'PRÄ-Inkrement'). Das Post-Inkrement, das
  <code>$variable++</code> geschrieben wird, enthält dagegen den
  ursprünglichen Wert von <varname>$variable</varname> vor der Erhöhung (PHP
  erhöht den Wert der Variablen, nachdem es ihren Wert ausgelesen hat, daher
  der Name 'POST-Inkrement').
 </simpara>
 <simpara>
  Ein sehr gebräuchlicher Typ von Ausdrücken sind
  <link linkend="language.operators.comparison">Vergleichsausdrücke</link>.
  Diese Ausdrücke geben entweder &false; oder &true; zurück. PHP unterstützt
  &gt; (größer), &gt;= (größer oder gleich), == (gleich), != (ungleich),
  &lt; (kleiner), und &lt;= (kleiner oder gleich). Die Sprache unterstützt
  weiterhin ein Set von absoluten Vergleichsoperatoren: === (inhalts- und
  typgleich) und !== (nicht inhalts- oder typgleich). Diese Ausdrücke werden
  meist in bedingten Anweisungen, wie &zb; in
  <code>if</code>-Anweisungen, verwendet.
 </simpara>
 <simpara>
  Im letzten Beispiel für Ausdrücke befassen wir uns mit kombinierten
  Zuweisungs- und Operator-Ausdrücken. Wir wissen bereits, dass, wenn wir
  <varname>$a</varname> um 1 erhöhen wollen, wir einfach
  <code>$a++</code> oder <code>++$a</code> schreiben können.
  Aber was tut man, wenn man den Wert um mehr als eins erhöhen will, &zb;
  um 3? Man könnte mehrere Male <code>$a++</code> schreiben, aber das
  ist offensichtlich weder ein effizienter noch komfortabler Weg. Viel
  üblicher ist es, einfach <code>$a = $a + 3</code>
  zu schreiben. <code>$a + 3</code> gibt den Wert von
  <varname>$a</varname> plus 3 zurück, dieser wird wieder <varname>$a</varname>
  zugewiesen, was dazu führt, dass <varname>$a</varname> nun um 3 erhöht wurde.
  In PHP - wie in einigen anderen Programmiersprachen, &zb; in C - kann man
  dies aber noch kürzer schreiben, was mit der Zeit klarer wird und auch
  einfacher zu verstehen ist. Um 3 zu dem aktuellen Wert von
  <varname>$a</varname> hinzuzufügen, schreibt man <code>$a += 3</code>.
  Das bedeutet exakt: "Nimm den Wert von <varname>$a</varname>, addiere 3
  hinzu und weise <varname>$a</varname> den entstandenen Wert zu". Zusätzlich
  dazu, dass diese Schreibweise kürzer und klarer ist, wird sie auch schneller
  ausgeführt. Der Wert von <code>$a += 3</code> ist, wie der Wert
  einer regulären Zuweisung, der zugewiesene Wert. Beachten Sie, dass dieser
  Wert NICHT 3, sondern dem kombinierten Wert von <varname>$a</varname> plus 3
  entspricht (das ist der Wert, der <varname>$a</varname> zugewiesen wird).
  Jeder Operator, der zwei Elemente verbindet, kann in dieser Schreibweise
  verwendet werden, &zb; <code>$a -= 5</code> (vermindert den Wert
  von <varname>$a</varname> um 5) oder <code>$b *= 7</code>
  (multipliziert den Wert von <varname>$b</varname> mit 7), usw.
 </simpara>
 <para>
  Es gibt einen weiteren Ausdruck, der Ihnen vielleicht seltsam vorkommt,
  wenn Sie ihn bisher noch in keiner Programmiersprache kennengelernt
  haben, den dreifach konditionalen Operator:
 </para>
 <para>
  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
$eins ? $zwei : $drei
?>
]]>
   </programlisting>
  </informalexample>
 </para>
 <para>
  Wenn der Wert des ersten Sub-Ausdruckes (hier: $eins) &true; ist
  (&dh; nicht 0), dann wird der Wert des zweiten Subausdrucks
  (hier: $zwei) ausgewertet und ist das Ergebnis des konditionalen
  Ausdrucks. Andernfalls wird der dritte Subausdruck ausgewertet und
  dessen Wert zurückgegeben.
 </para>
 <para>
  Das folgende Beispiel sollte das Verständnis von Prä- und
  Post-Inkrement und von Ausdrücken im Allgemeinen erleichtern:
 </para>
 <para>
  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
function verdoppeln($i)
{
    return $i*2;
}
$b = $a = 5;        /* Weise den Variablen $a und $b den Wert 5 zu */
$c = $a++;          /* Post-Inkrement, der urspruengliche Wert von $a (5)
                       wird $c zugewiesen. */
$e = $d = ++$b;     /* Prae-Inkrement, der erhöhte Wert von $b (6) wird $d und
                       $e zugewiesen. */

/* An diesem Punkt sind $d und $e beide gleich 6 */

$f = verdoppeln($d++);  /* Weise $f den doppelten Wert von $d vor
                           der Erhöhung um eins zu, 2*6 = 12 */
$g = verdoppeln(++$e);  /* Weise $g den doppelten Wert von $e nach
                           der Erhoehung um eins zu, 2*7 = 14 to $g */
$h = $g += 10;      /* Zuerst wird $g um 10 erhöht und hat damit den Wert
                       24. Der Wert dieser Zuweisung (24) wird dann $h
                       zugewiesen, womit $h ebenfalls den Wert von 24 hat. */
?>
]]>
   </programlisting>
  </informalexample>
 </para>
 <simpara>
  Einige Ausdrücke können wie Anweisungen verwendet werden. In diesem Falle
  hat eine Anweisung die Form '<code>expr ;</code>', dies meint einen Ausdruck
  gefolgt von einem Semikolon. In <code>$b = $a = 5;</code> ist
  <code>$a = 5</code> ein gültiger Ausdruck, aber für sich allein keine
  Anweisung. <code>$b = $a = 5;</code> ist jedoch eine gültige Anweisung.
 </simpara>
 <simpara>
  Ein letzter Punkt, der noch zu erwähnen ist, ist der Wahrheitswert
  von Ausdrücken. In vielen Fällen, hauptsächlich in bedingten
  Anweisungen und Schleifen, ist man nicht am spezifischen Wert
  eines Ausdrucks interessiert, sondern kümmert sich nur darum,
  ob er &true; oder &false; bedeutet.

  <!-- (PHP hat keinen speziellen boolean-Datentyp). -->

  Die Konstanten &true; und &false; (case-insensitiv) sind die beiden
  möglichen Wahrheitswerte. Wenn nötig wird ein Ausdruck automatisch in
  einen Booleschen Wert konvertiert. Wenn Sie mehr darüber erfahren wollen,
  lesen Sie den Abschnitt über
  <link linkend="language.types.typecasting">Typecasting</link>.
 </simpara>
 <simpara>
  PHP stellt eine vollständige und mächtige Implementierung von Ausdrücken
  bereit, deren vollständige Dokumentation den Rahmen dieses Manuals
  sprengen würde. Die obigen Beispiele sollten Ihnen einen guten Eindruck
  davon verschaffen, was Ausdrücke sind und wie man nützliche Ausdrücke
  konstruieren kann. Im Rest dieses Manuals werden wir
  <varname>expr</varname> schreiben, um auszudrücken, dass an dieser
  Stelle jeder gültige PHP-Ausdruck stehen kann.
 </simpara>
</chapter>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->