PHP多维数组排序完全指南

PHP 多维数组排序完全指南:从 array_multisort 到 usort 的 9 种实战姿势

摘要:多维数组排序是 PHP 业务开发里出镜率极高的操作------商品按价格排序、学生按成绩排名、订单按时间和状态组合排序......但很多同学写出来的排序代码要么在边界情况下错乱,要么多字段一组合就失效。本文系统梳理 PHP 中 6 个排序函数、多字段排序的 3 种写法、保持键名与重建索引的区别、PHP 8 排序稳定性带来的写法升级,以及 8 个真实项目中踩过的坑,并给出两个可直接复制的通用工具函数。

关键词:PHP 多维数组排序、array_multisort、usort、array_column、太空船操作符


目录

  • [一、先认清 PHP 的 6 个排序函数](#一、先认清 PHP 的 6 个排序函数)
  • [二、场景 1:按单个字段排序(最常用)](#二、场景 1:按单个字段排序(最常用))
  • [三、场景 2:多字段组合排序](#三、场景 2:多字段组合排序)
  • [四、场景 3:保持键名 vs 重建索引](#四、场景 3:保持键名 vs 重建索引)
  • [五、场景 4:自定义规则排序](#五、场景 4:自定义规则排序)
  • [六、PHP 8 排序稳定性:写法的一次升级](#六、PHP 8 排序稳定性:写法的一次升级)
  • 七、性能对比:到底该用哪个
  • [八、8 个高频坑(血泪总结)](#八、8 个高频坑(血泪总结))
  • 九、两个可直接复制的通用工具函数
  • 十、速查表与总结

一、先认清 PHP 的 6 个排序函数

排序之前先选对工具。PHP 提供的排序函数可以按「排什么」和「键怎么处理」两个维度来划分:

函数 排序依据 索引/键名处理 典型用途
sort() 值升序 重建数字索引,丢弃原键 一维数组简单排序
rsort() 值降序 重建数字索引 一维数组倒序
asort() 值升序 保留键值关联 关联数组按值排
arsort() 值降序 保留键值关联 关联数组按值倒序
ksort() / krsort() 键名 保留键值关联 按键名排序
usort() 自定义回调 重建数字索引 多维数组自定义排序(主力)
uasort() 自定义回调 保留键值关联 多维数组排序且要保留主键
uksort() 自定义回调(比键名) 保留键值关联 按主键名自定义排序
array_multisort() 多列 / 多数组 保留字符串键,重建数字键 多字段排序(性能最优)
natsort() / natcasesort() 自然序 保留键值关联 img2 < img10

💡 记忆口诀:带 u 的是 user 自定义,带 a 的是 association 保留关联,带 k 的是 key 按键排。

排序标志(flags)

array_multisort() 和 sort() 系列都支持排序类型标志,多维数组排序时强烈建议显式指定,否则会踩类型转换的坑:

标志 含义
SORT_REGULAR 默认,按 PHP 常规规则比较("10" 和 9 混排时行为不确定)
SORT_NUMERIC 按数值比较
SORT_STRING 按字符串比较
SORT_NATURAL 自然排序,img2 排在 img10 前面
SORT_FLAG_CASE 与 SORT_STRING 或 SORT_NATURAL 按位或,忽略大小写
SORT_LOCALE_STRING 按当前 locale 比较字符串

二、场景 1:按单个字段排序(最常用)

2.1 准备示例数据

后文统一使用这份数据:

php 复制代码
$users = [
    ['id' => 1, 'name' => '张三', 'dept' => '技术部', 'age' => 28, 'salary' => 18000, 'score' => 88.5],
    ['id' => 2, 'name' => '李四', 'dept' => '市场部', 'age' => 32, 'salary' => 15000, 'score' => 92.0],
    ['id' => 3, 'name' => '王五', 'dept' => '技术部', 'age' => 25, 'salary' => 22000, 'score' => 92.0],
    ['id' => 4, 'name' => '赵六', 'dept' => '人事部', 'age' => 32, 'salary' => 15000, 'score' => 76.5],
    ['id' => 5, 'name' => '孙七', 'dept' => '市场部', 'age' => 41, 'salary' => 30000, 'score' => 81.0],
];

2.2 写法 A:array_column + array_multisort(推荐,性能最好)

先抽出要排序的「列」,再让 array_multisort() 同步重排原数组:

php 复制代码
$ages = array_column($users, 'age');
array_multisort($ages, SORT_ASC, SORT_NUMERIC, $users);

// 结果:王五(25) → 张三(28) → 李四(32) → 赵六(32) → 孙七(41)

要点拆解:

  • array_column($users, 'age') 抽出一列,长度必须与 $users 一致;
  • 第二个参数是排序方向 SORT_ASC / SORT_DESC;
  • 第三个参数是排序类型,数值字段务必写 SORT_NUMERIC;
  • 最后一个参数放原数组,它会被按引用修改;
  • 函数返回 bool,不要写 $users = array_multisort(...) ,那样 $users 会变成 true。

⚠️ 注意:不要把 array_column() 直接内联进参数(如 array_multisort(array_column($u,'age'), ...)),array_multisort() 的形参是引用传递,传入函数返回值在部分 PHP 版本会产生 Only variables should be passed by reference 提示。老老实实先赋给变量。

2.3 写法 B:usort + 太空船操作符(最灵活)

PHP 7 引入的太空船操作符 <=> 让比较回调简洁到一行:

php 复制代码
usort($users, fn($a, $b) => $a['age'] <=> $b['age']);        // 升序:$a 在前
usort($users, fn($a, $b) => $b['age'] <=> $a['age']);        // 降序:$b 写在前面

$a <=> $b 返回 -1 / 0 / 1,分别表示小于、等于、大于。降序就是把两个参数位置对调,或者写成 $b['age'] <=> $a['age']。

usort() 同样是按引用修改,返回 bool。它不关心字段类型,所以数字当字符串存的时候要自己转:

php 复制代码
usort($users, fn($a, $b) => (int)$a['age'] <=> (int)$b['age']);

2.4 写法 C:PHP 8 箭头函数之外,别忘了 array_column 支持对象

如果数组里装的是对象(stdClass 或实体类),array_column() 从 PHP 7.0 起可以直接取公有属性:

php 复制代码
$names = array_column($userObjects, 'name');   // 支持 public 属性
array_multisort($names, SORT_ASC, SORT_STRING, $userObjects);

私有属性取不到,这种情况改用 usort 调用 getter。


三、场景 2:多字段组合排序

需求:先按部门升序(技术部 → 市场部 → 人事部排不了字典序,先按字符串),部门相同再按薪资降序,薪资也相同再按年龄升序。

3.1 写法 A:array_multisort 多列(推荐)

把每一列连同它的排序方向、排序类型依次传入:

php 复制代码
$dept   = array_column($users, 'dept');
$salary = array_column($users, 'salary');
$age    = array_column($users, 'age');

array_multisort(
    $dept,   SORT_ASC,  SORT_STRING,    // 主排序:部门升序(字符串比较)
    $salary, SORT_DESC, SORT_NUMERIC,   // 次排序:薪资降序(数值比较)
    $age,    SORT_ASC,  SORT_NUMERIC,   // 第三排序:年龄升序
    $users                              // 最后放被排序的原数组
);

这是最直观也最快的多字段排序写法,每一列可以独立指定方向和类型,非常适合列表页的「多列排序」。

3.2 写法 B:usort + ?: 短路技巧(最灵活)

利用 ?: 在比较结果为 0(相等)时继续计算下一级的特性,可以把多字段排序写成一行:

php 复制代码
usort($users, function ($a, $b) {
    return ($a['dept'] <=> $b['dept'])          // 部门升序
        ?: ($b['salary'] <=> $a['salary'])      // 薪资降序(参数对调)
        ?: ($a['age'] <=> $b['age']);           // 年龄升序
});

原理解释:<=> 返回 0 表示当前字段相等,而 0 是 falsy,?: 就会继续求值后面的表达式;返回 -1 或 1 都是 truthy,直接返回不再比较后面的字段。这是 PHP 多字段 usort 的经典惯用法,务必掌握。

3.3 写法 C:PHP 8 稳定排序 + 多次排序

PHP 8.0 起所有排序函数都变成稳定排序(相等元素保持原有相对顺序)。因此可以「先排次要字段,再排主要字段」:

php 复制代码
// 从最次要的字段开始排
usort($users, fn($a, $b) => $a['age']    <=> $b['age']);     // 1. 先按年龄
usort($users, fn($a, $b) => $b['salary'] <=> $a['salary']);  // 2. 再按薪资降序
usort($users, fn($a, $b) => $a['dept']   <=> $b['dept']);    // 3. 最后按部门

⚠️ 这个写法只能在 PHP 8.0+ 使用 。PHP 7.x 的 sort 系列是不稳定排序,多次排序会打乱前一次的结果,必须一次性在回调里比完(用 3.2 的写法)。


四、场景 3:保持键名 vs 重建索引

这是最容易出 bug 的地方。如果你的数组主键是有业务含义的(比如数据库主键 id 做键),选错函数会直接丢键。

php 复制代码
$usersById = [
    101 => ['name' => '张三', 'age' => 28],
    102 => ['name' => '李四', 'age' => 32],
    205 => ['name' => '王五', 'age' => 25],
];

4.1 用 usort:键名会被丢弃

php 复制代码
usort($usersById, fn($a, $b) => $a['age'] <=> $b['age']);
// 结果键名变成 0, 1, 2 ------ 主键 101/102/205 全丢了!

4.2 用 uasort:保留键值关联

php 复制代码
uasort($usersById, fn($a, $b) => $a['age'] <=> $b['age']);
/*
[
    205 => ['name' => '王五', 'age' => 25],
    101 => ['name' => '张三', 'age' => 28],
    102 => ['name' => '李四', 'age' => 32],
]
*/

4.3 array_multisort:字符串键保留,数字键重建

php 复制代码
$ages = array_column($usersById, 'age');
array_multisort($ages, SORT_ASC, SORT_NUMERIC, $usersById);
// 数字键 101/102/205 会被重建为 0/1/2(字符串键则保留)

⚠️ 这里有个隐藏大坑:array_column() 返回的是重新索引 的数组(0,1,2...),它与 $usersById 的键(101,102,205)不再对齐。array_multisort 内部按位置同步重排,结果对原数组的数字键仍会重建。若要保住数字主键,首选 uasort。

4.4 排完想要连续索引?加一层 array_values()

php 复制代码
$sorted = array_values($sorted);   // 键名重置为 0,1,2...

很多接口返回 JSON 时,如果键名不连续,前端拿到的是对象 {"0":...} 而不是数组 [...]。所以「uasort 排序 + array_values 重建」是接口输出的黄金组合:

php 复制代码
uasort($list, fn($a, $b) => $a['sort'] <=> $b['sort']);
return json_encode(array_values($list), JSON_UNESCAPED_UNICODE);

五、场景 4:自定义规则排序

5.1 按自定义权重排序(状态、优先级)

需求:订单按「待付款 → 待发货 → 已完成 → 已取消」排,而不是按字典序。

php 复制代码
$weight = ['pending' => 1, 'shipped' => 2, 'done' => 3, 'canceled' => 4];

usort($orders, function ($a, $b) use ($weight) {
    return ($weight[$a['status']] ?? PHP_INT_MAX)
       <=> ($weight[$b['status']] ?? PHP_INT_MAX);
});

用 ?? PHP_INT_MAX 给未知状态兜底,避免 Undefined array key 警告。

5.2 按指定顺序的白名单排序

需求:按前端传来的 id 顺序 [5, 1, 3] 输出。

php 复制代码
$order = [5, 1, 3];
$pos   = array_flip($order);          // [5 => 0, 1 => 1, 3 => 2]

usort($list, fn($a, $b) => ($pos[$a['id']] ?? PHP_INT_MAX) <=> ($pos[$b['id']] ?? PHP_INT_MAX));

5.3 中文按拼音排序

SORT_STRING 对中文是无效的(按字节/码点比)。正确做法是用 intl 扩展的 Collator:

php 复制代码
$collator = new Collator('zh_CN');
usort($users, fn($a, $b) => $collator->compare($a['name'], $b['name']));

没有 intl 扩展时,可用 SORT_LOCALE_STRING + setlocale() 兜底,但效果依赖系统 locale,不推荐用于生产环境。

5.4 自然排序(版本号、文件名)

php 复制代码
$files = [['name' => 'img10.png'], ['name' => 'img2.png'], ['name' => 'img1.png']];

$names = array_column($files, 'name');
array_multisort($names, SORT_ASC, SORT_NATURAL, $files);
// 结果:img1 → img2 → img10(普通字符串排序会得到 img1 → img10 → img2)

usort 版本用 strnatcmp():

php 复制代码
usort($files, fn($a, $b) => strnatcmp($a['name'], $b['name']));

5.5 浮点数排序

浮点数不要用 == 或直接减,用误差范围(epsilon)判断相等:

php 复制代码
$EPS = 1e-9;
usort($list, function ($a, $b) use ($EPS) {
    $diff = $a['score'] - $b['score'];
    return abs($diff) < $EPS ? 0 : ($diff > 0 ? 1 : -1);
});

5.6 按日期字符串排序

YYYY-mm-dd HH:mm:ss 格式的字符串字典序等于时间序,可直接比较;但不同格式不要混:

php 复制代码
usort($list, fn($a, $b) => strtotime($a['created_at']) <=> strtotime($b['created_at']));

六、PHP 8 排序稳定性:写法的一次升级

稳定性指的是:当两个元素比较结果相等时,排序后是否保持它们原有的相对顺序。

PHP 版本 稳定性 影响
PHP < 8.0 不稳定 相等元素的相对顺序不确定,多字段排序必须一次比完
PHP >= 8.0 稳定 相等元素保持原序,可以「多次单字段排序」叠加

实际影响举例:假设原数组按 id 升序,现在要按部门排序,希望同部门内仍按 id 排。

  • PHP 7:必须用 3.2 的组合回调,把两个字段写在一起;
  • PHP 8 :直接 usort($list, fn($a,$b) => $a['dept'] <=> $b['dept']) 即可,同部门内自动保持 id 顺序。

💡 升级 PHP 8 后,很多「为了稳定而写的复杂回调」可以简化。但如果你写的是要兼容 7.x 的 Composer 包,仍然要用一次性比完的写法。


七、性能对比:到底该用哪个

array_multisort() 的排序循环在 C 层面完成,而 usort() 每比较一次都要调用一次 PHP 回调函数,开销明显更大。

粗略结论(10 万行、单字段数值排序的实测量级):

方式 相对耗时 说明
array_multisort + array_column 1x(最快) 纯 C 实现,还有 array_column 的一次遍历开销
usort + <=> 约 2~5x 回调开销随数据量线性放大
usort + 复杂回调(含函数调用) 约 5~15x 回调里调 strtotime、Collator::compare 等会雪上加霜

优化建议:

  1. 排序规则能用 array_multisort 表达就优先用它;
  2. 回调里有「对每个元素重复计算」的逻辑(如 strtotime、strtolower),先做一次预处理,把计算好的值写进临时字段(装饰-排序-去装饰,即 Schwartzian Transform):
php 复制代码
// 慢:每次比较都调用两次 strtotime
usort($list, fn($a, $b) => strtotime($a['date']) <=> strtotime($b['date']));

// 快:预计算一次
foreach ($list as $k => $v) {
    $list[$k]['_ts'] = strtotime($v['date']);
}
usort($list, fn($a, $b) => $a['_ts'] <=> $b['_ts']);
foreach ($list as $k => $v) {
    unset($list[$k]['_ts']);   // 去掉临时字段
}
  1. 数据量上百万时,考虑交给数据库 ORDER BY 或搜索引擎,别在 PHP 里硬排。

八、8 个高频坑(血泪总结)

坑 1:array_multisort 的返回值不是数组

php 复制代码
$users = array_multisort($ages, SORT_ASC, $users);   // ❌ $users 变成 true
array_multisort($ages, SORT_ASC, $users);            // ✅ 按引用修改

坑 2:array_column 跳过缺失字段,导致长度不一致

php 复制代码
$list = [
    ['age' => 30],
    ['name' => '李四'],       // 没有 age
    ['age' => 25],
];
$ages = array_column($list, 'age');   // 只有 2 个元素!
array_multisort($ages, SORT_ASC, $list);
// ⚠️ Warning: Array sizes are inconsistent,排序结果错乱

解决 :先补齐默认值,或改用 usort:

php 复制代码
$ages = array_map(fn($it) => $it['age'] ?? 0, $list);   // ✅ 长度恒定

坑 3:SORT_REGULAR 让数字字符串排序翻车

SORT_REGULAR 是「看情况猜」的默认规则,遇到大小写、混合类型就会翻车:

php 复制代码
$names = ['apple', 'Banana', 'cherry'];
sort($names, SORT_REGULAR);                    // ['Banana', 'apple', 'cherry'] ------ 大写 ASCII 码更小
sort($names, SORT_STRING | SORT_FLAG_CASE);    // ✅ ['apple', 'Banana', 'cherry'](忽略大小写)

$mixed = ['10', 9, '100'];                     // JSON 与数据库混进来的 int / string
sort($mixed, SORT_REGULAR);                    // 结果依赖具体类型组合,不可预期
sort($mixed, SORT_NUMERIC);                    // ✅ [9, '10', '100']

多维数组里同理:数值字段显式指定 SORT_NUMERIC,字符串字段显式指定 SORT_STRING(需要时再 | SORT_FLAG_CASE)。

坑 4:usort 后主键丢失

见第四章。要保留主键用 uasort,接口输出补 array_values()。

坑 5:在回调里做「非对称」比较,破坏排序契约

比较函数必须满足:若 $a < $b 返回负,$a > $b 返回正,$a == $b 返回 0,且必须自反 (cmp($a,$b) 与 cmp($b,$a) 符号相反)。写成 return $a['v'] ? 1 : -1; 这种只返回 1/-1 的回调,会导致排序结果不可预期。用 <=> 就不会犯这个错。

坑 6:null 值参与比较

null 与数字、字符串比较的结果在不同 PHP 版本和类型组合下差异很大,很容易出现「空值一会儿在最前一会在最后」。若字段可能为 null,用空合并运算符兜底:

php 复制代码
usort($list, fn($a, $b) => ($a['score'] ?? 0) <=> ($b['score'] ?? 0));

坑 7:PHP 7 用「多次排序」实现多字段

PHP 7 排序不稳定,多次 usort 会互相覆盖。检查你的 PHP 版本,或统一用 ?: 一次性比完。

坑 8:排序后 json_encode 变成对象

键名不连续(如 uasort 保留的 101,205)会让 json_encode 输出 {"101":...}。接口场景记得 array_values()。


九、两个可直接复制的通用工具函数

9.1 基于 array_multisort 的高性能版(推荐,处理了字段缺失)

php 复制代码
/**
 * 多字段排序(array_multisort 版,性能最优)
 *
 * 用法:
 *   $list = sortByRules($list, [
 *       ['field' => 'dept',   'order' => SORT_ASC,  'flags' => SORT_STRING],
 *       ['field' => 'salary', 'order' => SORT_DESC, 'flags' => SORT_NUMERIC],
 *   ]);
 *
 * @param array $list  待排序的二维数组(会被重建数字索引)
 * @param array $rules 排序规则,按优先级从高到低
 * @return array 排序后的新数组
 */
function sortByRules(array $list, array $rules): array
{
    if (count($list) < 2) {
        return array_values($list);
    }

    $args = [];
    $size = count($list);

    foreach ($rules as $rule) {
        $field = $rule['field'];

        // 用 array_map 而非 array_column,避免字段缺失导致的长度不一致
        $column = array_map(static fn($item) => $item[$field] ?? null, $list);

        if (count($column) !== $size) {   // 理论上不会触发,保险起见
            throw new InvalidArgumentException("字段 {$field} 提取异常");
        }

        $args[] = $column;
        $args[] = $rule['order'] ?? SORT_ASC;
        $args[] = $rule['flags'] ?? SORT_REGULAR;
    }

    $args[] = &$list;                     // 必须按引用传入
    array_multisort(...$args);

    return $list;
}

9.2 基于 usort 的灵活版(支持保留键名、支持自定义比较器)

php 复制代码
/**
 * 多字段排序(usort 版,支持保留键名与自定义比较器)
 *
 * 用法:
 *   $list = usortByRules($list, [
 *       ['dept',   'asc',  'string'],
 *       ['salary', 'desc', 'numeric'],
 *   ], keepKeys: true);
 *
 * @param array $list      待排序数组
 * @param array $rules     [字段名, 方向 asc|desc, 类型 numeric|string|natural|regular]
 * @param bool  $keepKeys  是否保留键名(true 用 uasort)
 * @return array
 */
function usortByRules(array $list, array $rules, bool $keepKeys = false): array
{
    $comparator = static function ($a, $b) use ($rules) {
        foreach ($rules as $rule) {
            [$field, $dir, $type] = array_pad((array) $rule, 3, null);
            $dir  = strtolower((string) $dir) ?: 'asc';
            $type = strtolower((string) $type) ?: 'regular';

            $av = $a[$field] ?? null;
            $bv = $b[$field] ?? null;

            switch ($type) {
                case 'numeric':
                    $cmp = (float) $av <=> (float) $bv;
                    break;
                case 'string':
                    $cmp = strcmp((string) $av, (string) $bv);
                    break;
                case 'natural':
                    $cmp = strnatcmp((string) $av, (string) $bv);
                    break;
                default:
                    $cmp = $av <=> $bv;
            }

            if ($cmp !== 0) {
                return $dir === 'desc' ? -$cmp : $cmp;
            }
        }
        return 0;
    };

    $keepKeys ? uasort($list, $comparator) : usort($list, $comparator);

    return $list;
}

9.3 调用示例

php 复制代码
// 部门升序 → 薪资降序 → 年龄升序
$sorted = sortByRules($users, [
    ['field' => 'dept',   'order' => SORT_ASC,  'flags' => SORT_STRING],
    ['field' => 'salary', 'order' => SORT_DESC, 'flags' => SORT_NUMERIC],
    ['field' => 'age',    'order' => SORT_ASC,  'flags' => SORT_NUMERIC],
]);

// 保留主键的版本
$sorted = usortByRules($usersById, [['age', 'asc', 'numeric']], keepKeys: true);

十、速查表与总结

一图流选择指南

text 复制代码
要排多维数组?
├─ 排序规则是「若干字段 + 方向」?
│   ├─ 是 → array_column + array_multisort(最快,显式指定 flags)
│   └─ 规则含自定义逻辑(状态权重、拼音、白名单顺序)
│       └─ usort / uasort + <=> + ?: 短路
├─ 需要保留原数组的键名(如数据库主键)?
│   ├─ 是 → uasort(数字键别用 array_multisort)
│   └─ 否 → usort / array_multisort
└─ 输出给前端 JSON?
    └─ 排完补一层 array_values(),保证输出数组而非对象

核心要点回顾

  1. array_multisort + array_column 是多维数组排序的默认选择,性能最好,多字段写法直观;
  2. usort + <=> + ?: 是复杂规则的标准解法,三者组合能覆盖 90% 的场景;
  3. uasort 保留键名,usort 重建索引 ,接口输出记得 array_values();
  4. 数值字段务必显式 SORT_NUMERIC ,否则 "10" 会排在 "9" 前面;
  5. PHP 8 起排序稳定,多字段可拆成多次单字段排序;PHP 7 必须一次比完;
  6. array_multisort 按引用修改 ,返回值是 bool,别赋值给原变量。

如果这篇文章对你有帮助,欢迎点赞收藏 🌹。你在项目中还遇到过哪些排序的奇葩场景?评论区聊聊,我会持续补充到本文的「坑」章节里。


相关推荐

  • PHP 数组函数全家桶:array_column / array_reduce / array_walk 实战
  • PHP 8 新特性速览:太空船操作符、箭头函数、稳定排序
  • 用 Schwartzian Transform 优化 PHP 大数据量排序
相关推荐
starzy199010 小时前
深入理解Scala隐式类:扩展方法机制
开发语言·人工智能·scala
M--Y10 小时前
LangGraph 工作流模式
开发语言·javascript·python·langchain·大模型·llm·langgraph
吴可可12312 小时前
WScript Shell操作注册表详解
开发语言
纪念 22912 小时前
C++ 算法基础 (差分)
开发语言·c++·算法
码农小河6617 小时前
基于PHP的电商后台蜜罐系统
开发语言·php
starzy199017 小时前
深入理解Scala柯里化函数:函数链式变换
开发语言·scala
ShineWinsu17 小时前
对于Qt:QTreeWidget常见属性以及QTreeWidgetItem类的解析
开发语言·c++·qt·gui·客户端·多叉树·qtreewidget
落羽的落羽18 小时前
【C++】C++17的主要特性
linux·服务器·开发语言·c++·算法·机器学习
总要学点什么18 小时前
第108篇:三维特效-图片轨迹线效果——把贴图滚成一串箭头,想用它的本色反而整条消失
开发语言·javascript·ecmascript·gis·webgl·材质·cesium