当前位置：首页 > 文章列表 > 文章 > php教程 > PHP字符串转数组技巧：array_chunk用法详解

PHP字符串转数组技巧：array_chunk用法详解

2026-01-15 10:27:51 0浏览收藏

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个文章开发实战，手把手教大家学习《PHP字符串转数组技巧：array\_chunk使用详解》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

要将字符串转为固定大小数组，需先用str_split、explode或preg_split将字符串转为数组，再用array_chunk按指定大小分块，处理多字节字符时应使用mb_str_split或preg_split('/./u')以避免乱码。

如何用PHP将字符串转为固定大小的数组？array_chunk详解

将一个字符串转换为固定大小的数组，这听起来像是一个字符串操作，但实际上，PHP的array_chunk函数是针对数组进行操作的。所以，核心思路是：你需要先将字符串拆分成一个数组（例如，按字符拆分，或者按特定分隔符拆分），然后才能利用array_chunk将这个中间数组分割成若干个固定大小的子数组。这是一种非常实用的数据处理模式，尤其在处理长文本或批处理数据时。

解决方案

要实现这个目标，通常需要两步操作：

将字符串转换为基础数组：根据你的需求，这可以是字符数组，或者由特定分隔符（如空格、逗号）分割而成的单词/片段数组。
- 按字符分割：使用 str_split() 函数。
- 按分隔符分割：使用 explode() 函数。
- 按正则表达式分割：使用 preg_split() 函数，这在需要更复杂分割逻辑时非常有用。
使用 array_chunk() 分割数组：一旦有了基础数组，就可以调用 array_chunk() 函数，将它分割成指定大小的子数组。

以下是具体的代码示例：

<?php

// 示例1：将字符串按字符分割，再按每3个字符一组进行分块
$string1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
$charArray = str_split($string1); // 转换为字符数组
$chunkedChars = array_chunk($charArray, 3);

echo "--- 字符分块示例 ---" . PHP_EOL;
print_r($chunkedChars);
/*
输出大致如下：
Array
(
    [0] => Array
        (
            [0] => A
            [1] => B
            [2] => C
        )
    [1] => Array
        (
            [0] => D
            [1] => E
            [2] => F
        )
    ...
)
*/

echo PHP_EOL;

// 示例2：将句子按单词分割，再按每2个单词一组进行分块
$string2 = "This is a sample sentence for demonstration purposes";
$wordArray = explode(" ", $string2); // 转换为单词数组
$chunkedWords = array_chunk($wordArray, 2);

echo "--- 单词分块示例 ---" . PHP_EOL;
print_r($chunkedWords);
/*
输出大致如下：
Array
(
    [0] => Array
        (
            [0] => This
            [1] => is
        )
    [1] => Array
        (
            [0] => a
            [1] => sample
        )
    ...
)
*/

echo PHP_EOL;

// 示例3：使用 preg_split 进行更灵活的分割，例如按非字母数字字符分割
$string3 = "Hello-World!How_are.you?";
$partsArray = preg_split('/[^a-zA-Z0-9]+/', $string3, -1, PREG_SPLIT_NO_EMPTY);
$chunkedParts = array_chunk($partsArray, 2);

echo "--- 正则分割分块示例 ---" . PHP_EOL;
print_r($chunkedParts);
/*
输出大致如下：
Array
(
    [0] => Array
        (
            [0] => Hello
            [1] => World
        )
    [1] => Array
        (
            [0] => How
            [1] => are
        )
    [2] => Array
        (
            [0] => you
        )
)
*/
?>

PHP中`array_chunk`函数的基本用法和参数解析？

array_chunk函数是PHP数组操作中一个非常实用的工具，它能将一个数组分割成多个小数组（或称“块”），每个小数组包含指定数量的元素。它的签名如下：

array_chunk(array $array, int $size, bool $preserve_keys = false): array

让我们逐一解析这些参数：

$array (必选)：这是你想要进行分块操作的源数组。它可以是任何类型的数组，无论是索引数组还是关联数组。
$size (必选)：一个整数，表示每个子数组（块）应该包含的元素数量。如果源数组的元素数量不能被 $size 整除，那么最后一个子数组将包含剩余的元素，其数量会小于 $size。
$preserve_keys (可选)：一个布尔值，默认为 false。
- 如果设置为 false，那么每个生成的子数组都将重新索引，从 0 开始。这是最常见的行为。
- 如果设置为 true，那么子数组将保留原始数组中的键名。这在处理关联数组或希望保持原始索引关系时非常有用。

工作原理与返回值：

array_chunk函数会返回一个二维数组。这个二维数组的每个元素都是一个子数组，也就是我们所说的“块”。

示例：$preserve_keys 的影响

<?php
$data = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5];

echo "--- preserve_keys = false (默认) ---" . PHP_EOL;
$chunks_default = array_chunk($data, 2);
print_r($chunks_default);
/*
输出：
Array
(
    [0] => Array
        (
            [0] => 1
            [1] => 2
        )
    [1] => Array
        (
            [0] => 3
            [1] => 4
        )
    [2] => Array
        (
            [0] => 5
        )
)
*/

echo PHP_EOL;

echo "--- preserve_keys = true ---" . PHP_EOL;
$chunks_preserved = array_chunk($data, 2, true);
print_r($chunks_preserved);
/*
输出：
Array
(
    [0] => Array
        (
            [a] => 1
            [b] => 2
        )
    [1] => Array
        (
            [c] => 3
            [d] => 4
        )
    [2] => Array
        (
            [e] => 5
        )
)
*/
?>

从上面的例子可以看出，当 preserve_keys 为 true 时，原始的键名（a, b, c 等）被保留了下来，而 false 则会重新生成从 0 开始的数字索引。根据实际需求选择合适的参数，能让你的代码更精确地处理数据。

处理多字节字符（如中文）时`str_split`的局限性及替代方案？

在使用 str_split() 将字符串分割成字符数组时，一个非常常见的陷阱就是它对多字节字符（例如中文、日文、韩文、表情符号等UTF-8编码的字符）的支持不足。str_split() 默认是按字节进行分割的，而不是按字符。这意味着，一个UTF-8编码的中文字符可能由2到4个字节组成，如果 str_split() 遇到它，就会将其拆分成多个单独的字节，导致乱码或不完整的字符。

str_split的局限性示例：

<?php
$chineseString = "你好世界"; // 包含中文字符的字符串
$chars = str_split($chineseString);

echo "--- str_split 处理中文字符的错误示例 ---" . PHP_EOL;
print_r($chars);
/*
输出：
Array
(
    [0] => �
    [1] => �
    [2] => �
    [3] => �
    [4] => �
    [5] => �
    [6] => �
    [7] => �
)
你会看到乱码，因为一个中文字符被拆成了多个字节。
*/
?>

替代方案：mb_str_split() 或 preg_split()

为了正确处理多字节字符，我们应该使用支持多字节字符串的函数。

mb_str_split() (PHP 7.4+ 推荐)：这是PHP 7.4及更高版本中引入的函数，专门用于解决 str_split() 的多字节问题。它与 str_split() 类似，但可以指定编码。

<?php
$chineseString = "你好世界";
// 假设你的字符串是UTF-8编码
if (function_exists('mb_str_split')) {
    $mbChars = mb_str_split($chineseString, 1, 'UTF-8');
    echo "--- mb_str_split 正确处理中文字符 ---" . PHP_EOL;
    print_r($mbChars);
    /*
    输出：
    Array
    (
        [0] => 你
        [1] => 好
        [2] => 世
        [3] => 界
    )
    */

    // 然后再用 array_chunk 进行分块
    $chunkedMbChars = array_chunk($mbChars, 2);
    echo "--- mb_str_split 后 array_chunk 分块 ---" . PHP_EOL;
    print_r($chunkedMbChars);
    /*
    输出：
    Array
    (
        [0] => Array
            (
                [0] => 你
                [1] => 好
            )
        [1] => Array
            (
                [0] => 世
                [1] => 界
            )
    )
    */
} else {
    echo "PHP版本低于7.4，mb_str_split() 不可用。" . PHP_EOL;
}
?>

preg_split() 结合 u 修正符：如果你的PHP版本低于7.4，或者你需要更复杂的分割逻辑（例如，不仅是单个字符，而是按特定模式分割），preg_split() 是一个非常强大的选择。结合 u (UTF-8) 修正符，它可以正确处理多字节字符。

<?php
$chineseString = "你好世界，这是一个测试。";
// 使用空正则表达式 '/./u' 来匹配每一个UTF-8字符
$pregChars = preg_split('//u', $chineseString, -1, PREG_SPLIT_NO_EMPTY);

echo "--- preg_split 正确处理中文字符 ---" . PHP_EOL;
print_r($pregChars);
/*
输出：
Array
(
    [0] => 你
    [1] => 好
    [2] => 世
    [3] => 界
    [4] => ，
    [5] => 这
    [6] => 是
    [7] => 一
    [8] => 个
    [9] => 测
    [10] => 试
    [11] => 。
)
*/

// 然后再用 array_chunk 进行分块
$chunkedPregChars = array_chunk($pregChars, 5);
echo "--- preg_split 后 array_chunk 分块 ---" . PHP_EOL;
print_r($chunkedPregChars);
/*
输出：
Array
(
    [0] => Array
        (
            [0] => 你
            [1] => 好
            [2] => 世
            [3] => 界
            [4] => ，
        )
    [1] => Array
        (
            [0] => 这
            [1] => 是
            [2] => 一
            [3] => 个
            [4] => 测
        )
    [2] => Array
        (
            [0] => 试
            [1] => 。
        )
)
*/
?>

PREG_SPLIT_NO_EMPTY 标志是为了避免在字符串开头或结尾出现空匹配而产生空字符串元素。

在处理包含多字节字符的字符串时，务必注意选择正确的函数，否则会导致难以调试的乱码问题。我个人倾向于在PHP 7.4+的环境下优先使用 mb_str_split()，因为它语义更清晰，专门为此设计。

`array_chunk`在实际项目开发中常见的错误与陷阱？

array_chunk 虽然功能直接，但在实际开发中，如果不注意一些细节，也可能踩到一些“坑”。作为一名开发者，我总结了一些常见的错误和需要注意的地方：

忘记 array_chunk 只能处理数组：这是最基础也最容易被忽略的一点。标题就暗示了这一点——很多人会直觉地想把 字符串 直接传给 array_chunk。但它只接受 array 类型参数。如果你传入一个字符串，PHP会尝试将其转换为数组（通常是空数组或者一个包含单字符的数组，行为不确定且不符合预期），然后报错或返回非预期的结果。陷阱：直接 array_chunk("some_string", 3) 会导致 TypeError 或 Warning。解决：始终先将字符串通过 str_split()、explode() 或 preg_split() 等函数转换为数组。
$size 参数的非预期值：
- $size 为 0 或负数：如果你将 $size 设置为 0 或负数，array_chunk 会抛出 ValueError (PHP 8+) 或 Warning (PHP 7)，并返回一个空数组。这通常是逻辑错误导致的，比如计算 $size 的变量没有正确初始化或校验。
- $size 大于数组元素总数：这种情况下，array_chunk 会返回一个包含单个子数组的二维数组，这个子数组就是原始数组的全部内容。这本身不是错误，但可能不是你期望的结果，比如你本意是想分多页，结果只分了一页。解决：对 $size 参数进行有效性检查，确保它是一个正整数，并且符合你的业务逻辑。
$preserve_keys 参数的误解： $preserve_keys 默认为 false，这意味着子数组的键会重新从 0 开始索引。如果你处理的是关联数组，并且需要保留原始键名，那么务必将其设置为 true。否则，你可能会发现子数组中的数据正确，但访问方式（通过键名）却变了。陷阱：在处理像 ['user_id' => 1, 'username' => 'test'] 这样的数据时，如果忘记设置 true，子数组会变成 [0 => 1, 1 => 'test']，丢失了原始语义。解决：明确理解 preserve_keys 的作用，并根据是否需要保留原始键名来决定其值。
处理空数组的场景：如果 array_chunk 的第一个参数是一个空数组 []，它会返回一个空数组 []。这通常是符合预期的，但在某些逻辑中，如果期望至少有一个空子数组，就可能需要额外的处理。解决：在处理空数组时，确认返回空数组是否符合你的业务逻辑。
内存消耗问题（针对超大数组）：当处理包含数百万甚至上千万元素的超大数组时，一次性将整个数组加载到内存中，再进行 array_chunk 操作，可能会导致内存耗尽（Allowed memory size of X bytes exhausted）。这是因为 array_chunk 会创建一个新的二维数组来存储结果，这会占用比原始数组更多的内存。陷阱：在处理数据库查询结果、文件读取等生成的大量数据时，直接对所有数据进行 array_chunk。解决：
- 分批处理：如果你的目的是为了分页显示或批处理数据，更好的做法是在数据源层面就进行分批获取（例如，数据库的 LIMIT 和 OFFSET）。
- 迭代器/生成器：对于需要遍历大文件或数据流的场景，PHP的迭代器（Iterator）或生成器（Generator）是更好的选择。它们允许你按需加载和处理数据，而不是一次性加载全部。例如，你可以编写一个生成器函数，每次 yield 一个数据块，而不是返回整个数组。
- array_slice 结合循环：手动使用 array_slice 在循环中从原始数组中取出小块，虽然不如 array_chunk 方便，但在某些内存敏感的场景下，可以更好地控制内存使用。