International PHP Conference Berlin 2021
    Submit a Pull Request Report a Bug

    str_split

    (PHP 5, PHP 7, PHP 8)

    str_split — Convert a string to an array

    Description

    str_split ( string $string , int $length = 1 ) : array

    Converts a string to an array.

    Parameters

    string

    The input string.

    length

    Maximum length of the chunk.

    Return Values

    If the optional length parameter is specified, the returned array will be broken down into chunks with each being length in length, otherwise each chunk will be one character in length.

    false is returned if length is less than 1. If the length length exceeds the length of string, the entire string is returned as the first (and only) array element.

    Examples

    Example #1 Example uses of str_split()

    <?php

    $str     = "Hello Friend";

    $arr1 = str_split($str);
    $arr2 = str_split($str, 3);

    print_r($arr1);
    print_r($arr2);

    ?>

    The above example will output:

    Array
(
    [0] => H
    [1] => e
    [2] => l
    [3] => l
    [4] => o
    [5] =>
    [6] => F
    [7] => r
    [8] => i
    [9] => e
    [10] => n
    [11] => d
)

Array
(
    [0] => Hel
    [1] => lo
    [2] => Fri
    [3] => end
)

    Notes

    Note:

    str_split() will split into bytes, rather than characters when dealing with a multi-byte encoded string.

    See Also

    add a note add a note

    User Contributed Notes 39 notes

    up
    125
    qeremy [atta] gmail [dotta] com
    9 years ago
    A proper unicode string split;

    <?php
    function str_split_unicode($str, $l = 0) {
        if (    $l > 0) {
                $ret = array();
                $len = mb_strlen($str, "UTF-8");
            for (    $i = 0; $i < $len; $i += $l) {
                    $ret[] = mb_substr($str, $i, $l, "UTF-8");
            }
            return     $ret;
        }
        return     preg_split("//u", $str, -1, PREG_SPLIT_NO_EMPTY);
    }
    ?>

    $s = "Ilık süt"; // Mild milk

    print_r(str_split($s, 3));
    print_r(str_split_unicode($s, 3));

    Array
    (
        [0] => Il�
        [1] => �k
        [2] => sü
        [3] => t
    )

    Array
    (
        [0] => Ilı
        [1] => k s
        [2] => üt
    )
    up
    26
    qeremy [atta] gmail [dotta] com
    7 years ago
    A new version of "str_split_unicode" prev.

    <?php
    function str_split_unicode($str, $length = 1) {
            $tmp = preg_split('~~u', $str, -1, PREG_SPLIT_NO_EMPTY);
        if (    $length > 1) {
                $chunks = array_chunk($tmp, $length);
            foreach (    $chunks as $i => $chunk) {
                    $chunks[$i] = join('', (array) $chunk);
            }
                $tmp = $chunks;
        }
        return     $tmp;
    }
    ?>

    $s = 'Özgür Yazılım!'; // Open Source!

    print_r(str_split_unicode($s));
    print_r(str_split_unicode($s, 3));

    Array
    (
        [0] => Ö
        [1] => z
        [2] => g
        [3] => ü
        [4] => r
        [5] => 
        [6] => Y
        [7] => a
        [8] => z
        [9] => ı
        [10] => l
        [11] => ı
        [12] => m
        [13] => !
    )
    Array
    (
        [0] => Özg
        [1] => ür
        [2] => Yaz
        [3] => ılı
        [4] => m!
    )
    up
    11
    Anonymous
    13 years ago
    Version of str_split by rlpvandenberg at hotmail dot com is god-damn inefficient and when $i+$j > strlen($text) [last part of string] throws a lot of notice errors. This should work better:

        if(! function_exists('str_split'))
        {
            function str_split($text, $split = 1)
            {
                $array = array();
               
                for ($i = 0; $i < strlen($text);)
                {
                    $array[] = substr($text, $i, $split);
                    $i += $split;
                }
               
                return $array;
            }
        }
    up
    6
    robert dot johnson at icap dot com
    6 years ago
    <?php
    /* Another implementation of str_split_unicode: */
    function str_split_unicode($str, $l = 0)
    {
        return     preg_split('/(.{'.$l.'})/us', $str, -1, PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE);
    }
    ?>
    up
    8
    nemostein at hotmail dot com
    11 years ago
    The manual don't says what is returned when you parse a different type of variable.

    This is the example:

    <?php

    $str1     = "Long"; // More than 1 char
    $str2 = "x"; // Only 1 char
    $str3 = ""; // Empty String
    $str4 = 34; // Integer
    $str5 = 3.4; // Float
    $str6 = true; // Bool
    $str7 = null; // Null

    $spl1 = str_split($str1);
    $spl2 = str_split($str2);
    $spl3 = str_split($str3);
    $spl4 = str_split($str4);
    $spl5 = str_split($str5);
    $spl6 = str_split($str6);
    $spl7 = str_split($str7);

    echo     count($spl1); // 4
    echo count($spl2); // 1
    echo count($spl3); // 1
    echo count($spl4); // 2
    echo count($spl5); // 3
    echo count($spl6); // 1
    echo count($spl7); // 1

    print_r($spl1);
    print_r($spl2);
    print_r($spl3);
    print_r($spl4);
    print_r($spl5);
    print_r($spl6);
    print_r($spl7);

    /*

    Array
    (
        [0] => L
        [1] => o
        [2] => n
        [3] => g
    )
    Array
    (
        [0] => x
    )
    Array
    (
        [0] =>
    )
    Array
    (
        [0] => 3
        [1] => 4
    )
    Array
    (
        [0] => 3
        [1] => .
        [2] => 4
    )
    Array
    (
        [0] => 1
    )
    Array
    (
        [0] =>
    )

    */

    ?>
    up
    4
    stlawson AT JoyfulEarthTech DOT com
    7 years ago
    The documentation fails to mention what happens when the string length does not divide evenly with the chunk size.  Not sure if the same behavior for all versions of PHP so I offer the following code to determine this for your installation.  On mine [version 5.2.17], the last chunk is an array the length of the remaining chars.

    <?php

    $da_string     = "When number of chars does't divide evenly";
    $len = strlen($da_string);
    $chunk_size = 8;
    echo     "<p> Length of <span style='font-family:monospace'>$da_string</span>: $len</p>\n";
    echo     "<p> Chunck size: $chunk_size</p>\n";
    $parts = str_split($da_string, $chunk_size);
    $html = "<table border='5' cellpadding='3' cellspacing='4'>\n";
    foreach (    $parts as $idx=>$part)
    {
           $html .= "<tr>\n";
           $html .= "<td style='font-family:monospace'>$part</td>";
           $chars = str_split($part);
       foreach (    $chars as $char)
       {
           if (    $char === ' ')
           {
                   $html .= "<td>&nbsp;</td>";
           }
           else
           {
                   $html .= "<td>$char</td>";
           }
       }
           $html .= "</tr>\n";
    }
    $html .= "</table>\n";
    echo     $html;
    ?>
    up
    5
    anon
    10 years ago
    I needed a function that could split a string from the end with any left over chunk being at the beginning of the array (the beginning of the string).

    <?php
    function str_rsplit($str, $sz)
    {
            // splits a string "starting" at the end, so any left over (small chunk) is at the beginning of the array.   
            if ( !$sz ) { return false; }
        if (     $sz > 0 ) { return str_split($str,$sz); }    // normal split
       
            $l = strlen($str);
            $sz = min(-$sz,$l);
            $mod = $l % $sz;
       
        if ( !    $mod ) { return str_split($str,$sz); }    // even/max-length split

        // split
            return array_merge(array(substr($str,0,$mod)), str_split(substr($str,$mod),$sz));
    }

    $str = 'aAbBcCdDeEfFg';
    str_split($str,5); // return: {'aAbBc','CdDeE','fFg'}
    str_rsplit($str,5); // return: {'aAbBc','CdDeE','fFg'}
    str_rsplit($str,-5); // return: {'aAb','BcCdD','eEfFg'}

    ?>
    up
    5
    Daniel Rhodes
    5 years ago
    It's mentioned in the Return Values section above ("If the split_length length exceeds the length of string, the entire string is returned as the first (and only) array element"), but note that an input of empty string will return array(1) { [0]=> string(0) "" }. Interestingly an input of NULL will also return array(1) { [0]=> string(0) "" }.

    Compare this with, say, <?php  preg_split('//', $inputString, -1, PREG_SPLIT_NO_EMPTY); ?> which will return array(0) { } for an input of empty string or NULL. I find this to be a bit more intuitive.

    Hope this helps.
    up
    4
    Razor
    13 years ago
    heres my version for php4 and below

    <?php

    function str_split_php4($text, $split = 1)
    {
        if (!    is_string($text)) return false;
        if (!    is_numeric($split) && $split < 1) return false;
       
            $len = strlen($text);
       
            $array = array();
       
            $i = 0;
       
        while (    $i < $len)
        {
                $key = NULL;
           
            for (    $j = 0; $j < $split; $j += 1)
            {
                    $key .= $text{$i};
               
                    $i += 1;   
            }
           
                $array[] = $key;
        }
       
        return     $array;
    }

    ?>
    up
    2
    Hage Yaapa
    15 years ago
    The very handy str_split() was introduced in PHP 5, but a lot of us are still forced to use PHP 4 at our host servers. And I am sure a lot of beginners have looked or are looking for a function to accomplish what str_split() does.

    Taking advantge of the fact that strings are 'arrays' I wrote this tiny but useful e-mail cloaker in PHP, which guarantees functionality even if JavaScript is disabled in the client's browser. Watch how I make up for the lack of str_split() in PHP 4.3.10.

    <?php

    // cloackEmail() accepts a string, the email address to be cloaked
    function cloakEmail($email) {

    // We create a new array called $arChars, which will contain the individula characters making up the email address. The array is blank for now.
            $arChars = array();

    // We extract each character from the email 'exploiting' the fact that strings behave like an array: watch the '$email[$i]' bit, and beging to fill up the blank array $arChars
            for ($i = 0; $i < strlen($email); $i++) { $arChars[] = $email[$i]; }

    // Now we work on the $arChars array: extract each character in the array and print out it's ASCII value prefixed with '&#' to convert it into an HTML entity
            foreach ($arChars as $char) { print '&#'.ord($char); }

    // The result is an email address in HTML entities which, I hope most email address harvesters can't read.

    }
    print     cloakEmail('someone@nokikon.com');
    ?>

    ###### THE CODE ABOVE WITHOUT COMMENTS ######

    <?php
    function cloakEmail($email) {
            $arChars = array();
        for (    $i = 0; $i < strlen($email); $i++) { $arChars[] = $email[$i]; }
        foreach (    $arChars as $char) { print '&#'.ord($char); }
    }
    print     cloakEmail('someone@nokikon.com');
    ?>
    In creating this little utility, I demonstrated how the lack of str_split() can be made up in PHP < 5. If you got how it was accomplished, you could write a function to do exactly what str_split() does in PHP 5 and even name it 'str_split()'. :)
    up
    4
    rrelmy
    12 years ago
    revised function from tatsudoshi

    Fixed some bugs, more php5 style compliant
    <?php
    if(!function_exists('str_split')) {
        function     str_split($string,$string_length=1) {
            if(    strlen($string)>$string_length || !$string_length) {
                do {
                        $c = strlen($string);
                        $parts[] = substr($string,0,$string_length);
                        $string = substr($string,$string_length);
                } while(    $string !== false);
            } else {
                    $parts = array($string);
            }
            return     $parts;
        }
    }
    ?>
    up
    3
    rlpvandenberg at hotmail dot com
    13 years ago
    The previous suggestion is almost correct (and will only working for strlen=1. The working PHP4 function is:

    <code>
    function str_split($text, $split = 1){
        //place each character of the string into and array
        $array = array();
        for ($i=0; $i < strlen($text); $i++){
            $key = "";
            for ($j = 0; $j < $split; $j++){
                $key .= $text[$i+$j]; 
            }
            $i = $i + $j - 1;
            array_push($array, $key);
        }
        return $array;
    }
    </code>
    up
    4
    vec [ at t] g dot com
    12 years ago
    the fastast way (that fits my needs) to replace str_split() in php 4 i found is this:

    <?php
    if(!function_exists('str_split')) {
      function     str_split($string, $split_length = 1) {
            $array = explode("\r\n", chunk_split($string, $split_length));
            array_pop($array);
        return     $array;
      }
    }
    ?>

    i also tested the provided functions in the comments..

    (the differences are 0.001 to 0.00001 sec)
    up
    1
    mohd at ba7rain dot net
    13 years ago
    this function can perform a reverse str_split. I write it for PHP4 but you can rename It for other versions..

    if ( !function_exists('str_split') ) {
    function str_split($string,$split_length=1){
        $sign = (($split_length<0)?-1:1);
        $strlen = strlen($string);
        $split_length = abs($split_length);
        if ( ($split_length==0) || ($strlen==0) ){
                $result = false;
                //$result[] = "";
        }
        elseif ($split_length >= $strlen){
            $result[] = $string;
        }
        else {
            $length = $split_length;
            for ($i=0; $i<$strlen; $i++){
                $i=(($sign<0)?$i+$length:$i);
                $result[] = substr($string,$sign*$i,$length);
                $i--;
                $i=(($sign<0)?$i:$i+$length);
                if ( ($i+$split_length) > ($strlen) ){
                    $length = $strlen-($i+1);
                }
                else {
                    $length = $split_length;
                }
            }
        }
        return $result;
    }
    }
    up
    1
    webmaster at nsssa dot ca
    14 years ago
    I noticed in the post below me that his function would return an array with an empty key at the end.

    So here is just a little fix for it.

    <?php

    //Create a string split function for pre PHP5 versions
    function str_split($str, $nr) {  
                
             //Return an array with 1 less item then the one we have
             return array_slice(split("-l-", chunk_split($str, $nr, '-l-')), 0, -1);
         
    }

    ?>
    up
    1
    carlosreche at yahoo dot com
    15 years ago
    For those who work with PHP < 5:

    <?php

    if (!function_exists("str_split")) {
        function     str_split($string, $length = 1) {
            if (    $length <= 0) {
                    trigger_error(__FUNCTION__."(): The the length of each segment must be greater then zero:", E_USER_WARNING);
                return     false;
            }
                $splitted  = array();
                $str_length = strlen($string);
                $i = 0;
            if (    $length == 1) {
                while (    $str_length--) {
                        $splitted[$i] = $string[$i++];
                }
            } else {
                    $j = $i;
                while (    $str_length > 0) {
                        $splitted[$j++] = substr($string, $i, $length);
                        $str_length -= $length;
                        $i += $length;
                }
            }
            return     $splitted;
        }
    }

    ?>
    up
    1
    jakub dot lopuszanski at nasza-klasa dot pl
    7 years ago
    To split UTF-8 into 16-charcater slices you can use:
    <?php
    preg_split    ('/(?=(.{16})*$)/u', $text);
    ?>
    You can also use look-behind instead of look-ahead if you want the first (not the last) chunk to be the shortest.
    up
    2
    dacmeaux at gmail dot com
    13 years ago
    I was looking for a function that would split a string into an array like str_split() and found Razor's function above. Just though that I would simplify the code a little.

    <?php
    function str_split_php4($text, $split = 1){
            //place each character of the string into and array
            $array = array();
        for(    $i=0; $i < strlen($text); $i++){
                $key = NULL;
            for (    $j = 0; $j < $split; $j++){
                    $key .= $text[$i]; 
            }
                array_push($array, $key);
        }
        return     $array;
    }
    ?>

    Both mine and worksRazor's work well, I just prefer to use less code. I could have written one myself, but I was just being lazy.
    up
    1
    magisano at cs dot unibo dot it
    13 years ago
    Even shorter version:

    //place each character (or group of) of the
    string into and array

    function str_split_php4($sText, $iSplit = 1)
    {
        $iSplit=(integer) $iSplit;       // sanity check
        if ($iSplit < 1) {  return false; }
        $aResult = array();
        for($i=0, $limit=strlen($sText); $i < $limit; $i+=$iSplit) {
            $aResult[]=substr($sText, $i, $iSplit);
        }
        return $aResult;
    }
    up
    2
    fstorm2 at gmail dot com
    14 years ago
    If you use PHP 4 and don't need the split_length parameter, here's the shortest replacement:

    <?php

    preg_split    ('#(?<=.)(?=.)#s', $str);

    ?>
    up
    1
    veszelovszki at gmail dot com
    5 years ago
    Here is a better version of queremy@gmail.com's solution. It has the exact same interface as str_split, but works with any UTF-8 string.

    <?php
    if (!function_exists('mb_str_split')) {
            /**
         * Converts an UTF-8 string to an array.
         *
         * E.g. mb_str_split("Hello Friend");
         * returns ['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
         *
         * @param string $string The input string.
         * @param int $split_length Maximum length of the chunk. If specified, the returned array will be broken down
         *        into chunks with each being split_length in length, otherwise each chunk will be one character in length.
         * @return array|boolean
         *         -
         *         - If the split_length length exceeds the length of string, the entire string is returned
         *           as the first (and only) array element.
         *         - False is returned if split_length is less than 1.
         */
            function mb_str_split($string, $split_length = 1)
        {
            if (    $split_length == 1) {
                return     preg_split("//u", $string, -1, PREG_SPLIT_NO_EMPTY);
            } elseif (    $split_length > 1) {
                    $return_value = [];
                    $string_length = mb_strlen($string, "UTF-8");
                for (    $i = 0; $i < $string_length; $i += $split_length) {
                        $return_value[] = mb_substr($string, $i, $split_length, "UTF-8");
                }
                return     $return_value;
            } else {
                return     false;
            }
        }
    }
    ?>
    up
    1
    seebz.net
    10 years ago
    here an equivalent function for unicode string :

    <?php
    function uni_strsplit($string, $split_length=1)
    {
            preg_match_all('`.`u', $string, $arr);
            $arr = array_chunk($arr[0], $split_length);
            $arr = array_map('implode', $arr);
        return     $arr;
    }
    up
    1
    atolia at gmail----- dot com
    13 years ago
    i use this in PHP4

    function str_split($str){
       return preg_split('//',$str);
    }
    up
    1
    kjensen at iaff106 dot com
    13 years ago
    Here is what I use. I started with examples here but modified to my own version:

    <?php
    if (phpversion () < "5"){ // define PHP5 functions if server uses PHP4

    function str_split($text, $split = 1)
    {
    if (!    is_string($text)) return false;
    if (!    is_numeric($split) && $split < 1) return false;
    $len = strlen($text);
    $array = array();
    $s = 0;
    $e=$split;
    while (    $s <$len)
        {
                $e=($e <$len)?$e:$len;
                $array[] = substr($text, $s,$e);
                $s = $s+$e;
        }
    return     $array;
    }
    }
    ?>
    up
    1
    mattias at lsahlin dot se
    11 years ago
    For those it may concern:

    We encountered trubble when trying to str_split a UTF-8 encoded string, containing such Swedish letters as å, å and ö.

    It seems that this function splits according to byte-length and not character length. So if the letter "Å" takes 2 bytes, then str_split() will only return the first bite of the character "Å".

    We ain't 100% sure that this is the case but this was anyhow the result we got. So we used the multi-byte functions instead.
    up
    0
    kunal dot b at indiaproperty dot com
    6 years ago
    Note that in atleast in PHP 5.5.9 (Zend Engine v2.5.0), str_split with an integer value as an argument may return unpredictable results.

    If your number contains leading 0's, the result array is unprdictable as it may contain any number of digits from the argument or (mostly) just a 0.

    Here are a list of possible values that might be returned:
    -Interger

    <?php
    print_r    (str_split(0080450));  // does not work
    print_r(str_split(strval(0080450)));  // neither this

    /*
    * Outputs:
    * Array
    * (
    *     [0] => 0
    * )
    */
    ?>

    BUT
    <?php
    print_r    (str_split(80450));  // works fine
    print_r(str_split(strval(80450)));  // so does this

    /*
    * Outputs:
    * (
    *     [0] => 8
    *     [1] => 0
    *     [2] => 4
    *     [3] => 5
    *     [4] => 0
    * )
    */
    ?>

    Floating point numbers have their leading and trailing 0s cut off:
    <?php
    print_r    (str_split(0080450.0010));   // works but.. print_r(str_split(strval(0080450.0010)));  // same here..

    /*
    Outputs:
    * Array
    * (
    *     [0] => 8
    *     [1] => 0
    *     [2] => 4
    *     [3] => 5
    *     [4] => 0
    *     [5] => .
    *     [6] => 0
    *     [7] => 0
    *     [8] => 1
    * )
    */
    ?>

    I'm not sure if this can be considered a bug, since this is due to how type conversion and casting works, so i just posted it here.
    I've notced that this is how strval() works. Can anyone shed light into this?..
    up
    0
    ricordati at web dot de
    12 years ago
    To split unicode text, preg_match_all('/./u', $text, $array); seems faster for large strings than the use of preg_split('//u', $text); suggested by "edgaras dot janusauskas at gmail dot com" below.
    up
    0
    Sam
    13 years ago
    A good way to use this method to convert CamelCase text into nice text would be-

    <?php
                /**
             Returns a formatted string based on camel case.
             e.g. "CamelCase" -> "Camel Case".
            */
                function FormatCamelCase( $string ) {
                        $output = "";
                    foreach(     str_split( $string ) as $char ) {
                                strtoupper( $char ) == $char and $output and $output .= " ";
                                $output .= $char;
                    }
                    return     $output;
            }
    ?>
    up
    0
    malmsteenforce at tlen dot pl
    14 years ago
    <?
    //fast & short version od str_split

    function string_split($str)
          {
            $str_array=array();
            $len=strlen($str);
            for($i=0;$i<$len;$i++) $str_array[]=$str{$i};
            return $str_array;
           }
    //example :
    var_dump (string_split("split this"));
    ?>
    up
    0
    heavyraptor
    14 years ago
    I think that the last post by carlosreche at yahoo dot com is too complicated.
    It's much easier if you do it like this:

    <?php
    if (!function_exists("str_split")) {
      function     str_split($str,$length = 1) {
        if (    $length < 1) return false;
            $strlen = strlen($str);
            $ret = array();
        for (    $i = 0; $i < $strlen; $i += $length) {
             $ret[] = substr($str,$i,$length);
        }
        return     $ret;
      }
    }
    ?>

    I hope it helps for those with PHP <5
    up
    -1
    Anonymous
    3 years ago
    This is very good. I love PHP. Woderful!
    up
    -1
    l0c4lh0st DOT nl AT gmail DOT com
    13 years ago
    how I can conwert
    $string
    '1, 2, 5, 6, 10, 13, 23'
    from ENUM at mySQL to

    $array
    [0] -> false
    [1] -> true
    [2] -> true
    [3] -> false
    [4] -> false
    [5] -> true
    [6] -> true
    [7] -> false
    [8] -> false
    [9] -> false
    [10] -> true
    [11] -> false
    [12] -> false
    [13] -> true
    [14] -> false
    [15] -> false
    ...
    [23] -> true

    <?php
    function enum_to_array($psEnum)
    {
            $aReturn = array();
            $aTemp = explode(', ', $psEnum);
        for (    $i = $aTemp[0]; $i <= $aTemp[count($aTemp)-1]; $i++)
        {
                $aReturn[$i] = in_array($i, $aTemp);
        }
    }
    ?>
    up
    -1
    user at mockme dot com
    14 years ago
    found this great example on a php board for those not using php5, as an alternative to the posts below this

    <?php
    if(!function_exists('str_split')){
        function     str_split($string,$split_length=1){
                $count = strlen($string); 
            if(    $split_length < 1){
                return     false; 
            } elseif(    $split_length > $count){
                return array(    $string);
            } else {
                    $num = (int)ceil($count/$split_length); 
                    $ret = array(); 
                for(    $i=0;$i<$num;$i++){ 
                        $ret[] = substr($string,$i*$split_length,$split_length); 
                } 
                return     $ret;
            }     
        } 
    }
    ?>
    up
    -2
    lskatz at gmail dot com
    12 years ago
    A good use of str_split is reverse translating an amino acid sequence.

    <?php
    /* reverse translate an aa sequence using its dna counterpart */
    function reverseTranslate($aaSeq,$ntSeq){
          $nt=str_split($ntSeq,3);
          $aa=str_split($aaSeq,1);
          $gapChar=array('*','-');

          $numAa=count($aa);
          $ntIndex=0;
          $newNtSeq="";
      for(    $i=0;$i<$numAa;$i++){
            // if the aa is a gap, then just put on a gap character
            if(in_array($aa[$i],$gapChar)){
              $newNtSeq.='---';
        }
        else{
              $newNtSeq.=$nt[$ntIndex];
              $ntIndex++;
        }
      }
      return     $newNtSeq;
    }
    ?>
    up
    -4
    saeedco
    12 years ago
    This function supportes utf8

    (improvement of function str_split_php4)

    i tried this function successfully with these languages
    1- Chinese
    2- Japanese
    3- Arabic
    4- Turkish
    5- Urdu
    6- Russian
    7- Persian

    <?php
    function str_split_php4_utf8($str) {
            // place each character of the string into and array
            $split=1;
            $array = array();
        for (     $i=0; $i < strlen( $str ); ){
                $value = ord($str[$i]);
            if(    $value > 127){
                if(    $value >= 192 && $value <= 223)
                        $split=2;
                elseif(    $value >= 224 && $value <= 239)
                        $split=3;
                elseif(    $value >= 240 && $value <= 247)
                        $split=4;
            }else{
                    $split=1;
            }
                    $key = NULL;
            for (     $j = 0; $j < $split; $j++, $i++ ) {
                    $key .= $str[$i];
            }
                array_push( $array, $key );
        }
        return     $array;
    }
    ?>
    up
    -2
    Perl Rules
    4 years ago
    Unicode str_split without use of mbstring. Based on PCRE_UTF8 feature.

    function mb_str_split($str, $len){
        $chars = preg_split('/(?<!^)(?!$)/u', $str );
        $out = array();
        foreach( array_chunk($chars, $len) as $a ){
            $out[] = join("", $a);
        }
        return $out;
    }
    up
    -4
    kevin at metalaxe dot com
    12 years ago
    Response to "Richard Ayotte 18-Jan-2008 09:27":

    Slight tweak to prevent the need to call another preg_replace, there were also some bugs in this that I'm surprised didn't get noticed (causing duplicate replaces between the preg_replace calls) :)

    Please feel free to optimize further. I'm not the best with lookahead/behinds yet. I also removed the :upper/lower: and it seemed to speed things up too.

    <?php
    $test     = 'CustomerIDWithSomeOtherJETWords';

    preg_replace('/(?!^)[A-Z]{2,}(?=[A-Z][a-z])|[A-Z][a-z]/', ' $0', $test));
    ?>

    Shaves off a little time anyway. :)
    up
    -1
    thax
    12 years ago
    Regarding ricordatis comment on preg_match_all('/./u',...) instead of preg_split('//u',...):
    You'll have to use the pattern '/./us' with preg_match_all to get exactly the same behaviour w.r.t. newlines. Don't know if this is still faster, though. Oh, and the expected result is in $array[0].
    up
    -4
    Anonymous
    8 years ago
    A little one-liner that came in handy. I thought i'd share for those who want to split a string into two parts by the given offset.

    <?php

            /**
        * Split a string into two parts at offset.
        *
        * @param    string    $string
        * @param    integer    $offset
        * @return    mixed    array and bool(false) if offset is out of scope
        */

    function str_osplit($string, $offset){
        return isset(    $string[$offset]) ? array(substr($string, 0, $offset), substr($string, $offset)) : false;
        }

    $str = "Split a string into two parts at offset";
    var_dump(str_osplit($str, 12));

    /**
    * Output:
    array(2) {
      [0]=>
      string(12) "Split a stri"
      [1]=>
      string(27) "ng into two parts at offset"
    }
    */

    ?>
    add a note add a note
    To Top