PHP Doku:: Prüft, ob eine Variable einen Wert enthält - function.empty.html

Verlauf / Chronik / History: (1) anzeigen

Sie sind hier:
Doku-StartseitePHP-HandbuchFunktionsreferenzVariablen- und typbezogene ErweiterungenVariablenbehandlungFunktionen zur Behandlung von Variablenempty

Ein Service von Reinhard Neidl - Webprogrammierung.

Funktionen zur Behandlung von Variablen

<<doubleval

floatval>>

empty

(PHP 4, PHP 5)

emptyPrüft, ob eine Variable einen Wert enthält

Beschreibung

bool empty ( mixed $var )

Prüft, ob eine Variable einen Wert enthält

Parameter-Liste

var

Die zu prüfende Variable.

Hinweis:

empty() überprüft nur Variablen, alles andere führt zu einem Parse-Error. Anders gesagt wird folgendes nicht funktionieren: empty(trim($name)).

empty() ist das Gegenteil von (boolean) var, außer dass keine Warnung erzeugt wird, wenn die Variable nicht gesetzt ist.

Rückgabewerte

Gibt FALSE zurück, wenn var einen nicht-leeren und von 0 verschiedenen Wert hat.

Folgende Dinge zählen als nicht mit einem Wert belegt:

  • "" (eine leere Zeichenkette)
  • 0 (0 als Integer)
  • "0" (0 als Zeichenkette)
  • NULL
  • FALSE
  • array() (ein leeres Array)
  • var $var; (in einer Klasse deklarierte, aber nicht belegt Variable)

Changelog

Version Beschreibung
PHP 5

Seit PHP 5 zählen Objekte ohne Properties nicht mehr als nicht mit einem Wert belegt.

Beispiele

Beispiel #1 Ein einfacher Vergleich von empty() / isset()

<?php
$var 
0;

// true, weil $var keinen Wert enthält
if (empty($var)) {
    echo 
'$var ist 0, nicht mit einem Wert belegt, oder nicht gesetzt';
}

// true, weil $var gesetzt wurde
if (isset($var)) {
    echo 
'$var ist gesetzt, enthält aber keinen Wert';
}
?>

Anmerkungen

Hinweis: Da dies ein Sprachkonstrukt und keine Funktion ist, können Sie dieses nicht mit Variablenfunktionen verwenden.

Hinweis:

Bei Aufruf von empty() auf nicht-öffentliche Objekteigenschaten wird die überladene Methode __isset aufgerufen, falls deklariert.

Siehe auch


33 BenutzerBeiträge:
- Beiträge aktualisieren...
e dot klerks at i-bytes dot nl
8.11.2010 15:16
To make an empty function, which only accepts arrays, one can use type-hinting:

<?php
// emptyArray :: [a] -> Bool

function emptyArray(array $xs){
 return empty(
$xs);
}
?>

Type hinting is a good thing to use in your code, because it makes it more easy to reason about your code. Besides that, it automatically documents the code.
serkons at yahoo dot com
28.10.2010 23:01
Hi you can check the status of multiple array or any variable is empty with below code.

<?php
$microtimeref
= microtime ( true );
//$variable=null; // false,true,0,''
//$variable = array ('id' => 10, 'name' => 'serkon' );
$variable = array (array (0) );
echo
'<pre>';
function
getArray($dizi) {
    foreach (
$dizi as $value )
        return
$value;
}
function
isEmpty($array) {
    if (
is_array ( $array )) {
       
$dizi = getArray ( $array );
        if (
is_array ( $dizi ))
           
$ref = isEmpty ( $dizi );
        else
            if (
strlen ( $dizi ) >= 1)
                return
false;
            else
                return
true;
    }
    else
        if (
strlen ( $array ) >= 1)
            return
false;
        else
            return
true;
   
    if (
$ref === false)
        return
false;
    else
        return
true;
}
$sonuc = isEmpty ( $variable );
var_dump ( $sonuc );
echo
"Total time: <b>" . round ( microtime ( true ) - $microtimeref, 4 ) . 's</b><br />';
echo
'</pre>';
?>

Response:

bool(false)  // not empty
Total time: 0s
rodolphe dot bodeau at free dot fr
25.10.2010 15:37
Be careful, if "0" (zero as a string), 0 (zero as an integer) and -0 (minus zero as an integer) return true, "-0" (minus zero as a string (yes, I already had some customers that wrote -0 into a form field)) returns false. You need to cast your variable before testing it with the empty() function :

<?php
$var
= "-0";
echo empty(
$var);  // returns false
$var = (int) $var; // casts $var as an integer
echo empty($vat);  // returns true
?>
ehsmeng
21.09.2010 14:25
I can't use empty() in all situations because '0' is usually not considered empty to me. I did a quick benchmark over the most common ways of testing it. '' == var suffers from '' == 0 is true so that's just there for curiosity.

<?php
    $microtimeref
= microtime(true);
   
$a = 0;
   
$b = 'asd';
    for (
$i = 0; $i < 5000000; $i++)
    {
        if (
0 == mb_strlen ($b))
        {
           
$a++;
        }
    }
    echo
"Total time 0 == mb_strlen(var): <b>" . round(microtime(true) - $microtimeref,3) . 's</b><br />';
?>

The results:

Total time 0 == mb_strlen(var): 3.141s
Total time 0 === strlen(var): 2.904s
Total time 0 == strlen(var): 2.878s
Total time '' == var: 1.774s
Total time '' === var: 1.706s
Total time empty(var): 1.496s

Thus '' === var will be my zero length string test.
marko dot crni at gmail dot com
16.09.2010 20:06
Calling non existing object property, empty($object->prop), will trigger __isset(), the same way as isset($object->prop) does, but there is one difference. If __isset() returns TRUE, another call to __get() will be made and actual return value will be result of empty() and result of __get().
php at sethsyberg dot com
7.05.2010 7:30
To find if an array has nothing but empty (string) values:

<?php
$foo
= array('foo'=>'', 'bar'=>'');
$bar = implode('', $foo);

if (empty(
$bar)) {
    echo
"EMPTY!";
} else {
    echo
"NOT EMPTY!";
}
?>
aidan1103 at yahoo dot com
26.03.2010 19:11
empty() should not necessarily return the negation of the __isset() magic function result, if you set a data member to 0, isset() should return true and empty should also return true.  A simpler implementation of the __isset magic function would be:

public function __isset($key) {
  return isset($this->{$key});
}

I don't understand why this isn't included in stdClass and inherited by default.
kleingeist
25.11.2009 2:23
Another, simpler, implementation to test if mulitarrays are empty.

<?php
function array_empty($mixed) {
    if (
is_array($mixed)) {
        foreach (
$mixed as $value) {
            if (!
array_empty($value)) {
                return
false;
            }
        }
    }
    elseif (!empty(
$mixed)) {
        return
false;
    }
    return
true;
}
?>
Janci
24.08.2009 17:57
Please note that results of empty() when called on non-existing / non-public variables of a class are a bit confusing if using magic method __get (as previously mentioned by nahpeps at gmx dot de). Consider this example:

<?php
class Registry
{
    protected
$_items = array();
    public function
__set($key, $value)
    {
       
$this->_items[$key] = $value;
    }
    public function
__get($key)
    {
        if (isset(
$this->_items[$key])) {
            return
$this->_items[$key];
        } else {
            return
null;
        }
    }
}

$registry = new Registry();
$registry->empty = '';
$registry->notEmpty = 'not empty';

var_dump(empty($registry->notExisting)); // true, so far so good
var_dump(empty($registry->empty)); // true, so far so good
var_dump(empty($registry->notEmpty)); // true, .. say what?
$tmp = $registry->notEmpty;
var_dump(empty($tmp)); // false as expected
?>

The result for empty($registry->notEmpty) is a bit unexpeced as the value is obviously set and non-empty. This is due to the fact that the empty() function uses __isset() magic functin in these cases. Although it's noted in the documentation above, I think it's worth mentioning in more detail as the behaviour is not straightforward. In order to achieve desired (expexted?) results, you need to add  __isset() magic function to your class:

<?php
class Registry
{
    protected
$_items = array();
    public function
__set($key, $value)
    {
       
$this->_items[$key] = $value;
    }
    public function
__get($key)
    {
        if (isset(
$this->_items[$key])) {
            return
$this->_items[$key];
        } else {
            return
null;
        }
    }
    public function
__isset($key)
    {
        if (isset(
$this->_items[$key])) {
            return (
false === empty($this->_items[$key]));
        } else {
            return
null;
        }
    }
}

$registry = new Registry();
$registry->empty = '';
$registry->notEmpty = 'not empty';

var_dump(empty($registry->notExisting)); // true, so far so good
var_dump(empty($registry->empty)); // true, so far so good
var_dump(empty($registry->notEmpty)); // false, finally!
?>

It actually seems that empty() is returning negation of the __isset() magic function result, hence the negation of the empty() result in the __isset() function above.
denobasis-bozic et yahoo.com
18.07.2009 13:54
test if all multiarray's are empty

<?php
function is_multiArrayEmpty($multiarray) {
    if(
is_array($multiarray) and !empty($multiarray)){
       
$tmp = array_shift($multiarray);
            if(!
is_multiArrayEmpty($multiarray) or !is_multiArrayEmpty($tmp)){
                return
false;
            }
            return
true;
    }
    if(empty(
$multiarray)){
        return
true;
    }
    return
false;
}

$testCase = array (    
0 => '',
1 => "",
2 => null,
3 => array(),
4 => array(array()),
5 => array(array(array(array(array())))),
6 => array(array(), array(), array(), array(), array()),
7 => array(array(array(), array()), array(array(array(array(array(array(), array())))))),
8 => array(null),
9 => 'not empty',
10 => "not empty",
11 => array(array("not empty")),
12 => array(array(),array("not empty"),array(array()))
);

foreach (
$testCase as $key => $case ) {
    echo
"$key is_multiArrayEmpty= ".is_multiArrayEmpty($case)."<br>";
}
?>

OUTPUT:
========

0 is_multiArrayEmpty= 1
1 is_multiArrayEmpty= 1
2 is_multiArrayEmpty= 1
3 is_multiArrayEmpty= 1
4 is_multiArrayEmpty= 1
5 is_multiArrayEmpty= 1
6 is_multiArrayEmpty= 1
7 is_multiArrayEmpty= 1
8 is_multiArrayEmpty= 1
9 is_multiArrayEmpty=
10 is_multiArrayEmpty=
11 is_multiArrayEmpty=
12 is_multiArrayEmpty=
mlibazisi mabandla
28.05.2009 23:47
in cases when "0" is not intended to be empty, here is a simple function to safely test for an empty string (or mixed variable):

<?php
function _empty($string){
    
$string = trim($string);
     if(!
is_numeric($string)) return empty($string);
     return
FALSE;
}
?>
emperoruk at dontspam dot hotmail dot com
8.05.2009 17:07
When using the php empty() function to check submitted variables such as $_POST or $_GET, be careful to remember that values 0 (integer) and "0" (string with zero character) are all considered empty. eg. in a simple cms a page ID of zero might be used to indicate that the homepage should be displayed but using the following code:

<?php
if (isset($_GET['pid'] && !empty($_GET['pid']) {
 
// assign value to local variable
 
$pageID = $_GET['pid'];
} else {
  echo
"missing variable 'pageID'";
}
?>

When attempting to display the homepage using a pid of zero the above code will fail.

So as a result i wrote a small function to replace the php empty() function in situations where you want 0 and "0" not to be considered empty.

<?php
function is_empty($var, $allow_false = false, $allow_ws = false) {
    if (!isset(
$var) || is_null($var) || ($allow_ws == false && trim($var) == "" && !is_bool($var)) || ($allow_false === false && is_bool($var) && $var === false) || (is_array($var) && empty($var))) {   
        return
true;
    } else {
        return
false;
    }
}
?>

This function will allow you to test a variable is empty and considers the following values as empty:

an unset variable -> empty
null -> empty
0 -> NOT empty
"0" -> NOT empty
false -> empty
true -> NOT empty
'string value' -> NOT empty
"    " (white space) -> empty
array() (empty array) -> empty

There are two optional parameters:

$allow_false: setting this to true will make the function consider a boolean value of false as NOT empty. This parameter is false by default.

$allow_ws: setting this to true will make the function consider a string with nothing but white space as NOT empty. This parameter is false by default.

In Testing:

<?php
// an unset variable
echo 'unset variable ($notset) - Empty: ';
echo
is_empty($notset) ? 'yes<br />' : 'no<br />';
// NULL variable
echo 'null - Empty: ';
$var = null;
echo
is_empty($var) ? 'yes<br />' : 'no<br />';
// integer 0
echo '0 - Empty: ';
$var = 0;
echo
is_empty($var) ? 'yes<br />' : 'no<br />';
// string "0"
echo 'string "0" - Empty: ';
$var = "0";
echo
is_empty($var) ? 'yes<br />' : 'no<br />';
// boolean value false
echo 'false - Empty: ';
$var = false;
echo
is_empty($var) ? 'yes<br />' : 'no<br />';
// allow boolean value false
echo 'false ($allow_false = true) - Empty: ';
$var = false;
echo
is_empty($var, true) ? 'yes<br />' : 'no<br />';
// boolean value true
echo 'true - Empty: ';
$var = true;
echo
is_empty($var) ? 'yes<br />' : 'no<br />';
// string
echo 'string "foo" - Empty: ';
$var = "foo";
echo
is_empty($var) ? 'yes<br />' : 'no<br />';
// white space
echo 'white space "     " - Empty: ';
$var = "    ";
echo
is_empty($var) ? 'yes<br />' : 'no<br />';
// allow white space
echo 'white space ($allow_ws = true) "     " - Empty: ';
$var = "    ";
echo
is_empty($var, false, true) ? 'yes<br />' : 'no<br />';
// empty array
echo 'empty array - Empty: ';
$var = array();
echo
is_empty($var) ? 'yes<br />' : 'no<br />';
?>

the above code outputs the following:

unset variable ($notset) - Empty: yes
null - Empty: yes
0 - Empty: no
string "0" - Empty: no
false - Empty: yes
false ($allow_false = true) - Empty: no
true - Empty: no
string "foo" - Empty: no
white space " " - Empty: yes
white space ($allow_ws = true) " " - Empty: no
empty array - Empty: yes

Hope this code is useful for someone.

Michael
contato at andersonfraga dot net
10.02.2009 20:24
<?php

function _empty() {
    foreach(
func_get_args() as $args) {
        if( !
is_numeric($args) ) {
            if(
is_array($args) ) { // Is array?
               
if( count($args, 1) < 1 ) return true;
            }
            elseif(!isset(
$args) || strlen(trim($args)) == 0)
                return
true;
            }
        }
    }
    return
false;
}

?>
thomas at thomasnoest dot nl
28.11.2008 22:54
Note on the selfmade empty function below:

function_exists() returns false on language constructs and empty is a language construct.
nizamgok at gmail dot com
27.10.2008 15:52
By definition empty( mixed* $var  ) cannot accept all types. For example, define constants will cause error if you try to test them.

* mixed indicates that a parameter may accept multiple (but not necessarily all) types.

This will produce error:
define("CONSTANT", "Hello world.");
var_dump( empty( CONSTANT ) );

At  first, this seemed to me very legal, but then I realized the fact that it just doesn't work.
justin at booleangate dot org
23.08.2008 1:59
How about this improvement to Karl Jung's my_empty

<?php
function my_empty($val) {
   
$val = trim($val);
  
    return empty(
$val) && $val !== 0;
}
?>
Anonymous
20.08.2008 23:41
To add on to what anon said, what's happening in john_jian's example seems unusual because we don't see the implicit typecasting going on behind the scenes.  What's really happening is:

$a = '';
$b = 0;
$c = '0';

(int)$a == $b -> true, because any string that's not a number gets converted to 0
$b==(int)$c -> true, because the int in the string gets converted
and
$a==$c -> false, because they're being compared as strings, rather than integers.  (int)$a==(int)$c should return true, however.

Note: I don't remember if PHP even *has* typecasting, much less if this is the correct syntax.  I'm just using something for the sake of examples.
tom at tomwardrop dot com
22.05.2008 14:01
In reply to "admin at ninthcircuit dot info",

Using str_replace is unnecessary. I would encourage the use of trim which would most likely be faster (haven't tested) and easier. Trim also takes care of other white space like line breaks and tabs. Actually, in most of the applications I code, I use a multi-dimensional array map function with trim on the Super Globals such as $_POST, $_GET and $_COOKIE as so far, there hasn't been an instance where I would want any user input to begin or end with whitespace. The good thing about doing this is that you never have to worry about 'trimming' your input which makes your code easier and more reliable (incase you forget to trim some input).
Greg Hartwig
2.05.2008 23:55
David from CodeXplorer:
>> The ONLY reason to use empty() is for code readability. It is the same as an IF/ELSE check.
>> So, don't bother using EMPTY in the real world.

This is NOT true.  empty() will not generate warnings if you're testing against an undefined variable as a simple boolean check will.  On production systems, warnings are usually shut off, but they are often active on development systems.

You could test a flag with
   <?php if ($flagvar)  ... ?>
but this can generate a warning if $flagvar is not set.

Instead of
   <?php if (isset($flagvar) && $flagvar)  ... ?>
you can simply use
   <?php if (!empty($flagvar))  ... ?>

for easy readability without warnings.
David from CodeXplorer
11.03.2008 5:29
Mad Hampster did  his test wrong. empty is NOT faster than a simple boolean check. The ONLY reason to use empty() is for code readability. It is the same as an IF/ELSE check. But if you are dealing with intermediate or higher level coders this function has no other benefit.

So, don't bother using EMPTY in the real world.

I ran an array with 5000 simple true/false values through four checks (both types twice) in case of any gain one type might have by going first. These are my results generated one one page request. (PHP5)

0.015328 Time EMPTY
0.014281 Time IF/ELSE
0.015239 Time EMPTY
0.013404 Time IF/ELSE

The page was accessed a couple times to reduce caching effects.
Andrea Giammarchi
31.01.2008 16:34
In addiction to Ed comment:
http://uk.php.net/manual/en/function.empty.php#80106

if an instance variable is assigned with an empty value, i.e. false, empty returns true.

<?php
class TestEmpty{
    protected          
$empty;
    public  function   
__construct(){
       
var_dump(empty($this->empty)); // true
       
$this->empty = false;
       
var_dump(empty($this->empty)); // true
   
}
}
new
TestEmpty;
?>

I think this is an expected behaviour but at the same time the note about classes variables is too ambiguous.

''var $var; (a variable declared, but without a value in a class)''

Please change them into something like:
''var $var; (a variable undeclared or declared with an empty value in a class)''
jay at w3prodigy dot com
28.01.2008 19:59
Also note, that if you have a URI that looks like this:

/page/index.php?query=

performing isset($_GET['query']) will return TRUE. as query is set, though null, in the QUERY.

To counteract this behavior, check isset($_GET['query']) and !empty($_GET['query']) as empty will detect the null value.
Ed
29.12.2007 21:08
Also, it doesn't appear to mention in the documentation, if a variable hasn't previously been declared, empty also returns true.

E.g.
var $bar;
empty( $bar ); // declared variable returns true.
empty( $foo ); // undeclared variable also returns true.

The closest the documentation comes to saying this is:
"var $var; (a variable declared, but without a value in a class)"
which isn't really the same, as the variable doesn't necessarily have to be declared first.
MaD HamsteR
12.12.2007 16:33
SAME RESULT! But somehow using empty() function is faster for about 10-13%

<?php

$array
[] = "";
$array[] = '';
$array[] = 0;
$array[] = "0";
$array[] = NULL;
$array[] = false;
$array[] = array();
$array[] = $var;

foreach(
$array as $value){
    echo (!empty(
$value))? 'Not empty!' : 'Empty!';
    echo
'<br />'."\r\n";
}

echo
'<br />'."\r\n";

foreach(
$array as $value){
    echo (
$value)? 'Not empty!' : 'Empty!';
    echo
'<br />'."\r\n";
}

?>
EllisGL
4.10.2007 23:48
Here's what I do for the zero issue issue:
if($val == '' && $val !== 0 && $val !== '0')
Antone Roundy
15.09.2007 15:55
There's a faster and easier to write method than (isset($a) && strlen($a)) -- isset($a{0}). It evaluates to false if $a is not set or if it has zero length (ie. it's first character is not set). My tests indicate that it's about 33% faster.
rkulla2 at gmail dot com
6.09.2007 0:57
Since I didn't like how empty() considers 0 and "0" to be empty (which can easily lead to bugs in your code), and since it doesn't deal with whitespace, i created the following function:

<?php
function check_not_empty($s, $include_whitespace = false)
{
    if (
$include_whitespace) {
       
// make it so strings containing white space are treated as empty too
       
$s = trim($s);
    }
    return (isset(
$s) && strlen($s)); // var is set and not an empty string ''
}
?>

Instead of saying if (!empty($var)) { // it's not empty } you can just say if (check_not_empty($var)) { // it's not empty }.

If you want strings that only contain whitespace (such as tabs or spaces) to be treated as empty then do: check_not_empty($var, 1)

If you want to check if a string IS empty then do: !check_not_empty($var).

So, whenever you want to check if a form field both exists and contains a value just do: if (check_not_empty($_POST['foo'], 1))

no need to do if (isset() && !empty()) anymore =]
florian.sonner [at] t-online.de
11.06.2007 21:06
Since a few people here mentioned that empty will not work with magic-overloading ("__get($var)"):

empty(..) goes the same way as isset(..) do, to check if a property exists. Thus you have to override the magic-function __isset($var) to produce correct results for empty(..) in combination with a magic-overloaded property.
nobody at example dot com
28.02.2006 21:06
Re: inerte is my gmail.com username's comment:

While that may be true, those two statements (empty($var), $var == '') are NOT the same. When programming for web interfaces, where a user may be submitting '0' as a valid field value, you should not be using empty().

<?php
    $str
= '0';

   
// outputs 'empty'
   
echo empty($str) ? 'empty' : 'not empty';

   
// outputs 'not empty'
   
echo $str == '' ? 'empty' : 'not empty';
?>
nahpeps at gmx dot de
19.08.2005 12:14
When using empty() on an object variable that is provided by the __get function, empty() will always return true.

For example:

<?php
class foo {
  
   public function
__get($var) {
      if (
$var == "bar") {
         return
"bar";  
      }  
   }  
}
$object_foo = new foo();
echo
'$object_foo->bar is ' . $object_foo->bar;
if (empty(
$object_foo->bar)) {
   echo
'$object_foo->bar seems to be empty';  
}
?>

produces the following output:
$object_foo->bar is bar
$object_foo->bar seems to be empty
jmarbas at hotmail dot com
1.07.2005 18:10
empty($var) will return TRUE if $var is empty (according to the definition of 'empty' above) AND if $var is not set.

I know that the statement in the "Return Values" section of the manual already says this in reverse:

"Returns FALSE if var has a non-empty and non-zero value."

but I was like "Why is this thing returning TRUE for unset variables???"... oh i see now... Its supposed to return TRUE for unset variables!!!

<?php
  ini_set
('error_reporting',E_ALL);
 
ini_set('display_errors','1');
  empty(
$var);
?>
admin at ninthcircuit dot info
24.05.2005 19:14
Something to note when using empty():

empty() does not see a string variable with nothing but spaces in it as "empty" per se.

Why is this relevant in a PHP application? The answer is.. if you intend to use empty() as a means of input validation, then a little extra work is necessary to make sure that empty() evaluates input with a more favorable outcome.

Example:
<?php
  $spaces
= "       ";
 
/* This will return false! */
 
if (empty($spaces))
     print
"This will never be true!";
  else
     print
"Told you!";
?>

To make empty() behave the way you would expect it to, use str_replace().

<?php
  $spaces
= str_replace(" ","","      ");
 
/* This will return true! */
 
if (empty($spaces))
      print
"This will always be true!";
  else
      print
"Told you!";
?>

This might seem trivial given the examples shown above; however, if one were to be storing this information in a mySQL database (or your preferred DB of choice), it might prove to be problematic for retrieval of it later on.
paul at worldwithoutwalls dot co dot uk
22.05.2004 19:09
Note the exceptions when it comes to decimal numbers:

<?php
$a
= 0.00;
$b = '0.00';
echo (empty(
$a)? "empty": "not empty"); //result empty
echo (empty($b)? "empty": "not empty"); //result not empty
//BUT...
$c = intval($b);
echo (empty(
$c)? "empty": "not empty"); //result empty
?>

For those of you using MySQL, if you have a table with a column of decimal type, when you do a SELECT, your data will be returned as a string, so you'll need to do apply intval() before testing for empty.

e.g.
TABLE t has columns id MEDIUMINT and d DECIMAL(4,2)
and contains 1 row where id=1, d=0.00
<?php
$q
= "SELECT * FROM t";
$res = mysql_query($q);
$row = mysql_fetch_assoc($res);
echo (empty(
$row['d'])? "empty": "not empty"); //result not empty
?>



PHP Powered Diese Seite bei php.net
The PHP manual text and comments are covered by the Creative Commons Attribution 3.0 License © the PHP Documentation Group - Impressum - mail("TO:Reinhard Neidl",...)