Php implode многомерные массивы

PHP: How to Convert Array to String using implode()

PHP comes with its native function to convert Array to string called implode().

The implode() function has two implementation:

The implode() function that accepts two arguments — String used to join array elements & Array itself Example: Here we will join array elements using «, » to store it as comma separated values.

$arr = ['Thor','Captain America','Iron Man']; echo implode(', ',$arr); // "Thor, Captain America, Iron Man"

$arr = ['H','e','l','l','o']; echo implode($arr); // "Hello"

Note: If the PHP array contains non-string items, implode function will first convert it to string and use it in the joined string. Boolean values are representated as → true = 1, false = 0.

Convert PHP Associative Array to String using implode()

The implode() function can not only join arrays with integer index but with string index as well, which we call it as associative arrays.

There are two approaches to this:

1) Combine only values to string

This is very simple since implode() function only considers array item’s value and not index. So, you can use implode() function directly like below:

$users = [ 'user1' => 'user1@example.com', 'user2' => 'user2@example.com' ]; echo implode(', ',$users); // "user1@example.com, user2@example.com"

2) Combine both Index and value to string

If you want to use both values and index while joining array to string, then it gets complex. There are many ways to achieve this. Also, it depends how you want to represent the index and values in string. The implode() doesn’t have any native functionality to handle such situations therefore, we will use multiple PHP functions including implode() function to achieve the same.

Example: Using the same associative array shown above, we will use both index and value i.e username and email address and combine it as follow:

$users = [ 'user1' => 'user1@example.com', 'user2' => 'user2@example.com' ]; $flattened = $array; array_walk($flattened, function(&$value, $key)  $value = "$key>:$value>"; >); echo implode(', ', $flattened); // "user1:user1@example.com, user2:user2@example.com"

In above example, we are combining username and email via color (:) by applying our custom function to each element in array using array_walk and then using implode(), we convert it to string.

Convert PHP Array of Arrays to String using implode()

Array can not only hold primary data types but Arrays and objects as well. If your Array holds arrays then combining all items at sub-level can get tricky.

The implode() cannot combine items at sub-level, therefore it doesn’t work with array of arrays directly.

Example: Notice here , implode() method only considers top-level items and while converting items to string, it returns «Array» as string.

$users = [ 'users' => ['user1@example.com','user2@example.com'], 'admins' => ['admin1@example.com', 'admin2@example.com'] ]; echo implode(', ',$users); // Array, Array 

There are different ways to achieve this and depends on what kind the array is. For our simple example above, easiest approach would be to loop-through the array to retrive each sub-array and join them.

$users = [ 'users' => ['user1@example.com','user2@example.com'], 'admins' => ['admin1@example.com', 'admin2@example.com'] ]; // function to convert array of arrays to string function implodeArrayofArrays($array, $glue = ', ')  $output = ''; foreach ($array as $subarray)  $output .= implode($separator, $subarray); > return $output; > echo implodeArrayofArrays($users); // "user1@example.com, user2@example.com, admin1@example.com, admin2@example.com"

But, if your arrays has more levels — multidimensional array then you will have to check whether the item is of Array type or not. If it is then loop through that array as well.

Convert PHP Array to String using json_encode() and serialize()

There are other ways to convert PHP arrays to string as well. We will explore two methods to convert array to string in PHP. These functions even though returns string, have different purpose.

1) json_encode()

This function is very useful to not only convert PHP array to strings but pass it to javascript as well. You cannot pass PHP arrays to JavaScript directly, so you can convert it to JSON string using json_encode() and use it in JavaScript efficiently.

$arr = ['Thor','Captain America','Iron Man']; echo json_encode($arr); // "['Thor','Captain America','Iron Man']"

2) serialize()

This function is helpful when you want to convert PHP array into storable representation. Like, when you want to store PHP array in a memory buffer, this function can be helpful.

$arr = ['Thor','Captain America','Iron Man']; echo serialize($arr); // a:3: 

That’s all for today! Keep Learning

Источник

implode

Alternative signature (not supported with named arguments):

Legacy signature (deprecated as of PHP 7.4.0, removed as of PHP 8.0.0):

Join array elements with a separator string.

Parameters

Optional. Defaults to an empty string.

The array of strings to implode.

Return Values

Returns a string containing a string representation of all the array elements in the same order, with the separator string between each element.

Changelog

Version	Description
8.0.0	Passing the separator after the array is no longer supported.
7.4.0	Passing the separator after the array (i.e. using the legacy signature) has been deprecated.

Examples

Example #1 implode() example

$array = [ ‘lastname’ , ’email’ , ‘phone’ ];
var_dump ( implode ( «,» , $array )); // string(20) «lastname,email,phone»

// Empty string when using an empty array:
var_dump ( implode ( ‘hello’ , [])); // string(0) «»

// The separator is optional:
var_dump ( implode ([ ‘a’ , ‘b’ , ‘c’ ])); // string(3) «abc»

Notes

Note: This function is binary-safe.

See Also

• explode() — Split a string by a string
• preg_split() — Split string by a regular expression
• http_build_query() — Generate URL-encoded query string

User Contributed Notes 14 notes

it should be noted that an array with one or no elements works fine. for example:

$a1 = array( «1» , «2» , «3» );
$a2 = array( «a» );
$a3 = array();

echo «a1 is: ‘» . implode ( «‘,'» , $a1 ). «‘
» ;
echo «a2 is: ‘» . implode ( «‘,'» , $a2 ). «‘
» ;
echo «a3 is: ‘» . implode ( «‘,'» , $a3 ). «‘
» ;
?>

will produce:
===========
a1 is: ‘1’,’2′,’3′
a2 is: ‘a’
a3 is: »

It’s not obvious from the samples, if/how associative arrays are handled. The «implode» function acts on the array «values», disregarding any keys:

$a = array( ‘one’ , ‘two’ , ‘three’ );
$b = array( ‘1st’ => ‘four’ , ‘five’ , ‘3rd’ => ‘six’ );

echo implode ( ‘,’ , $a ), ‘/’ , implode ( ‘,’ , $b );
?>

outputs:
one,two,three/four,five,six

Can also be used for building tags or complex lists, like the following:

?>

This is just an example, you can create a lot more just finding the right glue! 😉

It might be worthwhile noting that the array supplied to implode() can contain objects, provided the objects implement the __toString() method.

class Foo
protected $title ;

public function __construct ( $title )
$this -> title = $title ;
>

public function __toString ()
return $this -> title ;
>
>

$array = [
new Foo ( ‘foo’ ),
new Foo ( ‘bar’ ),
new Foo ( ‘qux’ )
];

echo implode ( ‘; ‘ , $array );
?>

will output:

If you want to implode an array of booleans, you will get a strange result:
var_dump ( implode ( » ,array( true , true , false , false , true )));
?>

Output:
string(3) «111»

TRUE became «1», FALSE became nothing.

If you want to implode an array as key-value pairs, this method comes in handy.
The third parameter is the symbol to be used between key and value.

function mapped_implode ( $glue , $array , $symbol = ‘=’ ) return implode ( $glue , array_map (
function( $k , $v ) use( $symbol ) <
return $k . $symbol . $v ;
>,
array_keys ( $array ),
array_values ( $array )
)
);
>

echo mapped_implode ( ‘, ‘ , $arr , ‘ is ‘ );

// output: x is 5, y is 7, z is 99, hello is World, 7 is Foo

Sometimes it’s necessary to add a string not just between the items, but before or after too, and proper handling of zero items is also needed.
In this case, simply prepending/appending the separator next to implode() is not enough, so I made this little helper function.

function wrap_implode ( $array , $before = » , $after = » , $separator = » ) if( ! $array ) return » ;
return $before . implode ( » < $after >< $separator > < $before >» , $array ) . $after ;
>

echo wrap_implode ([ ‘path’ , ‘to’ , ‘file.php’ ], ‘/’ );
// «/path/to/file.php»

$pattern = ‘#’ . wrap_implode ([ 4 , 2 , 2 ], ‘\d’ , ‘[-.]’ ) . ‘#’ ;
echo $pattern , «\n» ; // #\d[-.]\d[-.]\d#
echo preg_replace ( $pattern , ‘[REDACTED]’ , ‘The UFO appeared between 2012-12-24 and 2013.01.06 every night.’ );
// ‘The UFO appeared between [REDACTED] and [REDACTED] every night.

echo wrap_implode ([ ‘line’ , ‘by’ , ‘line’ ], ‘‘ , ‘‘ , ‘
‘ );
// line
by
line

It may be worth noting that if you accidentally call implode on a string rather than an array, you do NOT get your string back, you get NULL:
var_dump ( implode ( ‘:’ , ‘xxxxx’ ));
?>
returns
NULL

This threw me for a little while.

Even handier if you use the following:

$id_nums = array( 1 , 6 , 12 , 18 , 24 );

$id_nums = implode ( «, » , $id_nums );

$sqlquery = «Select name,email,phone from usertable where user_id IN ( $id_nums )» ;

// $sqlquery becomes «Select name,email,phone from usertable where user_id IN (1,6,12,18,24)»
?>

Be sure to escape/sanitize/use prepared statements if you get the ids from users.

null values are imploded too. You can use array_filter() to sort out null values.

$ar = array( «hello» , null , «world» );
print( implode ( ‘,’ , $ar )); // hello,,world
print( implode ( ‘,’ , array_filter ( $ar , function( $v )< return $v !== null ; >))); // hello,world
?>

If you want to use a key inside array:

Example:
$arr=array(
array(«id» => 1,»name» => «Test1»),
array(«id» => 2,»name» => «Test2»),
);

echo implode_key(«,»,$arr, «name»);
OUTPUT: Test1, Test2

function implode_key($glue, $arr, $key) $arr2=array();
foreach($arr as $f) if(!isset($f[$key])) continue;
$arr2[]=$f[$key];
>
return implode($glue, $arr2);
>

It is possible for an array to have numeric values, as well as string values. Implode will convert all numeric array elements to strings.

$test = implode ([ «one» , 2 , 3 , «four» , 5.67 ]);
echo $test ;
//outputs: «one23four5.67»
?>

There is no mention of behavior on a empty array, so I tried it and here’s the result:

$ar = array();
$result = implode ( ‘,’ , $ar ); // Comma arbitrarily applied as the separator
$is_result_empty = empty( $result );
?>

$result:
$is_result_empty: 1

In other words, an empty string is the result.

* Join pieces with a string recursively .
*
* @ param mixed $glue String between pairs ( glue ) or an array pair ‘s glue and key/value glue or $pieces.
* @param iterable $pieces Pieces to implode (optional).
* @return string Joined string
*/
function double_implode($glue, iterable $pieces = null): string
$glue2 = null;
if ($pieces === null) $pieces = $glue;
$glue = »;
> elseif (is_array($glue)) list($glue, $glue2) = $glue;
>

$result = [];
foreach ($pieces as $key => $value) $result[] = $glue2 === null ? $value : $key . $glue2 . $value;
>
return implode($glue, $result);
>
?>
Examples:
$array = [‘ a ‘ => 1, ‘b’ => 2];
$str = implode($array);
$str = implode(‘ , ‘, $array);
$str = implode([‘» ‘, ‘ keyword»>, ‘, $iterator);
$str = implode([‘» ‘, ‘ foot»>＋add a note

Источник