Search

PHP 8.0.18 Released!

Change language: English

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. Use mb_str_split() to split the
string into code points.

See Also ¶

mb_str_split() - Given a multibyte string,

return an array of its characters
chunk_split() - Split a string into smaller
chunks
preg_split() - Split string by a regular
expression
explode() - Split a string by a string
count_chars() - Return information about
characters used in a string
str_word_count() - Return information about
words used in a string
for

User Contributed Notes 40 notes add a note

up143 qeremy [atta] gmail [dotta] com ¶

down 10 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
)

up25 qeremy [atta] gmail [dotta] com ¶

down 8 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!
)

up8 Anonymous ¶ 14 years ago

down
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;
}
}

up4 mattias at lsahlin dot se ¶13 years ago

down
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.

up2 webmaster at nsssa dot ca ¶

down 15 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);

?>

up3 atolia at gmail----- dot com ¶

down 14 years ago
i use this in PHP4

function str_split($str){
return preg_split('//',$str);
}

up3 stlawson AT JoyfulEarthTech DOT com

¶ down 8 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;
?>

up2 jakub dot lopuszanski at nasza-klasa

dot pldown
¶ 8 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.

up6 nemostein at hotmail dot com ¶

down 12 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] =>
)

*/

?>

up4 rrelmy ¶ 13 years ago

down
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;
}
}
?>

up4 Daniel Rhodes ¶ 7 years ago

down
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.

up4 robert dot johnson at icap dot com ¶

down 7 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_CAP
TURE);
}
?>

up3 rlpvandenberg at hotmail dot com ¶

down 14 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>

up2 ricordati at web dot de ¶ 13 years ago

down
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.

up3 seebz.net ¶ 11 years ago

down
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;
}

up3 Razor ¶ 14 years ago

down
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;
}
 ?>

up3 anon ¶ 11 years ago

down
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'}

?>

up2 magisano at cs dot unibo dot it ¶

down 14 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;
}

up3 vec [ at t] g dot com ¶ 13 years ago

down
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)

up1 mohd at ba7rain dot net ¶14 years ago

down
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;
}
}

up1 kunal dot b at indiaproperty dot com

¶ down 7 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?..

up2 veszelovszki at gmail dot com ¶

down 7 years ago
Here is a better version of
[email protected]'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;
}
}
}
?>

up1 carlosreche at yahoo dot com ¶

down 16 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;
}
}

?>

up1 Sam ¶ 14 years ago

down
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;
}
?>

up1 l0c4lh0st DOT nl AT gmail DOT com ¶

down 14 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);
}
}
?>

up1 dacmeaux at gmail dot com ¶

down 14 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.

up1 kjensen at iaff106 dot com ¶

down 14 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;
}
}
?>

up1 fstorm2 at gmail dot com ¶

15 years ago
down
If you use PHP 4 and don't need the
split_length parameter, here's the
shortest replacement:

<?php

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

?>

up0 alex6ndr1 at gmail dot com ¶

down 9 months ago
If you pass 0 as the second
argument, then an error occurs

ValueError : str_split(): Argument #2

($length) must be greater than 0

up0 malmsteenforce at tlen dot pl ¶

down 15 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"));
?>

up0 heavyraptor ¶ 16 years ago

down
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

up0 Hage Yaapa ¶ 16 years ago

down
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('[email protected]');
?>

###### 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('[email protected]');
?>

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-1 Anonymous ¶ 4 years ago

down
This is very good. I love PHP. Woderful!

up-3 saeedco ¶ 13 years ago

down
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 lskatz at gmail dot com ¶13 years ago

down
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 kevin at metalaxe dot com ¶

down 14 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 ¶ 13 years ago

down
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 ¶ 9 years ago

down
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"
}
*/

?>

up-3 Perl Rules ¶ 5 years ago

down
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 user at mockme dot com ¶

down 16 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_l
ength);
}
return $ret;
}
}
}
?>

add a note

String Functions
addcslashes
addslashes
bin2hex
chop
chr
chunk_split
convert_uudecode
convert_uuencode
count_chars
crc32
crypt
echo
explode
fprintf
get_html_translation_table
hebrev
hex2bin
html_entity_decode
htmlentities
htmlspecialchars_decode
htmlspecialchars
implode
join
lcfirst
levenshtein
localeconv
ltrim
md5_file
md5
metaphone
money_format
nl_langinfo
nl2br
number_format
ord
parse_str
print
printf
quoted_printable_decode
quoted_printable_encode
quotemeta
rtrim
setlocale
sha1_file
sha1
similar_text
soundex
sprintf
sscanf
str_contains
str_ends_with
str_getcsv
str_ireplace
str_pad
str_repeat
str_replace
str_rot13
str_shuffle
» str_split
str_starts_with
str_word_count
strcasecmp
strchr
strcmp
strcoll
strcspn
strip_tags
stripcslashes
stripos
stripslashes
stristr
strlen
strnatcasecmp
strnatcmp
strncasecmp
strncmp
strpbrk
strpos
strrchr
strrev
strripos
strrpos
strspn
strstr
strtok
strtolower
strtoupper
strtr
substr_compare
substr_count
substr_replace
substr
trim
ucfirst
ucwords
utf8_decode
utf8_encode
vfprintf
vprintf
vsprintf
wordwrap
Deprecated
convert_cyr_string
hebrevc

Copyright © 2001-2022 The PHP Group

My PHP.net Contact Other PHP.net sites

Privacy policy View Source