|
|
 |
explode (PHP 3, PHP 4 , PHP 5) explode -- Split a string by string Descriptionarray explode ( string separator, string string [, int limit])
Returns an array of strings, each of which is a substring of
string formed by splitting it on
boundaries formed by the string separator.
If limit is set, the returned array will
contain a maximum of limit elements with
the last element containing the rest of
string.
If separator is an empty string (""),
explode() will return FALSE. If
separator contains a value that is not contained
in string, then explode() will
return an array containing string.
If the limit parameter is negative, all components
except the last limit are returned. This feature
was added in PHP 5.1.0.
Although implode() can, for historical reasons,
accept its parameters in either order,
explode() cannot. You must ensure that the
separator argument comes before the
string argument.
注:
The limit parameter was added in PHP
4.0.1
例子 1. explode() examples |
<?php
// Example 1
$pizza = "piece1 piece2 piece3 piece4 piece5 piece6";
$pieces = explode(" ", $pizza);
echo $pieces[0]; // piece1
echo $pieces[1]; // piece2
// Example 2
$data = "foo:*:1023:1000::/home/foo:/bin/sh";
list($user, $pass, $uid, $gid, $gecos, $home, $shell) = explode(":", $data);
echo $user; // foo
echo $pass; // *
?>
|
|
例子 2. limit parameter examples |
<?php
$str = 'one|two|three|four';
// positive limit
print_r(explode('|', $str, 2));
// negative limit
print_r(explode('|', $str, -1));
?>
|
The above example will output:
Array
(
[0] => one
[1] => two|three|four
)
Array
(
[0] => one
[1] => two
[2] => three
) |
|
See also
preg_split(),
spliti(),
split(), and
implode().
jeremy at fishbowlrecords dot com
23-Oct-2002 02:58
While explode() and implode() are helpful functions, I found I needed to
write additional functions to correctly handle two dimensional arrays. Here
are the two functions:
These functions based on code from
<peter at int8 dot com>.
<?php
// just as
double_explode functions akin to explode, so too does
//
double_implode to implode
function double_implode($first_break,
$second_break, $array)
{
$string =
"";
$k=0;
$num_length =
count($array);
foreach ($array as $key =>
$value)
{
// if the element of the main array is an
array
if (is_array($array[$key]))
{
// append the
string of the converted arary to
// the string being constructed of
the whole
// main array
$string .= implode($second_break,
$array[$key]);
}
else
{
// append the element to
the string
$string .=
$array[$key];
}
$k++;
//change here!
//
append the delimiting character to the string
if
($k<$num_length)
$string .=
$first_break;
}
return $string;
}
// this is a
replacement for the internal explode function so that
// strings
representing 2D arrays (ie matrices) maybe made again
// into their
array format
function
double_explode($first_break,$second_break,$string)
{
// creates
array based on the first division character
$array =
explode($first_break, $string);
// loops through the created
array in search of any strings
// that need to be converted to
arrays
for ($k=0; $k < count($array); $k++)
{
// the number of times the second division character
// is
present
$count = substr_count($array[$k], $second_break);
// if the second division character is present; ie,
// if
the string needs to be converted to an array
if
($count>0)
{
// creates array from string and
puts it in
// the main array where the string was
$array[$k] = explode($second_break, $array[$k]);
}
}
return $array;
}
?>
Notice the "if
($k<$num_length)" check near the bottom. What I found is that
without that, any string created would have an extra character at the end,
and when exploded w
| |
echo
