<?php
function mb_str_replace($needle, $replacement, $haystack)
{
    $needle_len = mb_strlen($needle);
    $replacement_len = mb_strlen($replacement);
    $pos = mb_strpos($haystack, $needle);
    while ($pos !== false)
    {
        $haystack = mb_substr($haystack, 0, $pos) . $replacement
                . mb_substr($haystack, $pos + $needle_len);
        $pos = mb_strpos($haystack, $needle, $pos + $replacement_len);
    }
    return $haystack;
}
?>

<?php

function mb_trim( $string )

{

    $string = preg_replace( "/(^\s+)|(\s+$)/us", "", $string );

   

    return $string;

}

?>

<?php

$string  = '漢字はユニコード';
$needle  = 'は';
$replace = 'Foo';

echo str_replace($needle, $replace, $string);
// outputs: 漢字Fooユニコード

?>

$string = mb_ereg_replace( "^($encoded_char_list)*", "", $string );
    $string = mb_ereg_replace( "($encoded_char_list)*$", "", $string );
    return $string;
}
?>

<?php
    function mb_str_split($string, $split_length = 1){
           
        mb_internal_encoding('UTF-8');
        mb_regex_encoding('UTF-8'); 
       
        $split_length = ($split_length <= 0) ? 1 : $split_length;
       
        $mb_strlen = mb_strlen($string, 'utf-8');
       
        $array = array();
               
        for($i = 0; $i < $mb_strlen; $i + $split_length){
       
            $array[] = mb_substr($string, $i, $split_length);
        }

return $array;
   
    }
?>

<?php

// multibyte string split

function mbStringToArray ($str) {
    if (empty($str)) return false;
    $len = mb_strlen($str);
    $array = array();
    for ($i = 0; $i < $len; $i++) {
        $array[] = mb_substr($str, $i, 1);
        }
    return $array;
    }

// removes $rem at both ends

function mb_trim ($str, $rem = ' ') {
    if (empty($str)) return false;
    // convert to array
    $arr = mbStringToArray($str);
    $len = count($arr);
    // left side
    for ($i = 0; $i < $len; $i++) {
        if ($arr[$i] === $rem) $arr[$i] = '';
        else break;
        }
    // right side
    for ($i = $len-1; $i >= 0; $i--) {
        if ($arr[$i] === $rem) $arr[$i] = '';
        else break;
        }
    // convert to string
    return implode ('', $arr);
    }

?>

<?php

function mb_substr_replace($output, $replace, $posOpen, $posClose) {

        return mb_substr($output, 0, $posOpen).$replace.mb_substr($output, $posClose+1);

    }

?>

Thanks to marc at ermshaus dot org for the original.

<?php

if(!function_exists('mb_str_replace')) {

function mb_str_replace($search, $replace, $subject) {

if(is_array($subject)) {
            $ret = array();
            foreach($subject as $key => $val) {
                $ret[$key] = mb_str_replace($search, $replace, $val);
            }
            return $ret;
        }

foreach((array) $search as $key => $s) {
            if($s == '') {
                continue;
            }
            $r = !is_array($replace) ? $replace : (array_key_exists($key, $replace) ? $replace[$key] : '');
            $pos = mb_strpos($subject, $s);
            while($pos !== false) {
                $subject = mb_substr($subject, 0, $pos) . $r . mb_substr($subject, $pos + mb_strlen($s));
                $pos = mb_strpos($subject, $s, $pos + mb_strlen($r));
            }
        }

return $subject;

}

}

?>

<?php

function mb_str_pad ($input, $pad_length, $pad_string, $pad_style, $encoding="UTF-8") {

   return str_pad($input,

strlen($input)-mb_strlen($input,$encoding)+$pad_length, $pad_string, $pad_style);

}

?>

Unlike other approaches that I've seen to this problem, I wanted to
emulate the full functionality of trim() - in particular, the ability to
customise the character list.

<?php

    /**

     * Trim characters from either (or both) ends of a string in a way that is

     * multibyte-friendly.

     *

     * Mostly, this behaves exactly like trim() would: for example supplying 'abc' as

     * the charlist will trim all 'a', 'b' and 'c' chars from the string, with, of

     * course, the added bonus that you can put unicode characters in the charlist.

     *

     * We are using a PCRE character-class to do the trimming in a unicode-aware

     * way, so we must escape ^, \, - and ] which have special meanings here.

     * As you would expect, a single \ in the charlist is interpretted as

     * "trim backslashes" (and duly escaped into a double-\ ). Under most circumstances

     * you can ignore this detail.

     *

     * As a bonus, however, we also allow PCRE special character-classes (such as '\s')

     * because they can be extremely useful when dealing with UCS. '\pZ', for example,

     * matches every 'separator' character defined in Unicode, including non-breaking

     * and zero-width spaces.

     *

     * It doesn't make sense to have two or more of the same character in a character

     * class, therefore we interpret a double \ in the character list to mean a

     * single \ in the regex, allowing you to safely mix normal characters with PCRE

     * special classes.

     *

     * *Be careful* when using this bonus feature, as PHP also interprets backslashes

     * as escape characters before they are even seen by the regex. Therefore, to

     * specify '\\s' in the regex (which will be converted to the special character

     * class '\s' for trimming), you will usually have to put *4* backslashes in the

     * PHP code - as you can see from the default value of $charlist.

     *

     * @param string

     * @param charlist list of characters to remove from the ends of this string.

     * @param boolean trim the left?

     * @param boolean trim the right?

     * @return String

     */

    function mb_trim($string, $charlist='\\\\s', $ltrim=true, $rtrim=true)

    {

        $both_ends = $ltrim && $rtrim;

$char_class_inner = preg_replace(

            array( '/[\^\-\]\\\]/S', '/\\\{4}/S' ),

            array( '\\\\\\0', '\\' ),

            $charlist

        );

$work_horse = '[' . $char_class_inner . ']+';

        $ltrim && $left_pattern = '^' . $work_horse;

        $rtrim && $right_pattern = $work_horse . '$';

if($both_ends)

        {

            $pattern_middle = $left_pattern . '|' . $right_pattern;

        }

        elseif($ltrim)

        {

            $pattern_middle = $left_pattern;

        }

        else

        {

            $pattern_middle = $right_pattern;

        }

return preg_replace("/$pattern_middle/usSD", '', $string) );

    }

?>

The problem occurs when a file is filled with a string using fwrite in the following manner:

$len = strlen($data);
fwrite($fp, $data, $len);

fwrite takes amount of bytes as the third parameter, but mb_strlen
returns the amount of characters in the string. Since multibyte
characters are possibly more than one byte in length each - this will
result in that the last characters of $data never gets written to the
file.

After hours of investigating why PEAR::Cache_Lite didn't work - the above is what I found.

I made an attempt at using single byte functions, but it doesn't work. Posting here anyway in case it helps someone else:

/**
* PHP Singe byte functions simulation (non successful)
*
* Usage: sb_string(functionname, arg1, arg2, etc);
* Example: sb_string("strlen", "tuöéä"); returns 8 (should...)
*/
function sb_string() {

$arguments = func_get_args();

$func_overloading = ini_get("mbstring.func_overload");

ini_set("mbstring.func_overload", 0);

$ret = call_user_func_array(array_shift($arguments), $arguments);

ini_set("mbstring.func_overload", $func_overloading);

return $ret;

Some of the functions, for example mb_convert_kana(), make absolutely no sense outside of a Japanese language environment.

It should perhaps be considered "lucky" if the functions work with non-Japanese multi-byte languages.

However, then Excel on Mac OS X doesn't identify columns properly and
its puts each whole row in its own cell. In order to fix that, use TAB
"\\t" character as CSV delimiter rather than comma or colon.

<?php
function str_sizeof($string) {
    return count(preg_split("`.`", $string)) - 1 ;
}
?>

Example:

I wanted a version of mb_str_replace with as similar a code signature
and behavior to str_replace as possible while conforming to the code
signature patterns of the mb library and avoiding performance pitfalls
like unnecessary concatenations and regular expressions.

<?php

/**

 * Multibyte safe version of str_replace.

 * See http://php.net/manual/en/function.str-replace.php

 */

function mb_str_replace(

  $search,

  $replace,

  $subject,

  string $encoding = null,

  int &$count = null) {

if (is_array($subject)) {

    $result = array();

    foreach ($subject as $item) {

      $result[] = mb_str_replace($search, $replace, $item, $encoding, $count);

    }

    return $result;

  }

if (!is_array($search)) {

    return _mb_str_replace($search, $replace, $subject, $encoding, $count);

  }

$replace_is_array = is_array($replace);

  foreach ($search as $key => $value) {

    $subject = _mb_str_replace(

      $value,

      $replace_is_array ? $replace[$key] : $replace,

      $subject,

      $encoding,

      $count

    );

  }

  return $subject;

}

/**

 * Implementation of mb_str_replace. Do not call directly. Enforces string parameters.

 */

function _mb_str_replace(

  string $search,

  string $replace,

  string $subject,

  string $encoding = null,

  int &$count = null) {

$search_length = mb_strlen($search, $encoding);

  $subject_length = mb_strlen($subject, $encoding);

  $offset = 0;

  $result = '';

while ($offset < $subject_length) {

    $match = mb_strpos($subject, $search, $offset, $encoding);

    if ($match === false) {

      if ($offset === 0) {

        // No match was ever found, just return the subject.

        return $subject;

      }

      // Append the final portion of the subject to the replaced.

      $result .=

        mb_substr($subject, $offset, $subject_length - $offset, $encoding);

      break;

    }

    if ($count !== null) {

      $count++;

    }

    $result .= mb_substr($subject, $offset, $match - $offset, $encoding);

    $result .= $replace;

    $offset = $match + $search_length;

  }

return $result;

}

?>

header("Content-type: application/octet-stream");
header("Content-Transfer-Encoding: binary");
header("Content-Disposition: attachment; filename=report.xls");
   
// assume $tmpString contains UTF-8 encoded CSV:
$tmpString =  iconv ( 'UTF-8', 'UTF-16LE//IGNORE', $tmpString );

if you have dowloaded  the "short" version of PHP,
(php-4.3.10-installer.exe), download the full version .
(php-4.3.10-Win32.zip)

unzip it, find php_mbstring.dll in
f:\php-4.3.10-Win32\extensions, and copy it across to your
php\extensions directory

use Notepad to open your PHP.INI

change the extension_dir line to read
extension_dir = "e:\php\extensions\"  (or whatever your
directory is called)

remove the semi-colon on line
 ; extension=php_mbstring.dll