如何在 PHP 中迭代 UTF-8 字符串？

Question

如何使用索引逐个字符地迭代 UTF-8 字符串？

当您使用括号运算符 $str[0] 访问 UTF-8 字符串时，utf 编码的字符由 2 个或更多元素组成。

例如：

$str = "Kąt";
$str[0] = "K";
$str[1] = "�";
$str[2] = "�";
$str[3] = "t";

但我想要：

$str[0] = "K";
$str[1] = "ą";
$str[2] = "t";

mb_substr 是可能的，但这非常慢，即。

mb_substr($str, 0, 1) = "K"
mb_substr($str, 1, 1) = "ą"
mb_substr($str, 2, 1) = "t"

是否有另一种方法可以在不使用mb_substr 的情况下逐个字符地对字符串进行交互？

Answer 1

使用preg_split。 "u" modifier 支持 UTF-8 unicode。

$chrArray = preg_split('//u', $str, -1, PREG_SPLIT_NO_EMPTY);

Answer 2

Preg split 将通过内存异常故障转移非常大的字符串，并且 mb_substr 确实很慢，所以这里有一个简单而有效的代码，我敢肯定，你可以使用它：

function nextchar($string, &$pointer){
    if(!isset($string[$pointer])) return false;
    $char = ord($string[$pointer]);
    if($char < 128){
        return $string[$pointer++];
    }else{
        if($char < 224){
            $bytes = 2;
        }elseif($char < 240){
            $bytes = 3;
        }else{
            $bytes = 4;
        }
        $str =  substr($string, $pointer, $bytes);
        $pointer += $bytes;
        return $str;
    }
}

这是我用来逐个字符循环遍历多字节字符串的，如果我将其更改为下面的代码，性能差异是巨大的：

function nextchar($string, &$pointer){
    if(!isset($string[$pointer])) return false;
    return mb_substr($string, $pointer++, 1, 'UTF-8');
}

使用下面的代码将字符串循环 10000 次，第一个代码的运行时间为 3 秒，第二个代码的运行时间为 13 秒：

function microtime_float(){
    list($usec, $sec) = explode(' ', microtime());
    return ((float)$usec + (float)$sec);
}

$source = 'árvíztűrő tükörfúrógépárvíztűrő tükörfúrógépárvíztűrő tükörfúrógépárvíztűrő tükörfúrógépárvíztűrő tükörfúrógép';

$t = Array(
    0 => microtime_float()
);

for($i = 0; $i < 10000; $i++){
    $pointer = 0;
    while(($chr = nextchar($source, $pointer)) !== false){
        //echo $chr;
    }
}

$t[] = microtime_float();

echo $t[1] - $t[0].PHP_EOL.PHP_EOL;

Answer 3

回复 @Pekla 和 @Col 发布的 cmets。弹片我将preg_split 与mb_substr 进行了比较。

图片显示，preg_split 耗时 1.2 秒，而mb_substr 几乎耗时 25 秒。

这里是函数的代码：

function split_preg($str){
    return preg_split('//u', $str, -1);     
}

function split_mb($str){
    $length = mb_strlen($str);
    $chars = array();
    for ($i=0; $i<$length; $i++){
        $chars[] = mb_substr($str, $i, 1);
    }
    $chars[] = "";
    return $chars;
}

Answer 4

以Lajos Meszaros'奇妙的函数为灵感，我创建了一个多字节字符串迭代器类。

// Multi-Byte String iterator class
class MbStrIterator implements Iterator
{
    private $iPos   = 0;
    private $iSize  = 0;
    private $sStr   = null;

    // Constructor
    public function __construct(/*string*/ $str)
    {
        // Save the string
        $this->sStr     = $str;

        // Calculate the size of the current character
        $this->calculateSize();
    }

    // Calculate size
    private function calculateSize() {

        // If we're done already
        if(!isset($this->sStr[$this->iPos])) {
            return;
        }

        // Get the character at the current position
        $iChar  = ord($this->sStr[$this->iPos]);

        // If it's a single byte, set it to one
        if($iChar < 128) {
            $this->iSize    = 1;
        }

        // Else, it's multi-byte
        else {

            // Figure out how long it is
            if($iChar < 224) {
                $this->iSize = 2;
            } else if($iChar < 240){
                $this->iSize = 3;
            } else if($iChar < 248){
                $this->iSize = 4;
            } else if($iChar == 252){
                $this->iSize = 5;
            } else {
                $this->iSize = 6;
            }
        }
    }

    // Current
    public function current() {

        // If we're done
        if(!isset($this->sStr[$this->iPos])) {
            return false;
        }

        // Else if we have one byte
        else if($this->iSize == 1) {
            return $this->sStr[$this->iPos];
        }

        // Else, it's multi-byte
        else {
            return substr($this->sStr, $this->iPos, $this->iSize);
        }
    }

    // Key
    public function key()
    {
        // Return the current position
        return $this->iPos;
    }

    // Next
    public function next()
    {
        // Increment the position by the current size and then recalculate
        $this->iPos += $this->iSize;
        $this->calculateSize();
    }

    // Rewind
    public function rewind()
    {
        // Reset the position and size
        $this->iPos     = 0;
        $this->calculateSize();
    }

    // Valid
    public function valid()
    {
        // Return if the current position is valid
        return isset($this->sStr[$this->iPos]);
    }
}

可以这样使用

foreach(new MbStrIterator("Kąt") as $c) {
    echo "{$c}\n";
}

哪个会输出

K
ą
t

或者如果你真的想知道起始字节的位置

foreach(new MbStrIterator("Kąt") as $i => $c) {
    echo "{$i}: {$c}\n";
}

哪个会输出

0: K
1: ą
3: t

Answer 5

您可以解析字符串的每个字节并确定它是单个（ASCII）字符还是start of a multi-byte character：

UTF-8 编码是可变宽度的，每个字符由 1 到 4 个字节表示。每个字节有 0-4 个前导连续的“1”位，后跟一个“0”位以指示其类型。 2 个或更多的“1”位表示这么多字节序列中的第一个字节。

您将遍历字符串，而不是将位置增加 1，而是完整读取当前字符，然后将位置增加该字符的长度。

*文章有每个字符的解释表^{[retrieved 2010-10-01]}：

   0-127 Single-byte encoding (compatible with US-ASCII)
 128-191 Second, third, or fourth byte of a multi-byte sequence
 192-193 Overlong encoding: start of 2-byte sequence, 
         but would encode a code point ≤ 127
  ........

Answer 6

我遇到了与 OP 相同的问题，我尽量避免在 PHP 中使用正则表达式，因为它会失败，甚至会因长字符串而崩溃。我使用 Mészáros Lajos' answer 进行了一些更改，因为我将 mbstring.func_overload 设置为 7。

function nextchar($string, &$pointer, &$asciiPointer){
   if(!isset($string[$asciiPointer])) return false;
    $char = ord($string[$asciiPointer]);
    if($char < 128){
        $pointer++;
        return $string[$asciiPointer++];
    }else{
        if($char < 224){
            $bytes = 2;
        }elseif($char < 240){
            $bytes = 3;
        }elseif($char < 248){
            $bytes = 4;
        }elseif($char = 252){
            $bytes = 5;
        }else{
            $bytes = 6;
        }
        $str =  substr($string, $pointer++, 1);
        $asciiPointer+= $bytes;
        return $str;
    }
}

mbstring.func_overload 设置为 7，substr 实际上调用了mb_substr。所以substr 在这种情况下得到了正确的值。我不得不添加第二个指针。一个跟踪字符串中的多字节字符，另一个跟踪单字节字符。多字节值用于substr（因为它实际上是mb_substr），而单字节值用于以这种方式检索字节：$string[$index]。

很明显，如果 PHP 决定修复 [] 访问以正常处理多字节值，这将失败。但是，一开始就不需要此修复程序。

Answer 7

我认为最有效的解决方案是使用 mb_substr 处理字符串。在循环的每次迭代中，mb_substr 将被调用两次（以查找下一个字符和剩余的字符串）。它只会将剩余的字符串传递给下一次迭代。这样，每次迭代的主要开销将是查找下一个字符（完成两次），这只需一到五次左右的操作，具体取决于字符的字节长度。

如果此描述不清楚，请告诉我，我将提供一个有效的 PHP 函数。