isset

(PHP 4, PHP 5, PHP 7, PHP 8)

issetDetermina si una variable está definida y no es null

Descripción

isset(mixed $var, mixed $... = ?): bool

Determina si una variable está definida y no es null.

Si una variable ha sido removida con unset(), esta ya no estará definida. isset() devolverá false si prueba una variable que ha sido definida como null. También tenga en cuenta que un byte null ("\0") no es equivalente a la constante null de PHP.

Si son pasados varios parámetros, entonces isset() devolverá true únicamente si todos los parámetros están definidos. La evaluación se realiza de izquierda a derecha y se detiene tan pronto como se encuentre una variable no definida.

Parámetros

var

La variable a ser evaluada.

...

Otra variable...

Valores devueltos

Devuelve true si var existe y tiene un valor distinto de null, false de lo contrario.

Historial de cambios

Versión Descripción
5.4.0

Comprobación de indices no numéricos de strings ahora retorna false.

Ejemplos

Ejemplo #1 Ejemplos isset()

<?php

$var
= '';

// Esto evaluará a TRUE así que el texto se imprimirá.
if (isset($var)) {
echo
"Esta variable está definida, así que se imprimirá";
}

// En los siguientes ejemplo usaremos var_dump para imprimir
// el valor devuelto por isset().

$a = "prueba";
$b = "otraprueba";

var_dump(isset($a)); // TRUE
var_dump(isset($a, $b)); // TRUE

unset ($a);

var_dump(isset($a)); // FALSE
var_dump(isset($a, $b)); // FALSE

$foo = NULL;
var_dump(isset($foo)); // FALSE

?>

También trabaja con elementos en matrices:

<?php

$a
= array ('test' => 1, 'hello' => NULL, 'pie' => array('a' => 'apple'));

var_dump(isset($a['test'])); // TRUE
var_dump(isset($a['foo'])); // FALSE
var_dump(isset($a['hello'])); // FALSE

// La clave 'helo' es igual a NULL así que no se considera definida
// Si desea comprobar los valores NULL clave, intente:
var_dump(array_key_exists('hello', $a)); // TRUE

// Comprobando valores de arrays con más profunidad
var_dump(isset($a['pie']['a'])); // TRUE
var_dump(isset($a['pie']['b'])); // FALSE
var_dump(isset($a['cake']['a']['b'])); // FALSE

?>

Notas

Advertencia

isset() sólo trabaja con variables, ya que pasar cualquier otra cosa dará como resultado un error de intérprete. Para comprobar si se han definidoconstantes use la función defined().

Nota: Puesto que esto es una construcción del lenguaje y no una función, no puede ser llamada usando funciones variables.

Nota:

Cuando se utiliza isset() sobre las propiedades de objetos inaccesibles, el método sobrecargado __isset() será llamado, si se declara.

Ejemplo #2 isset() en indices de String

PHP 5.4 cambia ahora el comportamiendo de isset() cuando son pasados indices de string.

<?php
$expected_array_got_string
= 'somestring';
var_dump(isset($expected_array_got_string['some_key']));
var_dump(isset($expected_array_got_string[0]));
var_dump(isset($expected_array_got_string['0']));
var_dump(isset($expected_array_got_string[0.5]));
var_dump(isset($expected_array_got_string['0.5']));
var_dump(isset($expected_array_got_string['0 Mostel']));
?>

Salida del ejemplo anterior en PHP 5.3:

bool(true)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)

Salida del ejemplo anterior en PHP 5.4:

bool(false)
bool(true)
bool(true)
bool(true)
bool(false)
bool(false)

Ver también

add a note add a note

User Contributed Notes 30 notes

up
82
p_ignorethis_lbowers at gmail dot com
7 years ago
I, too, was dismayed to find that isset($foo) returns false if ($foo == null). Here's an (awkward) way around it.

unset($foo);
if (compact('foo') != array()) {
  do_your_thing();
}

Of course, that is very non-intuitive, long, hard-to-understand, and kludgy. Better to design your code so you don't depend on the difference between an unset variable and a variable with the value null. But "better" only because PHP has made this weird development choice.

In my thinking this was a mistake in the development of PHP. The name ("isset") should describe the function and not have the desciption be "is set AND is not null". If it was done properly a programmer could very easily do (isset($var) || is_null($var)) if they wanted to check for this!

A variable set to null is a different state than a variable not set - there should be some easy way to differentiate. Just my (pointless) $0.02.
up
24
kurdtpage at gmail dot com
7 years ago
The new (as of PHP7) 'null coalesce operator' allows shorthand isset. You can use it like so:

<?php
// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>

Quoted from http://php.net/manual/en/migration70.new-features.php#migration70.new-features.null-coalesce-op
up
37
a dot schaffhirt at sedna-soft dot de
15 years ago
You can safely use isset to check properties and subproperties of objects directly. So instead of writing

    isset($abc) && isset($abc->def) && isset($abc->def->ghi)

or in a shorter form

    isset($abc, $abc->def, $abc->def->ghi)

you can just write

    isset ($abc->def->ghi)

without raising any errors, warnings or notices.

Examples
<?php
    $abc
= (object) array("def" => 123);
   
var_dump(isset($abc));                // bool(true)
   
var_dump(isset($abc->def));           // bool(true)
   
var_dump(isset($abc->def->ghi));      // bool(false)
   
var_dump(isset($abc->def->ghi->jkl)); // bool(false)
   
var_dump(isset($def));                // bool(false)
   
var_dump(isset($def->ghi));           // bool(false)
   
var_dump(isset($def->ghi->jkl));      // bool(false)

   
var_dump($abc);                       // object(stdClass)#1 (1) { ["def"] => int(123) }
   
var_dump($abc->def);                  // int(123)
   
var_dump($abc->def->ghi);             // null / E_NOTICE: Trying to get property of non-object
   
var_dump($abc->def->ghi->jkl);        // null / E_NOTICE: Trying to get property of non-object
   
var_dump($def);                       // null / E_NOTICE: Trying to get property of non-object
   
var_dump($def->ghi);                  // null / E_NOTICE: Trying to get property of non-object
   
var_dump($def->ghi->jkl);             // null / E_NOTICE: Trying to get property of non-object
?>
up
32
Daniel Klein
11 years ago
How to test for a variable actually existing, including being set to null. This will prevent errors when passing to functions.

<?php
// false
var_export(
 
array_key_exists('myvar', get_defined_vars())
);

$myvar;
// false
var_export(
 
array_key_exists('myvar', get_defined_vars())
);

$myvar = null;
// true
var_export(
 
array_key_exists('myvar', get_defined_vars())
);

unset(
$myvar);
// false
var_export(
 
array_key_exists('myvar', get_defined_vars())
);

if (
array_key_exists('myvar', get_defined_vars())) {
 
myfunction($myvar);
}
?>

Note: you can't turn this into a function (e.g. is_defined($myvar)) because get_defined_vars() only gets the variables in the current scope and entering a function changes the scope.
up
30
beuc at beuc dot net
17 years ago
"empty() is the opposite of (boolean) var, except that no warning is generated when the variable is not set."

So essentially
<?php
if (isset($var) && $var)
?>
is the same as
<?php
if (!empty($var))
?>
doesn't it? :)

!empty() mimics the chk() function posted before.
up
28
yaogzhan at gmail dot com
18 years ago
in PHP5, if you have

<?PHP
class Foo
{
    protected
$data = array('bar' => null);

    function
__get($p)
    {
        if( isset(
$this->data[$p]) ) return $this->data[$p];
    }
}
?>

and
<?PHP
$foo
= new Foo;
echo isset(
$foo->bar);
?>
will always echo 'false'. because the isset() accepts VARIABLES as it parameters, but in this case, $foo->bar is NOT a VARIABLE. it is a VALUE returned from the __get() method of the class Foo. thus the isset($foo->bar) expreesion will always equal 'false'.
up
25
Anonymous
17 years ago
I tried the example posted previously by Slawek:

$foo = 'a little string';
echo isset($foo)?'yes ':'no ', isset($foo['aaaa'])?'yes ':'no ';

He got yes yes, but he didn't say what version of PHP he was using.

I tried this on PHP 5.0.5 and got:  yes no

But on PHP 4.3.5 I got:  yes yes

Apparently, PHP4 converts the the string 'aaaa' to zero and then returns the string character at that position within the string $foo, when $foo is not an array. That means you can't assume you are dealing with an array, even if you used an expression such as isset($foo['aaaa']['bbb']['cc']['d']), because it will return true also if any part is a string.

PHP5 does not do this. If $foo is a string, the index must actually be numeric (e.g. $foo[0]) for it to return the indexed character.
up
19
Cuong Huy To
12 years ago
1) Note that isset($var) doesn't distinguish the two cases when $var is undefined, or is null. Evidence is in the following code.

<?php
unset($undefined);
$null = null;
if (
true === isset($undefined)){echo 'isset($undefined) === true'} else {echo 'isset($undefined) === false'); // 'isset($undefined) === false'
if (true === isset($null)){echo 'isset($null) === true'} else {echo 'isset($null) === false');              // 'isset($null)      === false'
?>

2) If you want to distinguish undefined variable with a defined variable with a null value, then use array_key_exist

<?php
unset($undefined);
$null = null;

if (
true !== array_key_exists('undefined', get_defined_vars())) {echo '$undefined does not exist';} else {echo '$undefined exists';} // '$undefined does not exist'
if (true === array_key_exists('null', get_defined_vars())) {echo '$null exists';} else {echo '$null does not exist';}                // '$null exists'
?>
up
18
mandos78 AT mail from google
15 years ago
Careful with this function "ifsetfor" by soapergem, passing by reference means that if, like the example $_GET['id'], the argument is an array index, it will be created in the original array (with a null value), thus causing posible trouble with the following code. At least in PHP 5.

For example:

<?php
$a
= array();
print_r($a);
ifsetor($a["unsetindex"], 'default');
print_r($a);
?>

will print

Array
(
)
Array
(
    [unsetindex] =>
)

Any foreach or similar will be different before and after the call.
up
17
muratyaman at gmail dot com
16 years ago
To organize some of the frequently used functions..

<?php

/**
* Returns field of variable (arr[key] or obj->prop), otherwise the third parameter
* @param array/object $arr_or_obj
* @param string $key_or_prop
* @param mixed $else
*/
function nz($arr_or_obj, $key_or_prop, $else){
 
$result = $else;
  if(isset(
$arr_or_obj)){
    if(
is_array($arr_or_obj){
      if(isset(
$arr_or_obj[$key_or_prop]))
       
$result = $arr_or_obj[$key_or_prop];
    }elseif(
is_object($arr_or_object))
      if(isset(
$arr_or_obj->$key_or_prop))
       
$result = $arr_or_obj->$key_or_prop;
    }
  }
  return
$result;
}

/**
* Returns integer value using nz()
*/
function nz_int($arr_or_obj, $key_or_prop, $else){
  return
intval(nz($arr_or_obj, $key_or_prop, $else));
}

$my_id = nz_int($_REQUEST, 'id', 0);
if(
$my_id > 0){
 
//why?
}
?>
up
4
borshak at gmail dot com
5 years ago
Would be nice to have is_set() alias for more language consistency (alike of is_int, is_bull so on).
up
6
ayyappan dot ashok at gmail dot com
7 years ago
Return Values :
Returns TRUE if var exists and has value other than NULL, FALSE otherwise.

<?php
$a
=NULL;
$b=FALSE; //The out put was TRUE.
$c=TRUE;
$d='';
$e="";
if(isset(
$b)):
echo
"TRUE";
else:
echo
"FALSE";   
endif;
?>
Could any one explain me in clarity.
up
14
anonymousleaf at gmail dot com
16 years ago
isset expects the variable sign first, so you can't add parentheses or anything.

<?php
    $foo
= 1;
    if(isset((
$foo))) { // Syntax error at isset((
       
$foo = 2;
    }
?>
up
14
soywiz at php dot net
17 years ago
Sometimes you have to check if an array has some keys. To achieve it you can use "isset" like this: isset($array['key1'], $array['key2'], $array['key3'], $array['key4'])
You have to write $array all times and it is reiterative if you use same array each time.

With this simple function you can check if an array has some keys:

<?php
function isset_array() {
    if (
func_num_args() < 2) return true;
   
$args = func_get_args();
   
$array = array_shift($args);
    if (!
is_array($array)) return false;
    foreach (
$args as $n) if (!isset($array[$n])) return false;
    return
true;
}
?>

Use: isset_array($array, 'key1', 'key2', 'key3', 'key4')
First parameter has the array; following parameters has the keys you want to check.
up
4
Hayley Watson
6 years ago
If you regard isset() as indicating whether the given variable has a value or not, and recall that NULL is intended to indicate that a value is _absent_ (as said, somewhat awkwardly, on its manual page), then its behaviour is not at all inconsistent or confusing.

It's not just to check for uninitialised variables - a lot of the time those are just due to sloppy coding. There are other ways a variable could fail to have a value (e.g., it's meant to hold the value returned from a function call but the function didn't have a value to return) where uninitialising the variable would not be an option nor even make sense (e.g., depending on what was to be done with the returned value).
up
5
andreasonny83 at gmail dot com
8 years ago
Here is an example with multiple parameters supplied

<?php
$var
= array();
$var['val1'] = 'test';
$var['val2'] = 'on';

if ( isset(
$var['val1'], $var['val2'] ) && $var['val2'] === 'on' ) {
    unset(
$var['val1'] );
}
print_r( $var );
?>

This will output:
Array
(
    [val2] => on
)

The following code does the same calling "isset" 2 times:

<?php
$var
= array();
$var['val1'] = 'test';
$var['val2'] = 'on';

if ( isset(
$var['val1'] ) && isset( $var['val2'] ) && $var['val2'] === 'on' ) {
    unset(
$var['val1'] );
}
print_r( $var );
?>
up
8
uramihsayibok, gmail, com
10 years ago
Note that isset() is not recursive as of the 5.4.8 I have available here to test with: if you use it on a multidimensional array or an object it will not check isset() on each dimension as it goes.

Imagine you have a class with a normal __isset and a __get that fatals for non-existant properties. isset($object->nosuch) will behave normally but isset($object->nosuch->foo) will crash. Rather harsh IMO but still possible.

<?php

class FatalOnGet {

   
// pretend that the methods have implementations that actually try to do work
    // in this example I only care about the worst case conditions

   
public function __get($name) {
        echo
"(getting {$name}) ";

       
// if property does not exist {
           
echo "Property does not exist!";
            exit;
       
// }
   
}

    public function
__isset($name) {
        echo
"(isset {$name}?) ";
       
// return whether the property exists
       
return false;
    }

}

$obj = new FatalOnGet();

// works
echo "Testing if ->nosuch exists: ";
if (isset(
$obj->nosuch)) echo "Yes"; else echo "No";

// fatals
echo "\nTesting if ->nosuch->foo exists: ";
if (isset(
$obj->nosuch->foo)) echo "Yes"; else echo "No";

// not executed
echo "\nTesting if ->irrelevant exists: ";
if (isset(
$obj->irrelevant)) echo "Yes"; else echo "No";

?>

    Testing if ->nosuch exists: No
    Testing if ->nosuch->foo exists: Property does not exist!

Uncomment the echos in the methods and you'll see exactly what happened:

    Testing if ->nosuch exists: (isset nosuch?) No
    Testing if ->nosuch->foo exists: (getting nosuch) Property does not exist!

On a similar note, if __get always returns but instead issues warnings or notices then those will surface.
up
11
Andrew Penry
18 years ago
The following is an example of how to test if a variable is set, whether or not it is NULL. It makes use of the fact that an unset variable will throw an E_NOTICE error, but one initialized as NULL will not.

<?php

function var_exists($var){
    if (empty(
$GLOBALS['var_exists_err'])) {
        return
true;
    } else {
        unset(
$GLOBALS['var_exists_err']);
        return
false;
    }
}

function
var_existsHandler($errno, $errstr, $errfile, $errline) {
  
$GLOBALS['var_exists_err'] = true;
}

$l = NULL;
set_error_handler("var_existsHandler", E_NOTICE);
echo (
var_exists($l)) ? "True " : "False ";
echo (
var_exists($k)) ? "True " : "False ";
restore_error_handler();

?>

Outputs:
True False

The problem is, the set_error_handler and restore_error_handler calls can not be inside the function, which means you need 2 extra lines of code every time you are testing. And if you have any E_NOTICE errors caused by other code between the set_error_handler and restore_error_handler they will not be dealt with properly. One solution:

<?php

function var_exists($var){
   if (empty(
$GLOBALS['var_exists_err'])) {
       return
true;
   } else {
       unset(
$GLOBALS['var_exists_err']);
       return
false;
   }
}

function
var_existsHandler($errno, $errstr, $errfile, $errline) {
   
$filearr = file($errfile);
    if (
strpos($filearr[$errline-1], 'var_exists') !== false) {
       
$GLOBALS['var_exists_err'] = true;
        return
true;
    } else {
        return
false;
    }
}

$l = NULL;
set_error_handler("var_existsHandler", E_NOTICE);
echo (
var_exists($l)) ? "True " : "False ";
echo (
var_exists($k)) ? "True " : "False ";
is_null($j);
restore_error_handler();

?>

Outputs:
True False
Notice: Undefined variable: j in filename.php on line 26

This will make the handler only handle var_exists, but it adds a lot of overhead. Everytime an E_NOTICE error happens, the file it originated from will be loaded into an array.
up
9
talbutt(at)mail(dot)med(dot)upenn(edu)
16 years ago
In PHP 5.2.3, really returns true if the variable is set to null.
up
7
mark dot fabrizio at gmail dot com
15 years ago
I know this is probably not the recommended way to do this, but it seems to work fine for me. Instead of the normal isset check to extract variables from arrays (like $_REQUEST), you can use the @ prefix to squelch any errors.

For example, instead of:
<?php
$test
= isset($_REQUEST['test']) ? $_REQUEST['test'] : null;
?>
you can use:
<?php
$test
= @$_REQUEST['test'];
?>

It saves some typing, but doesn't give the opportunity to provide a default value. If 'test' is not an assigned key for $_REQUEST, the assigned value will be null.
up
1
venimus at gmail dot com
5 years ago
Be warned that before checking an array key existence with isset() the key will be typecasted to integer if it is not a string or integer!

See Example #2 in http://php.net/manual/en/language.types.array.php

I.e.

$a = ['test']; // 'test' will have key 0
$key = false;

var_dump(isset($a[$key]) ); // true, because false will be typecasted to 0

It is not a problem with isset but rather the lose typing when you access keys in arrays
up
6
francois vespa
13 years ago
Now this is how to achieve the same effect (ie, having isset() returning true even if variable has been set to null) for objects and arrays

<?php

// array

$array=array('foo'=>null);

return isset(
$array['foo']) || array_key_exists('foo',$array)
  ?
true : false ; // return true

return isset($array['inexistent']) || array_key_exists('inexistent',$array)
  ?
true : false ; // return false

// static class

class bar

{
  static
$foo=null;
}

return isset(
bar::$foo) || array_key_exists('foo',get_class_vars('bar'))
  ?
true : false ; // return true

return isset(bar::$inexistent) || array_key_exists('inexistent',get_class_vars('bar'))
  ?
true : false ; // return false

// object

class bar
{
    public
$foo=null;
}

$bar=new bar();

return isset(
$bar->foo) || array_key_exists('foo',get_object_vars($bar))
  ?
true : false ; // return true

return isset($bar->inexistent) || array_key_exists('inexistent',get_object_vars($bar))
  ?
true : false ; // return true

// stdClass

$bar=new stdClass;
$bar->foo=null;

return isset(
$bar->foo) || array_key_exists('foo',get_object_vars($bar))
  ?
true : false ; // return true

return isset($bar->inexistent) || array_key_exists('inexistent',get_object_vars($bar))
  ?
true : false ; // return true

?>
up
4
Anl zselgin
14 years ago
Note: Because this is a language construct and not a function, it cannot be called using variable functions.

So why it is under "Variable handling Functions". Maybe there should be some good documentation field for language constructs.
up
0
razvan_bc at yahoo dot com
5 years ago
In these days you can use ISSET to compare a sting length
COOOL! I love php !!!!

<?php
//FIRST:try to run the script like this,
//THEN: try to uncomment the seccond $str=

$yes="SURE!!!";
$no="NOPE !";

$str="12345";//the string is long 5 bytes ?
//$str="123456";

echo !isset($str{5}) ? $yes : $no;

?>
up
3
packard_bell_nec at hotmail dot com
16 years ago
Note: isset() only checks variables as anything else will result in a parse error. In other words, the following will not work: isset(trim($name)).

isset() is the opposite of is_null($var) , except that no warning is generated when the variable is not set.
up
3
randallgirard at hotmail dot com
17 years ago
The unexpected results of isset has been really frustrating to me. Hence, it doesn't work how you'd think it would, (as documented) a var currently in the scope with a null value will return false.

Heres a quick solution, perhaps there are better ways of going about this, but heres my solution...

<?php
function is_set( $varname, $parent=null ) {
  if ( !
is_array( $parent ) && !is_object($parent) ) {
   
$parent = $GLOBALS;
  }
  return
array_key_exists( $varname, $parent );
}
?>

Hence, $varname should be a mixed value of var's to check for, and $parent can be an array or object, which will default to the GLOBAL scope. See the documentation of array_key_exists for further information.

This will allow to check if a var is in the current scope, object, or array... Whether it's a null, false, true, or any value. It depends on ARRAY_KEY_EXISTS for it's functionality which also works with Objects. Feel free to improve on this anyone ;D
up
2
Ashus
15 years ago
Note that array keys are case sensitive.

<?php
$ar
['w'] = true;

var_dump(isset($ar['w']),
      isset(
$ar['W']));
?>

will report:
bool(true) bool(false)
up
3
pianistsk8er at gmail dot com
19 years ago
This function is very useful while calling to the URL to specify which template to be used on certain parts of your application.

Here is an example...

<?php

    $cat
= $_GET['c'];
   
$id = $_GET['id'];   
   
$error = 'templates/error.tpl';

    if( isset(
$cat))
    {
        if( isset(
$id))
        {
           
$var = 'templates/pics/' . $cat . '-' . $id . '.tpl';
            if (
is_file($var))
            {
                include(
$var);
            }
            else
            {
                include(
$error);
            }
        }
        else
        {
           
$var = 'templates/pics/' . $cat . '.tpl';       
            if (
is_file($var))
            {
                include(
$var);
            }
            else
            {
                include(
$error);
            }
        }
    }
    else
    {
        include(
'templates/alternative.'.tpl);
    }

?>

You can see several uses of the isset function being used to specify wheter a template is to be called upon or not.  This can easily prevent other generic PHP errors.
up
2
Tee Cee
17 years ago
In response to 10-Feb-2006 06:02, isset($v) is in all (except possibly buggy) cases equivalent to !is_null($v). And no, it doesn't actually test if a variable is set or not by my definition "$v is set if unset($v) has no effect".

<?php
unset($c); //force $c to be unset
var_dump($a=&$c); // NULL, but this actually sets $a and $c to the 'same' NULL.
var_dump(isset($c)); // bool(false)
var_dump($a = 5); // int(5)
var_dump($c); // int(5)

unset($c);
var_dump($a=&$c); // NULL
var_dump(isset($c)); // bool(false)
unset($c);
var_dump($a = 5); // int(5)
var_dump($c); // NULL
?>

In the following example, we see an alternate method of testing if a variable is actually set or not:
<?php
var_dump
(array_key_exists('c',get_defined_vars())); // false
var_dump(isset($c));                                // also false
var_dump($c);                                       // manipulate $c a bit...
var_dump((string)$c);
var_dump(print_r($c,true));
var_dump($a=$c);
var_dump(array_key_exists('c',get_defined_vars())); // ... still false
var_dump($c = NULL);                                // this sets $c
var_dump(array_key_exists('c',get_defined_vars())); // true!
var_dump(isset($c));                                // false; isset() still says it's unset
unset($c);                                          // actually unset it
var_dump(array_key_exists('c',get_defined_vars())); // false
var_dump($a=&$c);                                          
var_dump(array_key_exists('c',get_defined_vars())); // true!
unset($c);                                          // unset it again
var_dump(&$c);                                      // &NULL
var_dump(array_key_exists('c',get_defined_vars())); // true!
?>

Obviously, null values take up space (or they wouldn't show up in get_defined_vars). Also, note that &$v sets $v to NULL if it is unset.
up
0
Slawek Petrykowski
18 years ago
<?php
$foo
= 'a little string';
echo isset(
$foo)?'yes ':'no ', isset($foo['aaaa'])?'yes ':'no ';
>

results with unexpected values:
yes yes

Well
, it is necessary to check type of $foo first !
To Top