isset

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

    isset — 检测变量是否已声明并且其值不为 null

    说明

    isset(mixed $var, mixed ...$vars): bool

    判断一个变量是否已设置, 即变量已被声明，且其值不为 null。

    如果一个变量已经被使用 unset() 释放，它将不再被认为已设置。

    若使用 isset() 测试一个被赋值为 null 的变量，将返回 false。 同时要注意的是 null 字符（"\0"）并不等同于 PHP 的 null 常量。

    如果一次传入多个参数，那么 isset() 只有在全部参数都已被设置时返回 true。 计算过程从左至右，中途遇到未设置的变量时就会立即停止。

    参数

    var

    要检查的变量。

    vars

    其他变量。

    返回值

    如果 var 存在并且值不是 null 则返回 true，否则返回 false。

    示例

    示例 #1 isset() 例子

    <?php

    $var     = '';

    // 结果为 TRUE，所以后边的文本将被打印出来。
    if (isset($var)) {
    echo     "This var is set so I will print.";
    }

    // 在后边的例子中，我们将使用 var_dump 输出 isset() 的返回值。
    // the return value of isset().

    $a = "test";
    $b = "anothertest";

    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

    ?>

    这对于数组中的元素也同样有效：

    <?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

    // 键 'hello' 的值等于 NULL，所以被认为是未置值的。
    // 如果想检测 NULL 键值，可以试试下边的方法。
    var_dump(array_key_exists('hello', $a)); // TRUE

    // Checking deeper array values
    var_dump(isset($a['pie']['a'])); // TRUE
    var_dump(isset($a['pie']['b'])); // FALSE
    var_dump(isset($a['cake']['a']['b'])); // FALSE

    ?>

    示例 #2 在字符串位移中使用 isset()

    <?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']));
    ?>

    以上示例会输出：

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

    注释

    警告

    isset() 只能用于变量，因为传递任何其它参数都将造成解析错误。若想检测常量是否已设置，可使用 defined() 函数。

    注意: 因为是语言构造器而不是函数，不能被 可变函数 或者 命名参数 调用。

    注意:

    如果使用 isset() 来检查对象无法访问的属性，如果 __isset() 方法已经定义则会调用这个重载方法。

    参见

    改进此页面

    了解如何改进此页面 • 提交拉取请求 • 报告一个错误
    ＋添加备注

    用户贡献的备注 19 notes

    up
    110
    p_ignorethis_lbowers at gmail dot com
    8 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
    41
    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
    1
    eckoson at gmail dot com
    1 year ago
    If you are annoyed by the behavior of isset() concerning null values, here is a handy function for you. its similar to array_key_exists but, its a lot more flexible and can check for multiple array keys across multiple arrays.
    Not recursive!
    Tested on php 8.1.6, linux
    <?php
    /**
    * is_set
    * @author DJ Eckoson
    * @link @eckosongh Facebook Page
    * checks whether variable names are set within the global space or they exists as an key and return if they are set (even if their values are null)
    * @param string $var_name
    * name of the first variable to check
    * @param array|null|string
    * optional array to check for key (if null, checks from $GLOBALS) OR
    * other variable names to check OR
    * other variable names and their associated arrays to their right (use null for global variables, optional if its the last parameter)
    * check examples below
    */
    function is_set(string $var_name, array|null|string ... $args): bool {
    $vars[$var_name] = null;
    if (    array_key_exists(0, $args)) {
    if (    is_array($args[0])) {
    $vars[$var_name] = $args[0];
    } elseif (    is_string($args[0])) {
    goto     main;
    }
    unset(    $args[0]);
    }
    main:
    if (    $args) {
    $args = array_reverse($args);
    $cur_array = null;
    array_walk($args, function ($value) use (&$cur_array, &$vars): void {
    if (!    is_string($value)) {
    $cur_array = $value;
    } else {
    $vars[$value] = $cur_array;
    }
    });
    }
    foreach (    $vars as $name => $array) {
    if (!    array_key_exists($name, $array??$GLOBALS)) return false;
    }
    return     true;
    }

    // Examples
    $arr1 = range(0, 5);
    $arr2 = [
    'a' => 1,
    'b' => 2,
    'c' => 'hELLO wORLD!'
    ];
    $gender = 'male';
    $age = 12;
    var_dump(is_set('age')); // true
    var_dump(is_set('age', null)); // true
    var_dump(is_set('age', $arr1)); // false
    var_dump(is_set('age', array())); // false
    var_dump(is_set('age', array('age' => 48))); // true
    var_dump(is_set('age', 'arr1', null, 'b', $arr2, 0, 3, 4, $arr1, 'gender')); // true
    var_dump(is_set('age', 'arr1', null, 'b', $arr2, 0, 3, 4, $arr1, 'gender', null)); // true

    $c=$d=$e=$a=2;
    $arr = [1,4];
    var_dump(is_set('a', 'c', null, 0, 1, $arr)); // true
    var_dump(is_set('a', 'c', null, 0, 4, $arr)); // false
    ?>
     Note:
    it won't work for variables declared locally inside a function;
    however you can use it for checking if array keys exists inside a function
    up
    36
    a dot schaffhirt at sedna-soft dot de
    16 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
    30
    yaogzhan at gmail dot com
    19 years ago
    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
    26
    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
    20
    soywiz at php dot net
    18 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
    8
    ayyappan dot ashok at gmail dot com
    8 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
    17
    mandos78 AT mail from google
    16 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
    13
    Cuong Huy To
    13 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
    6
    andreasonny83 at gmail dot com
    9 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
    10
    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
    10
    Andrew Penry
    19 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
    8
    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
    6
    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
    4
    Anl zselgin
    15 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
    Hayley Watson
    7 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
    -1
    Tee Cee
    18 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
    -2
    randallgirard at hotmail dot com
    18 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
    ＋添加备注
    To Top