Php list and exploded

list

Like array() , this is not really a function, but a language construct. list() is used to assign a list of variables in one operation. Strings can not be unpacked and list() expressions can not be completely empty.

Note:

Before PHP 7.1.0, list() only worked on numerical arrays and assumes the numerical indices start at 0.

Parameters

Return Values

Returns the assigned array.

Changelog

Version	Description
7.3.0	Support for reference assignments in array destructuring was added.
7.1.0	It is now possible to specify keys in list() . This enables destructuring of arrays with non-integer or non-sequential keys.

Examples

Example #1 list() examples

$info = array( ‘coffee’ , ‘brown’ , ‘caffeine’ );

// Listing all the variables
list( $drink , $color , $power ) = $info ;
echo » $drink is $color and $power makes it special.\n» ;

// Listing some of them
list( $drink , , $power ) = $info ;
echo » $drink has $power .\n» ;

// Or let’s skip to only the third one
list( , , $power ) = $info ;
echo «I need $power !\n» ;

// list() doesn’t work with strings
list( $bar ) = «abcde» ;
var_dump ( $bar ); // NULL
?>

Example #2 An example use of list()

$result = $pdo -> query ( «SELECT id, name FROM employees» );
while (list( $id , $name ) = $result -> fetch ( PDO :: FETCH_NUM )) echo «id: $id , name: $name \n» ;
>
?>

Example #3 Using nested list()

list( $a , list( $b , $c )) = array( 1 , array( 2 , 3 ));

Example #4 list() and order of index definitions

The order in which the indices of the array to be consumed by list() are defined is irrelevant.

$foo = array( 2 => ‘a’ , ‘foo’ => ‘b’ , 0 => ‘c’ );
$foo [ 1 ] = ‘d’ ;
list( $x , $y , $z ) = $foo ;
var_dump ( $foo , $x , $y , $z );

Gives the following output (note the order of the elements compared in which order they were written in the list() syntax):

array(4) < [2]=>string(1) "a" ["foo"]=> string(1) "b" [0]=> string(1) "c" [1]=> string(1) "d" > string(1) "c" string(1) "d" string(1) "a"

Example #5 list() with keys

As of PHP 7.1.0 list() can now also contain explicit keys, which can be given as arbitrary expressions. Mixing of integer and string keys is allowed; however, elements with and without keys cannot be mixed.

$data = [
[ «id» => 1 , «name» => ‘Tom’ ],
[ «id» => 2 , «name» => ‘Fred’ ],
];
foreach ( $data as [ «id» => $id , «name» => $name ]) echo «id: $id , name: $name \n» ;
>
echo PHP_EOL ;
list( 1 => $second , 3 => $fourth ) = [ 1 , 2 , 3 , 4 ];
echo » $second , $fourth \n» ;

The above example will output:

id: 1, name: Tom id: 2, name: Fred 2, 4

See Also

• each() — Return the current key and value pair from an array and advance the array cursor
• array() — Create an array
• extract() — Import variables into the current symbol table from an array

User Contributed Notes 25 notes

Since PHP 7.1, keys can be specified

exemple :
$array = [ ‘locality’ => ‘Tunis’ , ‘postal_code’ => ‘1110’ ];

list( ‘postal_code’ => $zipCode , ‘locality’ => $locality ) = $array ;

print $zipCode ; // will output 1110
print $locality ; // will output Tunis
?>

In PHP 7.1 we can do the following:

[ $a , $b , $c ] = [ ‘a’ , ‘b’ , ‘c’ ];
?>

Before, we had to do:

$info = array(‘kawa’, ‘brązowa’, ‘kofeina’);
list($a[0], $a[1], $a[2]) = $info;
var_dump($a);

One thing to note here is that if you define the array earlier, e.g.:
$a = [0, 0, 0];

the indexes will be kept in the correct order:

Thought that it was worth mentioning.

As noted, list() will give an error if the input array is too short. This can be avoided by array_merge()’ing in some default values. For example:

$parameter = ‘name’ ;
list( $a , $b ) = array_merge ( explode ( ‘=’ , $parameter ), array( true ) );
?>

However, you will have to array_merge with an array long enough to ensure there are enough elements (if $parameter is empty, the code above would still error).

An alternate approach would be to use array_pad on the array to ensure its length (if all the defaults you need to add are the same).

$parameter = ‘bob-12345’ ;
list( $name , $id , $fav_color , $age ) = array_pad ( explode ( ‘-‘ , $parameter ), 4 , » );
var_dump ( $name , $id , $fav_color , $age );
/* outputs
string(3) «bob»
string(5) «12345»
string(0) «»
string(0) «»
*/
?>

The example states the following:
// list() doesn’t work with strings
list( $bar ) = «abcde» ;
var_dump ( $bar );
// output: NULL
?>

If the string is in a variable however, it seems using list() will treat the string as an array:
$string = «abcde» ;
list( $foo ) = $string ;
var_dump ( $foo );
// output: string(1) «a»
?>

/**
* It seems you can skip listed values.
* Here’s an example to show what I mean.
*
* FYI works just as well with PHP 7.1 shorthand list syntax.
* Tested against PHP 5.6.30, 7.1.5
*/
$a = [ 1 , 2 , 3 , 4 ];

// this is quite normal use case for list
echo «Unpack all values\n» ;
list( $v1 , $v2 , $v3 , $v4 ) = $a ;
echo » $v1 , $v2 , $v3 , $v4 \n» ;
unset( $v1 , $v2 , $v3 , $v4 );

// this is what I mean:
echo «Skip middle\n» ;
list( $v1 , , , $v4 ) = $a ;
echo » $v1 , $v2 , $v3 , $v4 \n» ;
unset( $v1 , $v2 , $v3 , $v4 );

echo «Skip beginning\n» ;
list( , , $v3 , $v4 ) = $a ;
echo » $v1 , $v2 , $v3 , $v4 \n» ;
unset( $v1 , $v2 , $v3 , $v4 );

echo «Skip end\n» ;
list( $v1 , $v2 , , ) = $a ;
echo » $v1 , $v2 , $v3 , $v4 \n» ;
unset( $v1 , $v2 , $v3 , $v4 );

echo «Leave middle\n» ;
list( , $v2 , $v3 , ) = $a ;
echo » $v1 , $v2 , $v3 , $v4 \n» ;
unset( $v1 , $v2 , $v3 , $v4 );

list() can be used with foreach

$array = [[ 1 , 2 ], [ 3 , 4 ], [ 5 , 6 ]];

foreach( $array as list( $odd , $even )) echo » $odd is odd; $even is even» , PHP_EOL ;
>
?>

The output:
===
1 is odd; 2 is even
3 is odd; 4 is even
5 is odd; 6 is even

The list construct seems to look for a sequential list of indexes rather taking elements in sequence. What that obscure statement means is that if you unset an element, list will not simply jump to the next element and assign that to the variable but will treat the missing element as a null or empty variable:

The list() definition won’t throw an error if your array is longer then defined list.

list( $a , $b , $c ) = array( «a» , «b» , «c» , «d» );

var_dump ( $a ); // a
var_dump ( $b ); // b
var_dump ( $c ); // c
?>

Don’t miss simple array pattern matching since php 7

[ $a ] = [ ‘hello!’ ];
var_dump ( $a ); // ‘hello!’

$arr = [ 4 => 50 ];
[ 4 => $fifty ] = $arr ;
var_dump ( $fifty ); // 50

$multidimensionalArray = [[ ‘id’ => 15 , ’email’ => ‘diyor024@gmail.com’ ]];
[[ ‘id’ => $id , ’email’ => $email ]] = $multidimensionalArray ;
var_dump ( $id , $email ); // 15 diyor024@gmail.com

For PHP 7.1 on, the documentation states that integer and string keys can be mixed, but that elements with and without keys cannot. Here is an example, using data from getimagesize() with mixed keys:

$data =[
0 => 160 ,
1 => 120 ,
2 => 2 ,
3 => ‘width=»160″ height=»120″‘ ,
‘mime’ => ‘image/jpeg’
];
list( 0 => $width , 1 => $height , 2 => $type , 3 => $dimensions , ‘mime’ => $mime )= $data ;
?>

Here, the numeric keys also need to be specified, as if the whole array is treated as an associative array.

As noted elsewhere, the list() operator can be written in array format:

[ 0 => $width , 1 => $height , 2 => $type , 3 => $dimensions , ‘mime’ => $mime ]= $data ;
?>

Setting it like does _not_ raise an E_NOTICE (or other error) and afaics effectively equals an https://php.net/function.unset of $var1,$varN.

I note this as contrasting with the fact that PHP triggers an E_NOTICE about «Undefined offset» «if there aren’t enough array elements to fill the list()», as attow documented for https://php.net/control-structures.foreach#control-structures.foreach.list and here only noted in https://php.net/function.list#122951 by Mardaneus.

For completeness, a bash(1) (v5.0 or 4.3 on macos10.13) cli test producing the same result for all my PHP-versions (installed via macports.org) follows. It’s also tested with php7.3 using bash5.0 on Debian10:
bash —noprofile —norc -c ‘for php in php,>;do for literal in «array()» null;do echo -n $php …=$literal:&&$php -n -d error_reporting=E_ALL -r «var_dump(list(\$var)=$literal);»;done;done’

# Above produces the same result pairs per version from:
php53 …=array():
Notice: Undefined offset: 0 in Command line code on line 1
array(0) >
# . to:
php73 …=null:NULL

This is something I haven’t seen in documentation.

Since PHP 7.1, you can use short-hand list unpacking using square brackets, just like short-hand array declaration:

// short-hand array definition
[ $a , $b , $c ] = $foo ;
echo $a ; // displays «a»

// it’s same like:
list( $x , $y , $z ) = $foo ;
echo $x ; // displays «a»

Источник

Using list() With explode() In PHP

Note: This post is over two years old and so the information contained here might be out of date. If you do spot something please leave a comment and we will endeavour to correct.

A simple way to convert a string into a set of variables is through the use of the explode() and list() functions. list() is a language construct (not really a function) that will convert an array into a list of variables. For example, to convert a simple array into a set of variables do the following:

In this example $variable1 now contains the value 1 and $variable2 contains the value 2. This can be adapted to use the explode() function to take a string and convert it into a set of variables. An example of this in use might be when dealing with addresses, simply explode the string using the comma and you have a set of variables.

You can now print out parts of the address like this:

The good thing about using this code is that even if part of the address isn’t present you will still get a variable for that space. Altering the previous example to remove the town and the city like this:

Has the effect of creating empty $town and $city variables. They should always be present as long as your address has the same number of parts.

Phil is the founder and administrator of #! code and is an IT professional working in the North West of the UK. Graduating in 2003 from Aberystwyth University with an MSc in Computer Science Phil has previously worked as a database administrator, on an IT help desk, systems trainer, web architect, usability consultant, blogger and SEO specialist. Phil has lots of experience building and maintaining PHP websites as well as working with associated technologies like JavaScript, HTML, CSS, XML, Flex, Apache, MySQL and Linux.

Want to know more? Need some help?

Let us help! Hire us to provide training, advice, troubleshooting and more.

Support Us!

Please support us and allow us to continue writing articles.

Источник

PHP implode() and explode()

implode() function is used to join arrays. It joins an array with a given glue and returns a string.

The implode function has two arguments. implode(glue, array)

implode() with indexed arrays

implode() with associative arrays

When using implode() with associative arrays, the keys will be ignored. Values will be joined.

  'Apple', 'worst' => 'Pineapple', 'good' => 'Banana' ]; echo implode('|', $array); // Apple|Pineapple|Banana 

Note: implode() cannot be used with multi-dimensional arrays

implode() using different glues

Let’s play with the glue argument in the implode() function.

 ', $array); # using HTML // WTH? Reverse works? Yes!! PHP knows your mistakes echo implode($array, ','); 

explode()

explode() function is used to split strings. It splits a string by a delimeter, and returns an array.

The explode function has two arguments. explode(delimeter, string)

1. delemeter — the string which is used to split. (The boundary)
2. string — the string to be splitted

If the string is Apple,Banana , and the delimeter is , , you will get an array with two elements Apple and Banana . The important thing to notice is that delimeter is not included in the splitted elements. They work excatly as boundaries.

explode() Basic Examples

explode() with list()

Unlike implode(), explode()’s arguments cannot be reversed. The reason is: in implode(), each argument was in different data types (string and array). But, both arguments of explode() are strings. Therefore PHP doesn’t have a way to identify them seperately. So, for both functions, remember to use the delimeter or glue first to reduce mistakes.

Источник