数据汇总

计算汇总统计数据。

count(iterable, accessor)

d3.count(penguins, (d) => d.body_mass_g) // 342

示例 · 源代码 · 返回指定iterable中有效数字值的个数（即，非空、非NaN或非undefined）；接受访问器。

min(iterable, accessor)

示例 · 源代码 · 使用自然顺序返回给定iterable中的最小值。

d3.min([3, 2, 1, 1, 6, 2, 4]) // 1

与Math.min不同，d3.min不会将输入强制转换为数字；例如，字符串["20", "3"]的最小值为"20"，而数字[20, 3]的最小值为3。

d3.min(["bob", "alice", "carol"]) // "alice"

d3.min([new Date("2018-01-01"), new Date("2011-03-09")]) // 2011-03-09

与 Math.min 不同，此方法会忽略 undefined、null 和 NaN 值，这对忽略缺失数据很有用。

d3.min([3, 2, 1, NaN, 4]) // 1

可以指定一个可选的访问器函数，这类似于在计算最小值之前调用Array.from。访问器函数会重复地传递给定可迭代对象中的一个元素（通常是d）和零基索引（i）。

d3.min(alphabet, (d) => d.frequency) // 0.00074

由于会忽略 undefined 值，因此可以使用访问器函数来忽略值。例如，要获取非 Z 的最不常见字母的频率

d3.min(alphabet, (d) => d.letter === "Z" ? NaN : d.frequency) // 0.00095

如果可迭代对象不包含任何可比较的值，则返回 undefined。

d3.min([]) // undefined

d3.min(alphabet, (d) => d.doesnotexist) // undefined

另请参阅 extent 和 least。

minIndex(iterable, accessor)

源代码 · 与min类似，但返回最小值的索引，而不是值本身。

d3.minIndex([3, 2, 1, 1, 6, 2, 4]) // 2

此方法可以根据给定的访问器找到最小的元素，类似于least

d3.minIndex(alphabet, (d) => d.frequency) // 25

alphabet[d3.minIndex(alphabet, (d) => d.frequency)] // {letter: "Z", frequency: 0.00074}

另请参阅 leastIndex。

max(iterable, accessor)

示例 · 源代码 · 使用自然顺序返回给定iterable中的最大值。

d3.max([3, 2, 1, 1, 6, 2, 4]) // 6

与Math.max不同，d3.max不会将输入强制转换为数字；例如，字符串["20", "3"]的最大值为"3"，而数字[20, 3]的最大值为20。

d3.max(["bob", "alice", "carol"]) // "carol"

d3.max([new Date("2018-01-01"), new Date("2011-03-09")]) // 2018-01-01

与 Math.max 不同，此方法会忽略 undefined、null 和 NaN 值，这对忽略缺失数据很有用。

d3.max([3, 2, 1, NaN, 4]) // 4

可以指定一个可选的访问器函数，这类似于在计算最大值之前调用Array.from。访问器函数会重复地传递给定可迭代对象中的一个元素（通常是d）和零基索引（i）。

d3.max(alphabet, (d) => d.frequency) // 0.12702

由于会忽略 undefined 值，因此可以使用访问器函数来忽略值。例如，要获取非 E 的最常见字母的频率

d3.max(alphabet, (d) => d.letter === "E" ? NaN : d.frequency) // 0.09056

如果可迭代对象不包含任何可比较的值，则返回 undefined。

d3.max([]) // undefined

d3.max(alphabet, (d) => d.doesnotexist) // undefined

另请参阅 extent 和 greatest。

maxIndex(iterable, accessor)

源代码 · 与max类似，但返回最大值的索引，而不是值本身。

d3.maxIndex([3, 2, 1, 1, 6, 2, 4]) // 2

此方法可以根据给定的访问器找到最大的元素，类似于greatest

d3.maxIndex(alphabet, (d) => d.frequency) // 0

alphabet[d3.maxIndex(alphabet, (d) => d.frequency)] // {letter: "E", frequency: 0.12702}

另请参阅 greatestIndex。

least(iterable, comparator)

示例 · 源代码 · 根据指定的comparator返回指定iterable的最小元素。

d3.least(alphabet, (a, b) => a.frequency - b.frequency) // {letter: "Z", frequency: 0.00074}

d3.least(alphabet, (a, b) => b.frequency - a.frequency) // {letter: "E", frequency: 0.12702}

如果comparator接受一个参数，则解释为访问器，并使用自然顺序比较返回的元素。

d3.least(alphabet, (d) => d.frequency) // {letter: "Z", frequency: 0.00074}

d3.least(alphabet, (d) => -d.frequency) // {letter: "E", frequency: 0.12702}

如果未指定comparator，则默认为ascending。

d3.least(alphabet.map((d) => d.frequency)) // 0.00074

如果给定的iterable不包含任何可比较的元素（即，比较器在比较每个元素时返回 NaN），则返回 undefined。

d3.least([]) // undefined

此函数类似于min，除了它允许使用比较器而不是访问器。

leastIndex(iterable, comparator)

源代码 · 返回指定iterable的最小元素的索引，根据指定的comparator或accessor。如果给定的iterable不包含任何可比较的元素（即，比较器在比较每个元素时返回 NaN），则返回 -1。如果未指定comparator，则默认为ascending。例如

const array = [{foo: 42}, {foo: 91}];
d3.leastIndex(array, (a, b) => a.foo - b.foo); // 0
d3.leastIndex(array, (a, b) => b.foo - a.foo); // 1
d3.leastIndex(array, (d) => d.foo); // 0

此函数类似于minIndex，除了它允许使用比较器而不是访问器。

greatest(iterable, comparator)

示例 · 源代码 · 根据指定的comparator或accessor返回指定iterable的最大元素。如果给定的iterable不包含任何可比较的元素（即，比较器在比较每个元素时返回 NaN），则返回 undefined。如果未指定comparator，则默认为ascending。例如

const array = [{foo: 42}, {foo: 91}];
d3.greatest(array, (a, b) => a.foo - b.foo); // {foo: 91}
d3.greatest(array, (a, b) => b.foo - a.foo); // {foo: 42}
d3.greatest(array, (d) => d.foo); // {foo: 91}

此函数类似于max，除了它允许使用比较器而不是访问器。

greatestIndex(iterable, comparator)

源代码 · 返回指定iterable的最大元素的索引，根据指定的comparator或accessor。如果给定的iterable不包含任何可比较的元素（即，比较器在比较每个元素时返回 NaN），则返回 -1。如果未指定comparator，则默认为ascending。例如

const array = [{foo: 42}, {foo: 91}];
d3.greatestIndex(array, (a, b) => a.foo - b.foo); // 1
d3.greatestIndex(array, (a, b) => b.foo - a.foo); // 0
d3.greatestIndex(array, (d) => d.foo); // 1

此函数类似于maxIndex，除了它允许使用比较器而不是访问器。

extent(iterable, accessor)

示例 · 源代码 · 使用自然顺序返回给定iterable中的最小值和最大值。

d3.extent([3, 2, 1, 1, 6, 2, 4]) // [1, 6]

可以指定一个可选的访问器函数，这相当于在计算范围之前调用 Array.from。

d3.extent(alphabet, (d) => d.frequency) // [0.00074, 0.12702]

如果可迭代对象不包含任何可比较的值，则返回 [undefined, undefined]。

d3.extent(alphabet, (d) => d.doesnotexist) // [undefined, undefined]

mode(iterable, accessor)

示例 · 源代码 · 返回给定iterable的众数，即出现次数最多的值。忽略 undefined、null 和 NaN 值。

d3.mode([1, 2, 2, 2, 3, 3]) // 2

可以指定一个可选的访问器函数，这相当于在计算众数之前调用 Array.from。

d3.mode(penguins, (d) => d.island) // "Biscoe"

在相等的情况下，返回第一个相关值。如果可迭代对象不包含任何可比较的值，则返回 undefined。

sum(iterable, accessor)

示例 · 源代码 · 返回给定数字iterable的总和。忽略 undefined、null 和 NaN 值。

d3.sum([1, 2, 2, 2, NaN, 3, null]) // 10

可以指定一个可选的访问器函数，这相当于在计算总和之前调用 Array.from。

d3.sum(penguins, (d) => d.body_mass_g) // 1437000

如果可迭代对象不包含任何数字，则返回 0。另请参阅 fsum。

mean(iterable, accessor)

示例 · 源代码 · 返回给定可迭代数字的平均值。忽略 undefined、null 和 NaN 值。

d3.mean([1, 2, 2, 2, NaN, 3, null]) // 2

可以指定一个可选的访问器函数，它等同于在计算平均值之前调用 Array.from。

d3.mean(penguins, (d) => d.body_mass_g) // 4201.754385964912

如果可迭代对象不包含任何数字，则返回 undefined。

median(iterable, accessor)

示例 · 源代码 · 使用R-7 方法返回给定可迭代数字的中位数。忽略 undefined、null 和 NaN 值。

d3.median([1, 2, 2, 2, NaN, 3, null]) // 2

可以指定一个可选的访问器函数，它等同于在计算中位数之前调用 Array.from。

d3.median(penguins, (d) => d.body_mass_g) // 4050

如果可迭代对象不包含任何数字，则返回 undefined。

medianIndex(array, accessor)

源代码 · 与median类似，但返回中位数左侧元素的索引。

d3.medianIndex([1, 2, 2, 2, NaN, 3, null]) // 2

cumsum(iterable, accessor)

示例 · 源代码 · 返回给定可迭代数字的累积和，以相同长度的 Float64Array 形式返回。

d3.cumsum([1, 1, 2, 3, 5]) // [1, 2, 4, 7, 12]

可以指定一个可选的访问器函数，它等同于在计算累积和之前调用 Array.from。

d3.cumsum(penguins, (d) => d.body_mass_g) // [3750, 7550, 10800, 10800, …]

此方法忽略 undefined 和 NaN 值；这对于忽略缺失数据很有用。如果可迭代对象不包含任何数字，则返回零。另请参见fcumsum。

quantile(iterable, p, accessor)

示例 · 源代码 · 返回给定可迭代数字的p-分位数，其中p是 [0, 1] 范围内的数字。例如，中位数可以使用p = 0.5 计算，第一四分位数使用p = 0.25 计算，第三四分位数使用p = 0.75 计算。此特定实现使用R-7 方法，这是 R 编程语言和 Excel 的默认方法。

const numbers = [0, 10, 30];
d3.quantile(numbers, 0); // 0
d3.quantile(numbers, 0.5); // 10
d3.quantile(numbers, 1); // 30
d3.quantile(numbers, 0.25); // 5
d3.quantile(numbers, 0.75); // 20
d3.quantile(numbers, 0.1); // 2

可以指定一个可选的访问器函数，它等同于在计算分位数之前调用array.map。

quantileIndex(array, p, accessor)

源代码 · 与quantile类似，但返回p左侧的索引。

quantileSorted(array, p, accessor)

示例 · 源代码 · 与quantile类似，但期望输入是已排序的array值。与quantile相比，访问器仅在计算分位数所需的元素上调用。

rank(iterable, comparator)

示例 · 源代码 · 返回一个数组，其中包含可迭代对象中每个值的排名，即，可迭代对象排序后值的零索引。空值排序到末尾并排名为 NaN。可以指定一个可选的比较器或访问器函数；后者等同于在计算排名之前调用array.map。如果未指定比较器，则默认为ascending。平局（等效值）都获得相同的排名，定义为该值第一次出现的时间。

d3.rank([{x: 1}, {}, {x: 2}, {x: 0}], d => d.x); // [1, NaN, 2, 0]
d3.rank(["b", "c", "b", "a"]); // [1, 3, 1, 0]
d3.rank([1, 2, 3], d3.descending); // [2, 1, 0]

variance(iterable, accessor)

示例 · 源代码 · 使用Welford 算法返回给定可迭代数字的总体方差的无偏估计。如果可迭代对象少于两个数字，则返回 undefined。可以指定一个可选的访问器函数，它等同于在计算方差之前调用 Array.from。此方法忽略 undefined 和 NaN 值；这对于忽略缺失数据很有用。

deviation(iterable, accessor)

示例 · 源代码 · 返回标准差，定义为偏差校正方差的平方根，即给定可迭代数字的标准差。如果可迭代对象少于两个数字，则返回 undefined。可以指定一个可选的访问器函数，它等同于在计算标准差之前调用 Array.from。此方法忽略 undefined 和 NaN 值；这对于忽略缺失数据很有用。

every(iterable, test)

源代码 · 如果给定测试函数对给定可迭代对象中的每个值都返回 true，则返回 true。此方法在测试返回非真值或所有值都迭代完后立即返回。等效于array.every

d3.every(new Set([1, 3, 5, 7]), x => x & 1) // true

some(iterable, test)

源代码 · 如果给定测试函数对给定可迭代对象中的任何值都返回 true，则返回 true。此方法在测试返回真值或所有值都迭代完后立即返回。等效于array.some

d3.some(new Set([0, 2, 3, 4]), x => x & 1) // true