empty
Determine whether a variable is considered to be empty. A variable is considered empty if it does not exist or if its value equals false . empty() does not generate a warning if the variable does not exist.
Parameters
No warning is generated if the variable does not exist. That means empty() is essentially the concise equivalent to !isset($var) || $var == false.
Return Values
Returns true if var does not exist or has a value that is empty or equal to zero, aka falsey, see conversion to boolean. Otherwise returns false .
Examples
Example #1 A simple empty() / isset() comparison.
// Evaluates to true because $var is empty
if (empty( $var )) echo ‘$var is either 0, empty, or not set at all’ ;
>
// Evaluates as true because $var is set
if (isset( $var )) echo ‘$var is set even though it is empty’ ;
>
?>
Example #2 empty() on String Offsets
$expected_array_got_string = ‘somestring’ ;
var_dump (empty( $expected_array_got_string [ ‘some_key’ ]));
var_dump (empty( $expected_array_got_string [ 0 ]));
var_dump (empty( $expected_array_got_string [ ‘0’ ]));
var_dump (empty( $expected_array_got_string [ 0.5 ]));
var_dump (empty( $expected_array_got_string [ ‘0.5’ ]));
var_dump (empty( $expected_array_got_string [ ‘0 Mostel’ ]));
?>
The above example will output:
bool(true) bool(false) bool(false) bool(false) bool(true) bool(true)
Notes
Note: Because this is a language construct and not a function, it cannot be called using variable functions, or named arguments.
Note:
When using empty() on inaccessible object properties, the __isset() overloading method will be called, if declared.
See Also
- isset() — Determine if a variable is declared and is different than null
- __isset()
- unset() — Unset a given variable
- array_key_exists() — Checks if the given key or index exists in the array
- count() — Counts all elements in an array or in a Countable object
- strlen() — Get string length
- The type comparison tables
User Contributed Notes 36 notes
$testCase = array(
1 => » ,
2 => «» ,
3 => null ,
4 => array(),
5 => FALSE ,
6 => NULL ,
7 => ‘0’ ,
8 => 0 ,
foreach ( $testCase as $k => $v ) if (empty( $v )) echo »
$k => $v is empty» ;
>
>
/**
Output
1=> is empty
2=> is empty
3=> is empty
4=>Array is empty
5=> is empty
6=> is empty
7=>0 is empty
8=>0 is empty
**/
?>
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:
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:
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.
Php все элементы массива null
// Before php 5.4
$array = array(1,2,3);
// since php 5.4 , short syntax
$array = [1,2,3];
// I recommend using the short syntax if you have php version >= 5.4
Used to creating arrays like this in Perl?
Looks like we need the range() function in PHP:
$array = array_merge (array( ‘All’ ), range ( ‘A’ , ‘Z’ ));
?>
You don’t need to array_merge if it’s just one range:
There is another kind of array (php>= 5.3.0) produced by
$array = new SplFixedArray(5);
Standard arrays, as documented here, are marvellously flexible and, due to the underlying hashtable, extremely fast for certain kinds of lookup operation.
Supposing a large string-keyed array
$arr=[‘string1’=>$data1, ‘string2’=>$data2 etc. ]
when getting the keyed data with
php does *not* have to search through the array comparing each key string to the given key (‘string1’) one by one, which could take a long time with a large array. Instead the hashtable means that php takes the given key string and computes from it the memory location of the keyed data, and then instantly retrieves the data. Marvellous! And so quick. And no need to know anything about hashtables as it’s all hidden away.
However, there is a lot of overhead in that. It uses lots of memory, as hashtables tend to (also nearly doubling on a 64bit server), and should be significantly slower for integer keyed arrays than old-fashioned (non-hashtable) integer-keyed arrays. For that see more on SplFixedArray :
Unlike a standard php (hashtabled) array, if you lookup by integer then the integer itself denotes the memory location of the data, no hashtable computation on the integer key needed. This is much quicker. It’s also quicker to build the array compared to the complex operations needed for hashtables. And it uses a lot less memory as there is no hashtable data structure. This is really an optimisation decision, but in some cases of large integer keyed arrays it may significantly reduce server memory and increase performance (including the avoiding of expensive memory deallocation of hashtable arrays at the exiting of the script).
When creating arrays , if we have an element with the same value as another element from the same array, we would expect PHP instead of creating new zval container to increase the refcount and point the duplicate symbol to the same zval. This is true except for value type integer.
Example:
$arr = [‘bebe’ => ‘Bob’, ‘age’ => 23, ‘too’ => 23 ];
xdebug_debug_zval( ‘arr’ );
(refcount=2, is_ref=0)
array (size=3)
‘bebe’ => (refcount=1, is_ref=0)string ‘Bob’ (length=3)
‘age’ => (refcount=0, is_ref=0)int 23
‘too’ => (refcount=0, is_ref=0)int 23
but :
$arr = [‘bebe’ => ‘Bob’, ‘age’ => 23, ‘too’ => ’23’ ];
xdebug_debug_zval( ‘arr’ );
(refcount=2, is_ref=0)
array (size=3)
‘bebe’ => (refcount=1, is_ref=0)string ‘Bob’ (length=3)
‘age’ => (refcount=0, is_ref=0)int 23
‘too’ => (refcount=1, is_ref=0)string ’23’ (length=2)
or :
$arr = [‘bebe’ => ‘Bob’, ‘age’ => [1,2], ‘too’ => [1,2] ];
xdebug_debug_zval( ‘arr’ );
(refcount=2, is_ref=0)
array (size=3)
‘bebe’ => (refcount=1, is_ref=0)string ‘Bob’ (length=3)
‘age’ => (refcount=2, is_ref=0)
array (size=2)
0 => (refcount=0, is_ref=0)int 1
1 => (refcount=0, is_ref=0)int 2
‘too’ => (refcount=2, is_ref=0)
array (size=2)
0 => (refcount=0, is_ref=0)int 1
1 => (refcount=0, is_ref=0)int 2
This function makes (assoc.) array creation much easier:
function arr (. $array )< return $array ; >
?>
It allows for short syntax like:
$arr = arr ( x : 1 , y : 2 , z : 3 );
?>
Instead of:
$arr = [ «x» => 1 , «y» => 2 , «z» => 3 ];
// or
$arr2 = array( «x» => 1 , «y» => 2 , «z» => 3 );
?>
Sadly PHP 8.2 doesn’t support this named arguments in the «array» function/language construct.
Remove all `null` values from an array in PHP
A convenient method to remove all null values from an array in PHP is by using the array_filter() function. As the name suggests the method filters a given array, if you don’t supply your own filter function PHP filters out all values that evaluate as false in a condition; empty strings, 0 , false , null .
To explicitly only filter out the null values you should pass your own callback function to the array_filter() function that only returns false if a given value is equal to null .
Using an arrow function that would look like the following:
<?php $values = ['a', 'b', null, 'c']; $result = array_filter($values, fn ($value) => !is_null($value)); print_r($result); // Array // ( // [0] => a // [1] => b // [2] => c // ) As I mentioned above, if you don’t supply a callback function yourself PHP filters out all values that evaluate as false . So that includes other values besides null as well. But maybe that’s just what you need. In that case, see the example below:
<?php $values = ['a', '', null, false, []]; $result = array_filter($values); print_r($result); // Array // ( // [0] => a // )