echo
I needed a multiexplode which didn't replace my delimiters for 1 other delimiter. Because I couldn't find one in the examples I made one.
delimiter array:
array('/RTRN/','/BUSP/','/BENM/','/ORDP/','/CSID/', '/MARF/','/EREF/', '/PREF/','/REMI/','/ID/','/PURP/', '/ULTB/','/ULTD/');
input string: /RTRN/MS03//BENM/NL50INGB00012345/BUSP/Europese Incasso/eenmalig/67/INGBNL2A/ING Bank N.V. inzake WeB///CSID/NL32ZZZ999999991234//MARF/EV45451//EREF/EV45451 REP170112T1106//REMI///EV45451REP170112T1106/
output:
array(
[/RTRN/] => MS03/
[/BENM/] => NL50INGB00012345
[/BUSP/] => Europese Incasso/eenmalig/67/INGBNL2A/ING Bank N.V. inzake WeB//
[/CSID/] => NL32ZZZ999999991234/
[/MARF/] => EV45451/
[/EREF/] => EV45451REP170112T1106/
[/REMI/] => //EV45451REP170112T1106/
[/ORDP/] =>
[/PREF/] =>
[/ID/] =>
[/PURP/] =>
[/ULTB/] =>
[/ULTD/] =>
)
<?php
function multiexplode($delimiters,$string) {
$arrOccurence = array();
$arrEnd = array();
foreach($delimiters as $key => $value){
$position = strpos($string, $value);
if($position > -1){
$arrOccurence[$value] = $position;
}
}
if(count($arrOccurence) > 0){
asort($arrOccurence);
$arrEnd = array_values($arrOccurence);
array_shift($arrEnd);
$i = 0;
foreach($arrOccurence as $key => $start){
$pointer = $start+strlen($key);
if($i == count($arrEnd)){
$arrOccurence[$key] = substr($string, $pointer);
} else {
$arrOccurence[$key] = substr($string, $pointer, $arrEnd[$i]-$pointer);
}
$i++;
}
}
//next part can be left apart if not necessary. In that case key that don't appear in the inputstringwill not be returned
foreach($delimiters as $key => $value){
if(!isset($arrOccurence[$value])){
$arrOccurence[$value] = '';
}
}
return $arrOccurence;
}
?>
explode
(PHP 4, PHP 5)
explode — Split a string by string
Description
array explode
( string
$delimiter
, 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 delimiter.
Parameters
-
delimiter -
The boundary string.
-
string -
The input string.
-
limit -
If
limitis set and positive, the returned array will contain a maximum oflimitelements with the last element containing the rest ofstring.If the
limitparameter is negative, all components except the last -limitare returned.If the
limitparameter is zero, then this is treated as 1.
Although implode() can, for historical reasons,
accept its parameters in either order,
explode() cannot. You must ensure that the
delimiter argument comes before the
string argument.
Return Values
Returns an array of strings
created by splitting the string parameter on
boundaries formed by the delimiter.
If delimiter is an empty string (""),
explode() will return FALSE.
If delimiter contains a value that is not
contained in string and a negative
limit is used, then an empty array will be
returned, otherwise an array containing
string will be returned.
Changelog
| Version | Description |
|---|---|
| 5.1.0 |
Support for negative limits was added
|
| 4.0.1 |
The limit parameter was added
|
Examples
Example #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; // *
?>
Example #2 explode() return examples
<?php
/* A string that doesn't contain the delimiter will simply return a one-length array of the original string. */
$input1 = "hello";
$input2 = "hello,there";
var_dump( explode( ',', $input1 ) );
var_dump( explode( ',', $input2 ) );
?>
The above example will output:
array(1)
(
[0] => string(5) "hello"
)
array(2)
(
[0] => string(5) "hello"
[1] => string(5) "there"
)
Example #3 limit parameter examples
<?php
$str = 'one|two|three|four';
// positive limit
print_r(explode('|', $str, 2));
// negative limit (since PHP 5.1)
print_r(explode('|', $str, -1));
?>
The above example will output:
Array
(
[0] => one
[1] => two|three|four
)
Array
(
[0] => one
[1] => two
[2] => three
)
Notes
Note: This function is binary-safe.
See Also
- preg_split() - Split string by a regular expression
- str_split() - Convert a string to an array
- mb_split() - Split multibyte string using regular expression
- str_word_count() - Return information about words used in a string
- strtok() - Tokenize string
- implode() - Join array elements with a string
add a note
User Contributed Notes
explode - [34 notes]
m.reesinck ¶
2 months ago
Hayley Watson ¶
1 month ago
The comments to use array_filter() without a callback to remove empty strings from explode's results miss the fact that array_filter will remove all elements that, to quote the manual, "are equal to FALSE".
This includes, in particular, the string "0", which is NOT an empty string.
If you really want to filter out empty strings, use the defining feature of the empty string that it is the only string that has a length of 0. So:
<?php
array_filter(explode(':', "1:2::3:0:4"), 'strlen');
?>
php at metehanarslan dot com ¶
2 months ago
Here is my approach to have exploded output with multiple delimiter.
<?php
//$delimiters has to be array
//$string has to be array
function multiexplode ($delimiters,$string) {
$ready = str_replace($delimiters, $delimiters[0], $string);
$launch = explode($delimiters[0], $ready);
return $launch;
}
$text = "here is a sample: this text, and this will be exploded. this also | this one too :)";
$exploded = multiexplode(array(",",".","|",":"),$text);
print_r($exploded);
//And output will be like this:
// Array
// (
// [0] => here is a sample
// [1] => this text
// [2] => and this will be exploded
// [3] => this also
// [4] => this one too
// [5] => )
// )
?>
eye_syah88 at yahoo dot com ¶
1 year ago
a simple one line method to explode & trim whitespaces from the exploded elements
array_map('trim',explode(",",$str));
example:
$str="one ,two , three , four ";
print_r(array_map('trim',explode(",",$str)));
Output:
Array ( [0] => one [1] => two [2] => three [3] => four )
m0gr14 at gmail dot com ¶
2 years ago
Here's a function for "multi" exploding a string.
<?php
//the function
//Param 1 has to be an Array
//Param 2 has to be a String
function multiexplode ($delimiters,$string) {
$ary = explode($delimiters[0],$string);
array_shift($delimiters);
if($delimiters != NULL) {
foreach($ary as $key => $val) {
$ary[$key] = multiexplode($delimiters, $val);
}
}
return $ary;
}
// Example of use
$string = "1-2-3|4-5|6:7-8-9-0|1,2:3-4|5";
$delimiters = Array(",",":","|","-");
$res = multiexplode($delimiters,$string);
echo '<pre>';
print_r($res);
echo '</pre>';
//returns
/*
Array
(
[0] => Array
(
[0] => Array
(
[0] => Array
(
[0] => 1
[1] => 2
[2] => 3
)
[1] => Array
(
[0] => 4
[1] => 5
)
[2] => Array
(
[0] => 6
)
)
[1] => Array
(
[0] => Array
(
[0] => 7
[1] => 8
[2] => 9
[3] => 0
)
[1] => Array
(
[0] => 1
)
)
)
[1] => Array
(
[0] => Array
(
[0] => Array
(
[0] => 2
)
)
[1] => Array
(
[0] => Array
(
[0] => 3
[1] => 4
)
[1] => Array
(
[0] => 5
)
)
)
)
*/
?>
kkobashi at kobashicomputing dot com ¶
9 months ago
Explode does not parse a string by delimiters, in the sense that we expect to find tokens between a starting and ending delimiter, but instead splits a string into parts by using a string as the boundary of each part. Once that boundary is discovered the string is split. Whether or not that boundary is proceeded or superseded by any data is irrelevant since the parts are determined at the point a boundary is discovered.
For example:
<?php
var_dump(explode("/","/"));
/*
Outputs
array(2) {
[0]=>
string(0) ""
[1]=>
string(0) ""
}
*/
?>
The reason we have two empty strings here is that a boundary is discovered before any data has been collected from the string. The boundary splits the string into two parts even though those parts are empty.
One way to avoid getting back empty parts (if you don't care for those empty parts) is to use array_filter on the result.
<?php
var_dump(array_filter(explode("/","/")));
/*
Outputs
array(0) {
}
*/
?>
*[This note was edited by googleguy at php dot net for clarity]*
coroa at cosmo-genics dot com ¶
9 years ago
To split a string containing multiple seperators between elements rather use preg_split than explode:
preg_split ("/\s+/", "Here are to many spaces in between");
which gives you
array ("Here", "are", "to", "many", "spaces", "in", "between");
SR ¶
4 years ago
Keep in mind that explode() can return empty elements if the delimiter is immediately repeated twice (or more), as shown by the following example:
<?php
$foo = 'uno dos tres'; // two spaces between "dos" and "tres"
print_r(explode(' ', $foo));
?>
Array
(
[0] => uno
[1] => dos
[2] =>
[3] => tres
)
Needless to say this is definitely not intuitive and must be handled carefully.
tiago dot dias at flow-me dot com ¶
2 years ago
Beaware splitting empty strings.
<?php
$str = "";
$res = explode(",", $str);
print_r($res);
?>
If you split an empty string, you get back a one-element array with 0 as the key and an empty string for the value.
Array
(
[0] =>
)
To solve this, just use array_filter() without callback. Quoting manual page "If the callback function is not supplied, array_filter() will remove all the entries of input that are equal to FALSE.".
<?php
$str = "";
$res = array_filter(explode(",", $str));
print_r($res);
?>
Array
(
)
Cody G. ¶
2 years ago
I'm sure you guys get just a bit frustrated at times when you need a fraction of a very simple string and you use "explode()", but then you have to define a whole extra variable. (That is because you need to store a function-returned array in a variable before you can extract a value).
If you're extracting the last half, or third, of a string, there's an easy inline workaround. Check this:
<?php
$mystr = "separated-text";
print(str_replace("-","",strstr("-",$mystr)));
//Returns "text"
?>
If the separator (dash) can be left in, you don't even need the "str_replace()" function.
Lets try this with 3 fractions:
<?php
$mystr = "separated-text-again";
//Comment submission wouldn't let me
// combine this into one statement.
// That's okay, it's more readable.
$split1 = str_replace("-","",strstr("-",$mystr));
print(str_replace("-","",strstr("-",$split1)));
//Returns "again"
?>
Anything more than 3 fractions gets really confusing, in that case you should use "explode()".
Hope this helps!
~Cody G.
jessebusman at gmail dot com ¶
2 years ago
Sometimes you need to explode a string by different delimiters. In that case you can use this function:
<?php
print_r(explodeX(Array(".","!"," ","?",";"),"This.sentence?contains wrong;characters"));
// Returns:
// Array("This","sentence","contains","wrong","characters")
function explodeX($delimiters,$string)
{
$return_array = Array($string); // The array to return
$d_count = 0;
while (isset($delimiters[$d_count])) // Loop to loop through all delimiters
{
$new_return_array = Array();
foreach($return_array as $el_to_split) // Explode all returned elements by the next delimiter
{
$put_in_new_return_array = explode($delimiters[$d_count],$el_to_split);
foreach($put_in_new_return_array as $substr) // Put all the exploded elements in array to return
{
$new_return_array[] = $substr;
}
}
$return_array = $new_return_array; // Replace the previous return array by the next version
$d_count++;
}
return $return_array; // Return the exploded elements
}
?>
Onur Nizam onur dot nizam at yahoo dot com ¶
2 years ago
The regular expression parameters such as \n or \t can be used as well as other strings as the delimeter which can be used to parse any given text files or downloaded web pages to read line by line.
An example may be considered as, name surname and phone numbers are written into a text file line by line and columns are seperated by tabs, can be exploded and read easily through the return and tab characters. After storing them in the array they can be manipulated or displayed in any other formats.
<?php
// Explode text file and store each row of the file into the array elements
function explodeRows($data) {
$rowsArr = explode("\n", $data);
return $rowsArr;
}
// Explode the columns according to tabs
function explodeTabs($singleLine) {
$tabsArr = explode("\t", $singleLine);
return $tabsArr;
}
// Open the text file and get the content
$filename = "phonebook.txt";
$handle = fopen($filename, 'r');
$data = fread($handle, filesize($filename));
$rowsArr = explodeRows($data);
// Display content which is exploded by regular expression parameters \n and \t
for($i=0;$i<count($rowsArr);$i++) {
$lineDetails = explodeTabs($rowsArr[$i]);
echo "<br>Name : " . $lineDetails[0];
echo "<br>Surname : " . $lineDetails[1];
echo "<br>Tel Number : " . $lineDetails[2];
echo "<br><br>";
}
/*
phonebook.txt text file can be something like this;
name1 sname1 +905429998877
name2 sname2 +905429998876
name3 sname3 +905429998875
The output will be as follows;
Name : name1
Surname : sname1
Tel Number : +905429998877
Name : name2
Surname : sname2
Tel Number : +905429998876
Name : name3
Surname : sname3
Tel Number : +905429998875
*/
?>
locoluis at gmail dot com ¶
3 years ago
That with all stateful encodings that use bytes between 0x00 and 0x7f for something other than, say, encoding ASCII characters. Including GBK, BIG5, Shift-JIS etc.
explode and other such PHP functions work on bytes, not characters.
What you do is to convert the string to UTF-8 using iconv(), then explode, then go back to GBK.
gxd305 at gmail dot com ¶
3 years ago
when the encoding of $string is 'GBK' and $delimiter is '|' , the return value may be wrong.
for example:
<?php
$result = explode("|", "滕华弢|海青");
var_dump($result);
?>
and the result will be:
array (
0 => '滕华,
1 => '',
2 => '海青',
)
bcz "弢" 's GBK is '0x8f7c'. and "|" 's ASCII is '0x7c'.
So, all GBK-encoding characters include '7c' will lead to the error result.
Anonymous ¶
3 years ago
Note to the previous example: we can do the whole string->array conversion using explode() exclusively.
<?php
// converts pure string into a trimmed keyed array
function string_2_array( $string, $delimiter = ',', $kv = '=>')
{
if ($element = explode( $delimiter, $string ))
{
// create parts
foreach ( $element as $key_value )
{
// key -> value pair or single value
$atom = explode( $kv, $key_value );
if( trim($atom[1]) )
{
$key_arr[trim($atom[0])] = trim($atom[1]);
}
else
{
$key_arr[] = trim($atom[0]);
}
}
}
else
{
$key_arr = false;
}
return $key_arr;
}
?>
Anonymous ¶
3 years ago
<?php
// converts pure string into a trimmed keyed array
function string2KeyedArray($string, $delimiter = ',', $kv = '=>') {
if ($a = explode($delimiter, $string)) { // create parts
foreach ($a as $s) { // each part
if ($s) {
if ($pos = strpos($s, $kv)) { // key/value delimiter
$ka[trim(substr($s, 0, $pos))] = trim(substr($s, $pos + strlen($kv)));
} else { // key delimiter not found
$ka[] = trim($s);
}
}
}
return $ka;
}
} // string2KeyedArray
$string = 'a=>1, b=>23 , $a, c=> 45% , true,d => ab c ';
print_r(string2KeyedArray($string));
?>
Array
(
[a] => 1
[b] => 23
[0] => $a
[c] => 45%
[1] => true
[d] => ab c
)
pinkgothic at gmail dot com ¶
5 years ago
coroa at cosmo-genics dot com mentioned using preg_split() instead of explode() when you have multiple delimiters in your text and don't want your result array cluttered with empty elements. While that certainly works, it means you need to know your way around regular expressions... and, as it turns out, it is slower than its alternative. Specifically, you can cut execution time roughly in half if you use array_filter(explode(...)) instead.
Benchmarks (using 'too many spaces'):
Looped 100000 times:
preg_split: 1.61789011955 seconds
filter-explode: 0.916578054428 seconds
Looped 10000 times:
preg_split: 0.162719011307 seconds
filter-explode: 0.0918920040131 seconds
(The relation is, evidently, pretty linear.)
Note: Adding array_values() to the filter-explode combination, to avoid having those oft-feared 'holes' in your array, doesn't remove the benefit, either. (For scale - the '9' becomes a '11' in the benchmarks above.)
Also note: I haven't tested anything other than the example with spaces - since djogo_curl at yahoo's note seems to imply that explode() might get slow with longer delimiters, I expect this would be the case here, too.
I hope this helps someone. :)
seventoes at gmail dot com ¶
6 years ago
Note that explode, split, and functions like it, can accept more than a single character for the delimiter.
<?php
$string = "Something--next--something else--next--one more";
print_r(explode('--next--',$string));
?>
bernard.schenk [at] bordet.be ¶
1 year ago
Nifty multiple explode function:
<?php
function multipleExplode($delimiters = array(), $string = ''){
$mainDelim=$delimiters[count($delimiters)-1]; // dernier
array_pop($delimiters);
foreach($delimiters as $delimiter){
$string= str_replace($delimiter, $mainDelim, $string);
}
$result= explode($mainDelim, $string);
return $result;
}
?>
dhz ¶
2 years ago
A one-liner to extract a portion of a string, starting from the END of the string....
<?php
$extracted_string = implode('.', array_slice(explode('.', $original_string), -2));
?>
Jrg Wagner ¶
3 years ago
Here is a very concise example for a quote aware explode - substrings in quotes (or another definable enclosure char) are not exploded.
An additional parameter allows to determine whether the enclosure chars should be preserved within the resulting array elements. Please note that as of PHP 5.3 the str_getcsv function offers a built-in way to do this!
<?php
function csv_explode($delim=',', $str, $enclose='"', $preserve=false){
$resArr = array();
$n = 0;
$expEncArr = explode($enclose, $str);
foreach($expEncArr as $EncItem){
if($n++%2){
array_push($resArr, array_pop($resArr) . ($preserve?$enclose:'') . $EncItem.($preserve?$enclose:''));
}else{
$expDelArr = explode($delim, $EncItem);
array_push($resArr, array_pop($resArr) . array_shift($expDelArr));
$resArr = array_merge($resArr, $expDelArr);
}
}
return $resArr;
}
?>
Anonymous ¶
3 years ago
If you are exploding string literals in your code that have a dollar sign ($) in it, be sure to use single-quotes instead of double-quotes, since php will not spare any chance to interpret the variable-friendly characters after the dollar signs as variables, leading to unintended consequences, the most typical being missing characters.
<?php
$doubleAr = explode(" ", "The $quick brown fox");
$singleAr = explode(" ", 'The $quick brown fox');
echo $doubleAr[1]; // prints "";
echo $singleAr[1]; // prints "$quick";
?>
nick dot brown at free dot fr ¶
3 years ago
My application was running out of memory (my hosting company limits PHP to 32MB). I have a string containing between 100 and 20000 triplets, separated by a space, with each triplet consisting of three double-precision numbers, separated by commas. Total size of the biggest string, with 20000 triplets, is about 1MB.
The application needs to split the string into triplets, then split the triplet into numbers. In C, this would take up about 480K (20000 times 3 x 8 bytes) for the final array. The intermediate array of strings shouldn't be much bigger than the long string itself (1MB). And I expect some overhead from PHP, say 300% to allow for indexes etc.
Well, PHP5 manages to run out of memory *at the first stage* (exploding the string on the space character). I'm expecting to get an array of 20000 strings, but it needs more than 32MB to store it. Amazing.
The workaround was easy and had the bonus of producing faster code (I compared it on a 10000 triplet string). Since in any case I had to split up the numeric triplets afterwards, I decided to use preg_match_all() on the original string. Despite the fact that the resulting "matches" array contains more data per element than the result of explode() - because it stores the matched triplet, plus its component numbers - it takes up far less memory.
Moral: be careful when using explode() on big strings, as it can also explode your memory usage.
Michael ¶
4 years ago
Here's a simple script which uses explode() to check to see if an IP address is in an array (can be used as a ban-check, without needing to resort to database storage and queries).
<?php
function denied($one) {
$denied = array(
0 => '^255.255.255.255',
1 => '^255.250',
2 => '^255.255.250'
);
for ($i = 0 ; $i < sizeof($denied) ; $i++) {
if (sizeof(explode($denied[$i], '^' . $one . '$')) == 2) {
return true;
}
}
return false;
}
if (denied($_SERVER['REMOTE_ADDR'])) {
header('Location: denied.php');
}
?>
adrian at bilsoftware dot com ¶
4 years ago
<?php
function explode_escaped($delimiter, $string){
$exploded = explode($delimiter, $string);
$fixed = array();
for($k = 0, $l = count($exploded); $k < $l; ++$k){
if($exploded[$k][strlen($exploded[$k]) - 1] == '\\') {
if($k + 1 >= $l) {
$fixed[] = trim($exploded[$k]);
break;
}
$exploded[$k][strlen($exploded[$k]) - 1] = $delimiter;
$exploded[$k] .= $exploded[$k + 1];
array_splice($exploded, $k + 1, 1);
--$l;
--$k;
} else $fixed[] = trim($exploded[$k]);
}
return $fixed;
}
?>
Here's a function which explodes string with delimiter, but if delimiter is "escaped" by backslash, function won't split in that point. Example:
<?php
$result = explode_escaped(',', 'string, piece, group\, item\, item2, next\,asd');
print_r($result);
?>
Will give:
Array
(
[0] => string
[1] => piece
[2] => group, item, item2
[3] => next,asd
)
xananax at yelostudio dot com ¶
2 years ago
I needed a way to explode an array, just like one would explode a string, and could not find anything on the net.
Maybe this can be made more efficient, but it fits my purpose. Contributions and comments welcome.
<?php
/**
* Allows to explode an array into multiple arrays on a set delimiter.
* Delimiter Can be set either by key, or by value, or by both (in which case,
* both key and value must be strictly equal to values provided).
* Note that numeric indexes don't work since the original array is reduced
* at each loop (thus making numerical indexes useless).
* @param array $array the array to explode
* @param mixed $key the key to check
* @param mixed $value the value to check
* @param int $limit You can limit the number of parts with this. If set to 0, limit is infinite
* @param boolean $removeDelimiter if set to TRUE, removes the delimiter key from the returned arrays
* @return array|boolean an array of as many parts as needed, or FALSE on error.
*/
function array_explode(array $array, $key=NULL, $value=NULL, $limit=0, $removeDelimiter=TRUE){
if($key===NULL && $value===NULL){return FALSE;}
$parts = array();
$delimiter = NULL;
$partsN = 0;
while($v = current($array)){
$k = key($array);
if(
(($key!==NULL && $value!==NULL) && ($k===$key && $v===$value)) ||
($key!==NULL && $value===NULL && $k===$key) ||
($value!==NULL && $key===NULL && $v===$value)
){
$delimiter = TRUE;
if($removeDelimiter){array_shift($array);}
$partsN++;
if($partsN===$limit){$parts[$partsN] = $array;return $parts;}
}
$parts[$partsN][] = array_shift($array);
}
if($delimiter){
return $parts;
}
return FALSE;
}
?>
marcus at synchromedia dot co dot uk ¶
3 years ago
Just in case the comment about empty strings is not clear:
<?php
$a = array();
var_dump($a);
$s = implode("\n", $a);
var_dump($s);
$b = explode("\n", $s);
var_dump($b);
$b = preg_split('/\n/', $s,-1,PREG_SPLIT_NO_EMPTY);
var_dump($b);
?>
Results in:
array(0) {
}
string(0) ""
array(1) {
[0]=>
string(0) ""
}
array(0) {
}
i.e. exploding an empty string results in an array with one element. You can use preg_split to skip the empty item, but that may not be quite what you need should your array have empty elements intentionally.
Kamba Jeno ¶
2 years ago
if u cannot use the original function explode, or your version is less than 4.0.1 you can use this example whith optional limit argument.
<?php
function exploding($separator,$string,$limit=NULL){
$returnarray = array();
$increment = 0;
$length = strlen($string);
$limit_negative=($limit < 0);
for($i = 0; $i < $length;$i++){
$current = substr($string,$i,1);
//main explode function
if($separator == $current){
$increment++;
}
elseif($separator == ""){
@$returnarray[$increment].=$current;
$increment++;
}
else{
@$returnarray[$increment].=$current;
}
//if limit is positive
if(isset($limit) && $limit == $increment){
break;
}
}
//if limit is negative
if($limit_negative){
for($i = 0; $i > $limit;$i--){
array_pop($returnarray);
}
}
return $returnarray;
}
//Test
$something = "Kamba.jeno.attila";
$result = exploding(".",$something)
/*returns
array(3) {
[0]=> string(5) "Kamba"
[1]=> string(4) "Jeno"
[2]=> string(6) "Attila" }
*/
$result2 = exploding(".",$something,1)
/*returns
array(1) {
[0]=> string(5) "Kamba" }
*/
$result3 = exploding(".",$something,-1)
/*returns
array(2) {
[0]=> string(5) "Kamba"
[1]=> string(4) "Jeno" }
*/
?>
drieick at hotmail dot com ¶
3 years ago
When explode is given an empty $string, it'll return an array with a single empty element.
<?php
# returns Array([0] => );
print_r(explode(',', ''));
?>
This is not a bug, but it can be pretty tricky (especially with callbacks that expect a certain type of array). So, be sure to check your arrays. It's not a bug, because there's nothing to split.
vzverev at nm dot ru ¶
3 years ago
If you are going to use foreach after explode(), call reset() before foreach:
<?php
$arr = explode("\n", 'test \n test2 \n test3');
reset($arr);
foreach($arr as $line)
{ /* do something */ ; }
?>
Rijk van Wel ¶
1 year ago
Here's another one of those functions that allow you to work with an escaped delimiter. It works by internally url-encoding the escaped delimiters before calling explode(). So if your delimiter is a %, you should use another encoding function ;)
<?php
function explode_escaped( $delimiter, $string ) {
$string = str_replace( '\\' . $delimiter, urlencode( $delimiter ), $string );
return array_map( 'urldecode', explode( $delimiter, $string ) );
}
?>
lm at ms dot net ¶
2 years ago
while explode() and implode() are counterparts, note that it does NOT work for an empty delimiter!
solution: use str_split($str) instead of explode('', $str)
example:
<?php
$str1 = 'abc';
var_dump($str1);
$str2 = implode(',' , explode(',' , $str1)); // OK (explode with non-empty delimiter)
var_dump($str2);
$str3 = implode('' , str_split($str1)); // OK (str_split)
var_dump($str3);
$str4 = implode('' , explode('' , $str1)); // ERROR! (explode with empty delimiter)
var_dump($str4);
?>
returns:
string 'abc' (length=3)
string 'abc' (length=3)
string 'abc' (length=3)
Warning: explode() [function.explode]: Empty delimiter.
Warning: implode() [function.implode]: Bad arguments.
null
info at noextratime dot com ¶
2 years ago
Here is a function for "double" exploding a string, like in the case of a flattened multi-dimensional array.
<?php
function doubleExplode ($del1, $del2, $array){
$array1 = explode("$del1", $array);
foreach($array1 as $key=>$value){
$array2 = explode("$del2", $value);
foreach($array2 as $key2=>$value2){
$array3[] = $value2;
}
}
$afinal = array();
for ( $i = 0; $i <= count($array3); $i += 2) {
if($array3[$i]!=""){
$afinal[trim($array3[$i])] = trim($array3[$i+1]);
}
}
return $afinal;
}
$proddetails = 'Size=Large, Color=Black';
$test = doubleExplode(',', '=', $proddetails);
print_r($test);
?>
/*
Array
(
[Size] => Large
[Color] => Black
)
*/
Elad Elrom ¶
4 years ago
<?php
// Remove words if more than max allowed character are insert or add a string in case less than min are displayed
// Example: LimitText("The red dog ran out of thefence",15,20,"<br>");
function LimitText($Text,$Min,$Max,$MinAddChar) {
if (strlen($Text) < $Min) {
$Limit = $Min-strlen($Text);
$Text .= $MinAddChar;
}
elseif (strlen($Text) >= $Max) {
$words = explode(" ", $Text);
$check=1;
while (strlen($Text) >= $Max) {
$c=count($words)-$check;
$Text=substr($Text,0,(strlen($words[$c])+1)*(-1));
$check++;
}
}
return $Text;
}
?>