PHP  
downloads | documentation | faq | getting help | mailing lists | | php.net sites | links | my php.net 
search for in the  
<Vordefinierte KonstantenOperatoren>
view the version of this page
Last updated: Sat, 19 Apr 2003

Kapitel 10. Ausdr�cke

Ausdr�cke (Expressions) sind die wichtigsten Bausteine von PHP. In PHP ist fast alles, was geschrieben wird, ein Ausdruck. Die einfachste, aber auch zutreffenste Definition f�r einen Ausdruck ist "alles, was einen Wert hat".

Die grundlegendste Formen von Ausdr�cken sind Konstanten und Variablen. Wenn man "$a = 5" schreibt, weist man $a den Ausdruck �5� zu. �5� hat offensichtlich den Wert 5. Anders ausgedr�ckt: �5� ist ein Ausdruck mit dem Wert 5 (in diesem Fall ist �5� eine Integer-Konstante).

Nach dieser Zuweisung w�rde man erwarten, dass der Wert von $a nun ebenfalls 5 ist, wenn man also $b = $a schreibt, sollte dasselbe dabei herauskommen, als h�tte man $b = 5 geschrieben. Anders ausgedr�ckt: $a w�re ebenfalls ein Ausdruck mit dem Wert 5. Wenn alles richtig funktioniert, wird genau das passieren.

Etwas kompliziertere Beispiele f�r Ausdr�cke sind Funktionen:

function foo () {
    return 5;
}

Angenommen, Sie sind mit dem Konzept von Funktionen vertraut (wenn Sie es nicht sind, lesen Sie das Kapitel �ber Funktionen), dann w�rden Sie annehmen, dass die Eingabe von $c = foo() grunds�tzlich daselbe bedeutet, als w�rde man schreiben $c = 5,und genau das trifft zu. Funktionen sind Ausdr�cke mit dem Wert ihres R�ckgabewertes. Da foo() den Wert 5 zur�ckgibt, ist der Wert des Ausdruckes �foo()� 5. Normalerweise geben Funktionen nicht einfach einen statischen Wert zur�ck, sondern berechnen irgendetwas.

Nat�rlich m�ssen Werte in PHP keine Integer-Zahlen sein, und oft sind sie es auch nicht. PHP unterst�tzt drei skalare Datentypen: integer values (Integer-Zahlen),floating point values (Flie�kommazahlen) und string values (Zeichenketten). (Skalare sind Datentypen, die man nicht in kleinere St�cke �brechen� kann, im Gegensatz zu Arrays). PHP unsterst�tzt auch zwei zusammengesetzte (nicht-skalare) Datentypen: Arrays und Objekte. Jeder dieser Datentypen kann Variablen zugewiesen und von Funktionen zur�ckgegeben werden.

Bis hierhin sollten Benutzer von PHP/FI 2 keine Ver�nderung bemerkt haben. PHP fasst den Begriff �Ausdruck� aber noch viel weiter, wie es auch andere Programmiersprachen tun. PHP ist in dem Sinne eine ausdrucksoriente Sprache, dass fast alles ein Ausdruck ist. Zur�ck zu dem Beispiel, mit dem wir uns schon besch�ftigt haben: �$a = 5�. Es ist einfach zu erkennen, dass hier zwei Werte enthalten sind: Der Wert der Integer-Konstanten �5� und der Wert von $a, der auf 5 ge�ndert wird. In Wirklichkeit ist aber noch ein zus�tzlicher 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 �$a = 5�, egal was es tut, immer einen Ausdruck mit dem Wert 5 darstellt. Folglich ist �$b = ($a = 5)� gleichbedeutend mit �$a = 5; $b = 5;� (ein Semikolon markiert das Ende einer Anweisung). Da Wertzuweisungen von rechts nach links geparst werden, kann man auch �$b = $a = 5� schreiben.

Ein anderes gutes Beispiel f�r die Ausdrucksorientierung von PHP sind Pr�- und Post-Inkrement sowie die entsprechenden Dekremente. Benutzer von PHP/FI 2 und vielen anderen Sprachen sind vermutlich mit den Notationen �variable++� und �variable--� vertraut. Dies sind Inkrement- und Dekrement-Operatoren. IN PHP/FI 2 hat das Statement �$a++� keinen Wert (es ist kein Ausdruck) und daher kann man es nicht als Wert zuweisen oder in irgendeiner Weise benutzen. PHP erweitert die Eigenschaften von Dekrement und Inkrement, indem es die beiden ebenfalls zu Ausdr�cken macht. 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 ist der Wert des Inkrement-Ausdruckes. Das Pr�-Inkrement, das �++$variable� geschrieben wird, enth�lt als Wert den Wert der erh�hten Variabe (PHP erh�ht den Wert der Variable, bevor es ihren Wert ausliest, daher der Name �PR�-Inkrement�). Das Post-Inkrement, das �$variable++� geschrieben wird, enth�lt dagegen den urspr�nglichen Wert der Variablen vor der Erh�hung (PHP erh�ht den Wert der Variablen, nachdem es ihren Wert ausgelesen hat, daher der Name �POST-Inkrement�).

Ein sehr gebr�uchlicher Typ von Ausdr�cken sind Vergleichsausdr�cke. Diese Ausdr�cke geben entweder 0 (=FALSCH) oder 1 (=WAHR) zur�ck. PHP unterst�tzt > (gr��er), >= (gr��er oder gleich), == (gleich), != (ungleich), < (kleiner), und <= (kleiner oder gleich). Diese Ausdr�cke werden meistens in bedingten Anweisungen, wie z. B. in if-Anweisungen, verwendet.

Im letzten Beispiel f�r Ausdr�cke befassen wir uns mit kombinierten Zuweisungs- und Operator-Ausdr�cken. Wir haben schon gezeigt, wie man den Wert von $a um 1 erh�ht, n�mlich indem man einfach �$a++� oder �++$a� schreibt. Aber was tut man, wenn man den Wert um mehr als eins erh�hen will, z. B. um 3? Man k�nnte mehrer Male �$a++� schreiben, aber das ist offensichtlich weder effizient noch sehr komfortabel. Viel �blicher ist es, einfach �$a = $a + 3� zu schreiben. �$a + 3� gibt den Wert von $a plus 3 zur�ck, dieser wird wieder $a zugewiesen, was dazu f�hrt, dass $a nun um 3 erh�ht wurde. In PHP - wie in einigen anderen Programmiersprachen, z. B. 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 hinzuzuf�gen, schreibt man �$a += 3�. Das bedeutet exakt: "Nimm� den Wert von $a, addiere 3 hinzu und weise $a den entstandenen Wert zu". Zus�tzlich dazu, dass diese Schreibweise k�rzer und klarer ist, resultiert sie auch in einer schnelleren Ausf�hrung. Der Wert von �$a += 3� ist, wie der Wert einer regul�ren Zuweisung, der zugewiesene Wert. Es ist zu beachten, dass dieser Wert NICHT 3, sondern dem kombinierten Wert von $a plus 3 entspricht (Das ist der Wert, der $a zugewiesen wird). Jeder Operator, der zwei Elemente verbindet, kann in dieser Schreibweise verwendet werden, z. B. �$a -= 5� (vermindert den Wert von $a um 5) oder �$a *= 7� (multipliziert den Wert von $a mit 7 und weist das Ergebnis $a zu), usw.

Es gibt einen weiteren Ausdruck, der Ihnen vielleicht seltsam vorkommt, wenn Sie ihn bisher noch in keiner Programmiersprache kennengelernt haben, den dreifach konditionalen Operator:

$eins ? $zwei : $drei

Wenn der Wert des ersten Sub-Ausdruckes (hier: $eins) wahr ist (d. h. nicht NULL), dann wird der Wert des zweiten Subausdrucks (hier: $zwei) zur�ckgeben und ist das Ergebnis des konditionalen Ausdrucks. Andernfalls (d. h. wenn der erste Ausdruck falsch ist), wird der Wert des dritten Subausdruckes (hier: $drei) zur�ckgeben.

Das folgende Beispiel sollte das Verst�ndnis von Pr�- und Post-Inkrement und von Ausdr�cken im allgemeinen erleichtern:

function verdoppeln($i) {
    return $i*2;
}
$b = $a = 5;        /* Weise den Variablen $a und $b beiden den Wert 5 zu */
$c = $a++;          /* Post-Inkrement, der urspruengliche Wert von $a (also 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 = double(++$e);  /* Weise $g den doppelten Wert von $e nach
                       der Erhoehung zu, 2*7 = 14 to $g */
$h = $g += 10;      /* Zuerst wie $g um 10 erh�ht und hat schliesslich den Wert
                       24. Der Wert dieser Zuweisung (24) wird dann $h zugewiesen,
                       womit $h ebenfalls den Wert von 24 hat. */

Am Anfang dieses Kapitels hatten wir gesagt, wir w�rden die verschiedenen Arten von Anweisungen beschreiben und, wie versprochen, Ausdr�cke k�nnen Anweisungen sein. Trotzdem ist nicht jeder Ausdruck eine Anweisung. In diesem Fall hat eine Anweisung die Form �Ausdr� �;�, d. h. ein Ausdruck gefolgt von einem Semikolon. In �$b=$a=5;� ist $a=5 ein g�ltiger Ausdruck, aber f�r sich allein keine Anweisung. �$b=$a=5;� ist jedoch eine g�ltige Anweisung.

Ein letzter Punkt, der noch zu erw�hnen ist, ist der �wahr�-Wert 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 WAHR oder FALSCH bedeutet (PHP hat keinen speziellen boolean-Datentyp). Der Wahrheitswert eines Ausdrucks in in PHP wird �hnlich bestimmt wie in Perl. Jeder numerische Wert, der nicht NULL ist, bedeutet WAHR, NULL bedeutet FALSCH. Es ist zu beachten, dass negative Werte nicht NULL sind und deshalb als WAHR aufgefasst werden! Eine leere Zeichenkette und die Zeichenkette "0" sind FALSCH; alle anderen Zeichenketten sind WAHR. Nicht-skalare Datentypen (Arrays und Objekte) werden als FALSCH betrachtet, wenn sie keine Elemente enthalten, anderfalls geben sie WAHR zur�ck.

PHP stellt eine vollst�ndige und m�chtige Implementat von Ausdr�cken bereit und, deren vollst�ndige Dokumentation den Rahmen dieses Manuals sprengen w�rde. Die obigen Beispiele sollten Ihnen einen guten Eindruck dar�ber verschaffen, was Ausdr�cke sind und wie man n�tzliche Ausdr�cke konstruieren kann. Im Rest dieses Manuals werden wir ausdr schreiben, um ausdr�cken, dass an dieser Stelle jeder g�ltige PHP-Ausdruck stehen kann.



User Contributed Notes
Ausdr�cke
add a note
rlynch at ignitionstate dot com
29-Sep-1999 09:43

boolean expressions short-circuit, currently.
If boolean expression short-circuiting is a feature rather than a coincidence, it should probably be added here... Unless I missed it.

anthony at n dot o dot s dot p dot a dot m dot trams dot com
24-Nov-2000 06:01

The ternary conditional operator is a useful way of avoiding inconvenient if statements.  They can even be used in the middle of a string concatenation, if you use parentheses.  

Example:

if ( $wakka ) {
 $string = 'foo' ;
} else {
 $string = 'bar' ;
}

The above can be expressed like the following:

$string = $wakka ? 'foo' : 'bar' ;

If $wakka is true, $string is assigned 'foo', and if it's false, $string is assigned 'bar'.

To do the same in a concatenation, try:

$string = $otherString . ( $wakka ? 'foo' : 'bar' ) ;

mircho at _NO_SPAM_abv dot bg
23-Jan-2001 07:23

try this

$a = "-1";
$a++;
echo $a;

this prints -2 as a result

to be sure you get what you wanted to get just do this

$a = "-2"
$b = (integer)($a)
and now $b will behave

somebody mentioning strict typing?

yasuo_ohgaki at hotmail dot com
12-Mar-2001 06:14

Manual defines "expression is anything that has value", Therefore, parser will give error for following code.

($val) ? echo('true') : echo('false');
Note: "? : " operator has this syntax  "expr ? expr : expr;"

since echo does not have(return) value and ?: expects expression(value).

However, if function/language constructs that have/return value, such as include(), parser compiles code.

Note: User defined functions always have/return value without explicit return statement (returns NULL if there is no return statement). Therefore, user defined functions are always valid expressions.
[It may be useful to have VOID as new type to prevent programmer to use function as RVALUE by mistake]

For example,

($val) ? include('true.inc') : include('false.inc');

is valid, since "include" returns value.

The fact "echo" does not return value(="echo" is not a expression), is less obvious to me.

Print() and Echo() is NOT identical since print() has/returns value and can be a valid expression.

tmacamNOSP at Mufc dot br
13-Sep-2001 06:57

As reported previously, PHP boolean operators seem to short-circuit. What if you want them to do not short-circuit?

Exemple:
$result_of = f1() and f2() and f3()

suppose you want to run f3 even when f1 already returned false.

If you perform some silly tests such as:
echo true + true;
you'll see that indeed, true=1 and false=0 and true+true = 2 (ok. this _is_ silly!)

Anyway, the point is: you could use * (multiplication) instead of 'and', to get a not short-circuiting 'and' and + (sum) to get a not short-circuiting or.


[]s
MaCa

08-Mar-2002 08:20
I found this worked nicely:

echo $var ? "yup" : "nope";

This doesnt work:

echo $var ? "yup";

you need to go:

echo $var ? "yup" : "";

-- there is not space in "", but it may appear that way above

Mattias at mail dot ee
25-May-2002 10:29

A note about the short-circuit behaviour of the boolean operators.

1. if (func1() || func2())
Now, if func1() returns true, func2() isn't run, since the expression
will be true anyway.

2. if (func1() && func2())
Now, if func1() returns false, func2() isn't run, since the expression
will be false anyway.

The reason for this behaviour comes probably from the programming
language C, on which PHP seems to be based on. There the
short-circuiting can be a very useful tool. For example:

int * myarray = a_func_to_set_myarray(); // init the array
if (myarray != NULL && myarray[0] != 4321) // check
myarray[0] = 1234;

Now, the pointer myarray is checked for being not null, then the
contents of the array is validated. This is important, because if
you try to access an array whose address is invalid, the program
will crash and die a horrible death. But thanks to the short
circuiting, if myarray == NULL then myarray[0] won't be accessed,
and the program will work fine.

toreilly at cityspree dot com
27-May-2002 09:30

I actually find the short-circuit aspect of expressions useful.  As in:
if ($foo AND Bar()) { echo "OK"; }

where Bar() should only be run if $foo is set, and OK should only be printed if both evaluate to TRUE.

My only concern is if this is the intended result in PHP.  In other words, if I code this way will it fail under later releases of PHP?

tai at iij dot ad dot jp
30-May-2002 02:30

Regarding short-circuit expression, it is a frozen feature, not a coincidence. At least, that's what I read from the URL below.



Now, I sometimes feel the need for BNF-written document to explain PHP syntax to others...does anyone know where I can find one?

iamfast at tampabay dot rr dot com
16-Jul-2002 08:47

If you need to do something like make sure you dont say '1 days' try this

echo $being-$today.' day'.($begin-$today===1?'':'s').' untill XYZ';

php at cotest dot com
17-Jul-2002 06:08

It should probably be mentioned that the short-circuiting of expressions (mentioned in some of the comments above) is often called "lazy evaluation" (in case someone else searches for the term "lazy" on this page and comes up empty!).
oliver at hankeln-online dot de
07-Aug-2002 01:06

The short-circuiting IS a feature. It is also available in C, so I suppose the developers won�t remove it in future PHP versions.

It is rather nice to write:

$file=fopen("foo","r") or die("Error!");

Greets,
Oliver

rainerd at eldwood dot com
23-Dec-2002 07:01

"Any two-place operator can be used in this operator-assignment mode."

It should be mentioned that this does not apply to the comparison operators.  $a <= $b is obviously not the same as $a = $a < $b.

stian at datanerd dot net
25-Feb-2003 09:37

The short-circuit feature is indeed intended, and there are two types of evaluators, those who DO short-circuit, and those who DON'T, || / && and | / & respectively.
The latter method is the bitwise operators, but works great with the usual boolean values ( 0/1 )

So if you don't want short-circuiting, try using the | and & instead.

Read more about the bitwise operators here:

Ruben Bonke
08-Apr-2003 11:03

In case you want to check whether an INT is even or uneven, you could use the % operator. In the example below it has been put into an if-statement.

<?php

 //Sets the variable a
$a=2;

 //Start checking
 if (($a%2)==0) {
  print "This is an even number";     //TRUE
} else {
  print "This is an uneven number";  //FALSE
}

?>

How does it work?
$a%2: constantly substract 2 from int a.
if put in an if-statement like above, it keeps on substracting 2 from int a, until value is exactly 0 or lower than 2 and higher than 0.

Another example.

<?php
 
$a=9;
 $b=8;
 $c=7;

 $outcome_A = $a % 3;
 $outcome_B = $b % 3;
 $outcome_C = $c % 3;

 print $outcome_A;  // result: 0
 print $outcome_B;  // result: 2
 print $outcome_C;  // result: 1

?>

I find this function useful for webdesign purposes.
For instance to colour the background of every even entry of database output.

Miki
20-Apr-2003 01:24

It appears to me that % is simply the same as % in C++ which is the modulus operator.

modulus  - Returns the remainder obtained by dividing the first argument by the second argument.

So in the example above it's not subtracting 2 from it and returning the result, it's dividing $a by 2 and returning the remainder.

cmartin at orlando dot fl
20-Apr-2003 06:34

Got into trouble here when not enclosing my multiple expressions in parenthesis:

  if ($res = mysql_query($query) && $row = mysql_fetch_assoc($res))
  {
      echo "Got DB Row!: ";
      print_r($row);
  }

Results in a PHP warning:

  PHP Warning:  mysql_fetch_assoc(): supplied argument is not a valid MySQL result resource in test.php on line 10

  Warning: mysql_fetch_assoc(): supplied argument is not a valid MySQL result resource in test.php on line 10

By adding parenthesis around the assignment expressions...

  if (($res = mysql_query($query)) && ($row = mysql_fetch_assoc($res))) {
      echo "Got DB Row!: ";
      print_r($row);
  }

...results in the desired output:

  Got DB Row!: Array
  (
      [id] => 0
      [name] => "Foo!"
  )

A closer look at what happens when the right value of an assignment is false (when used as a test expression):

  $a = 0;

  if ($b = $a && $c = $b) {
      echo "Test true: ";
  }
  echo "a:$a b:$b c:$c";

...yields $b and $c as unset:

  a:0 b: c:

...while parenthesis modify $b's result:

  $a = 0;

  if (($b = $a) && ($c = $b)) {
      echo "Test true: ";
  }
  echo "a:$a b:$b c:$c";

...as $b being set and $c remaining unset (desired):

  a:0 b:0 c:

One may want to always enclose their singular expressions within parenthesis to avoid this feature/problem. :)

add a note

<Vordefinierte KonstantenOperatoren>
 Last updated: Sat, 19 Apr 2003
show source | credits | mirror sites 
Copyright © 2001-2003 The PHP Group
All rights reserved.
This mirror generously provided by: /
Last updated: Mon May 12 21:12:21 2003 CEST