数据排序

对值进行排序；另请参见 bisect.

ascending(a, b)

示例 · 源代码 · 如果 a 小于 b，则返回 -1；如果 a 大于 b，则返回 1；如果 a 和 b 相等，则返回 0；否则返回 NaN。

[39, 21, 1, 104, 22].sort(d3.ascending) // [1, 21, 22, 39, 104]

这是自然排序的比较器函数，可与 array.sort 一起使用，以按升序排列元素。

descending(a, b)

示例 · 源代码 · 如果 a 大于 b，则返回 -1；如果 a 小于 b，则返回 1；如果 a 和 b 相等，则返回 0；否则返回 NaN。

[39, 21, 1, 104, 22].sort(d3.descending) // [104, 39, 22, 21, 1]

这是自然排序的比较器函数，可与 array.sort 一起使用，以按降序排列元素。

permute(source, keys)

示例 · 源代码 · 使用指定的 keys 可迭代对象返回指定 source 数组或对象的排列。返回的数组包含 source 对象中每个键在 keys 中的对应属性，按顺序排列。

d3.permute(["a", "b", "c"], [1, 2, 0]) // returns ["b", "c", "a"]

给定的 source 不必是数组；例如，给定一个对象

const object = {yield: 27, variety: "Manchuria", year: 1931, site: "University Farm"};

可以像这样提取三个字段

d3.permute(object, ["site", "variety", "yield"]) // ["University Farm", "Manchuria", 27]

quickselect(array, k, lo, hi, compare)

示例 · 源代码 · 对 array 中 lo 和 hi（含）之间的元素进行就地重新排列，使得 array[k] 是（k - lo + 1）个最小的值，而 array.slice(lo, k) 是 k 个最小的元素，根据给定的 compare 函数，并返回给定的 array。如果未指定 lo，则默认为零；如果未指定 hi，则默认为 array.length - 1；如果未指定 compare，则默认为 ascending.

例如，给定一个数字数组

const numbers = [65, 28, 59, 33, 21, 56, 22, 95, 50, 12, 90, 53, 28, 77, 39];

要选择最小的 8 个元素

d3.quickselect(numbers, 8)

重新排列后的 numbers 为

[39, 28, 28, 33, 21, 12, 22, 50, 53, 56, 59, 65, 90, 77, 95]
//                               ^^ numbers[k]

其中 numbers[8] 为 53：大于前面的 k 个元素，小于后面的元素。由 Volodymyr Agafonkin 的 quickselect 实现。

reverse(iterable)

源代码 · 返回一个数组，该数组包含给定 iterable 中的值，按反向顺序排列。

d3.reverse(new Set([0, 2, 3, 1])) // [1, 3, 2, 0]

等同于 array.reverse，但它不会改变给定的输入，并且可以处理任何可迭代对象。

shuffle(array, start, stop)

示例 · 源代码 · 使用 Fisher–Yates 洗牌算法 对指定的 array 进行就地随机排序，并返回该 array。

d3.shuffle([..."abcdefg"]) // ["e", "c", "a", "d", "b", "g", "f"], perhaps

如果指定了 start，则它是 array 中要进行随机排序的起始索引（含）；如果未指定 start，则默认为零。如果指定了 stop，则它是 array 中要进行随机排序的结束索引（不含）；如果未指定 stop，则默认为 array.length。例如，要对 array 的前十个元素进行随机排序：shuffle(array, 0, 10)。

shuffler(random)

源代码 · 给定指定的随机源，返回一个 shuffle 函数。

d3.shuffler(d3.randomLcg(42))([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) // [5, 3, 7, 6, 8, 9, 1, 4, 0, 2]

通常与 d3.randomLcg 一起使用，用于确定性随机排序。

sort(iterable, comparator)

源代码 · 返回一个数组，该数组包含给定 iterable 中的值，按给定 comparator 或 accessor 函数定义的排序顺序排列。如果未指定 comparator，则默认为 d3.ascending.

d3.sort(new Set([0, 2, 3, 1])) // [0, 1, 2, 3]

如果指定了 accessor（一个不接受两个参数的函数），

d3.sort(data, (d) => d.value)

它等同于使用 自然顺序 的 comparator

d3.sort(data, (a, b) => d3.ascending(a.value, b.value))

accessor 每个元素只调用一次，因此即使 accessor 非确定性，返回的排序顺序也是一致的。可以指定多个 accessor 来打破平局。

d3.sort(points, ({x}) => x, ({y}) => y)

上面等同于

d3.sort(data, (a, b) => d3.ascending(a.x, b.x) || d3.ascending(a.y, b.y))

与 array.sort 不同，d3.sort 不会改变给定的输入，比较器默认为自然顺序而不是词典顺序，并且输入可以是任何可迭代对象。