explode

(PHP 4, PHP 5)

explodeSplit 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 limit is set and positive, the returned array will contain a maximum of limit elements with the last element containing the rest of string.

If the limit parameter is negative, all components except the last -limit are returned.

If the limit parameter 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 limit parameter examples

<?php
$str 
'one|two|three|four';

// positive limit
print_r(explode('|'$str2));

// 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

add a note add a note

User Contributed Notes 26 notes

up
52
php at metehanarslan dot com
1 year 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] => )
// )

?>
up
9
nick dot brown at free dot fr
4 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.
up
21
eye_syah88 at yahoo dot com
2 years 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 )
up
12
tiago dot dias at flow-me dot com
3 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
(
)
up
17
m0gr14 at gmail dot com
3 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
                        )

                )

        )

)
*/
?>
up
7
coroa at cosmo-genics dot com
10 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");
up
8
kkobashi at kobashicomputing dot com
1 year 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]*
up
3
m.reesinck
1 year ago
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;
}
?>
up
5
Hayley Watson
1 year 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');
?>
up
4
SR
5 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.
up
2
Jrg Wagner
4 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;
}
?>
up
2
Anonymous
4 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
)
up
2
dhz
3 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));
?>
up
1
gxd305 at gmail dot com
4 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.
up
0
david dot drakulovski at gmail dot com
1 month ago
I made this code for some useful filtering texts with lot of gibberish. Example provided:

<?php
$text
= "There are;many|variations of:passages of Lorem Ipsum available,but the/majority have\"suffered|alteration in some form,by injected humour,or randomised words which don't look even.slightly:believable./";

$delimiter = array(" ",",",".","'","\"","|","\\","/",";",":");
$replace = str_replace($delimiter, $delimiter[0], $text);
$explode = explode($delimiter[0], $replace);

echo
'<pre>';
print_r($explode);
echo
'</pre>';
// replaces many symbols in text, then explodes it
?>

This will output the following:
Array
(
    [0] => There
    [1] => are
    [2] => many
    [3] => variations
    [4] => of
    [5] => passages
    [6] => of
    [7] => Lorem
    [8] => Ipsum
    [9] => available
    [10] => but
    [11] => the
    [12] => majority
    [13] => have
    [14] => suffered
    [15] => alteration
    [16] => in
    [17] => some
    [18] => form
    [19] => by
    [20] => injected
    [21] => humour
    [22] => or
    [23] => randomised
    [24] => words
    [25] => which
    [26] => don
    [27] => t
    [28] => look
    [29] => even
    [30] => slightly
    [31] => believable
    [32] =>
    [33] =>
)
up
0
artaxerxes2 at iname dot com
2 months ago
Note that using explode() on an empty string returns a non-empty array.

So the code:
<?php
  print_r
(explode("|","");
?>
returns:
Array
(
    [0] =>
)

If you need to return an empty array in the case of an empty string, you must call array_diff() after the explode:
<?php
  print_r
(array_diff(explode("|",""),array("")));
?>
returns:
Array
(
)

This is useful in case your use of MySQL's group_concat() returns an empty string for just some records but you want to convert them all to arrays that actually reflect what group_concat() gave you
up
0
crog at gustavus dot edu
8 months ago
Note that while the documentation states the "If limit is set and positive," passing a null-value will still result in triggering the "limit is zero" case (as of PHP 5.4.17).

When passing through values (such as using explode to implement an interface method), you'll need to explicitly check that the limit has been set:

<?php
 
public function split($string, $delimiter, $limit = null)
  {
    return isset(
$limit) ? explode($delimiter, $string, $limit) : explode($delimiter, $string);
  }
?>

Failing to check $limit and simply passing through a null-value will return the same value as if $limit were 0 or 1. To clarify, all of the following will return the same value:

<?php
explode
($string, $delimiter, null);
explode($string, $delimiter, 0);
explode($string, $delimiter, 1);
?>
up
0
Cody G.
3 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.
up
0
Anonymous
4 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;
    }
?>
up
0
Anonymous
4 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";
?>
up
0
Michael
5 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');
 }

?>
up
0
pinkgothic at gmail dot com
6 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. :)
up
0
seventoes at gmail dot com
7 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));
?>
up
-2
locoluis at gmail dot com
4 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.
up
-3
drieick at hotmail dot com
4 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.
up
-5
jessebusman at gmail dot com
3 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
}
?>
To Top