資料摘要

計算摘要統計資料。

count(iterable, accessor)

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

範例 · 原始碼 · 傳回指定 iterable 中有效數字值（即，非 null、NaN 或未定義）的數量；接受存取器。

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 不同，此方法會忽略未定義、null 和 NaN 值，這對於忽略遺失資料很有用。

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

可以指定一個選用的存取器函數，這類似於在計算最小值之前呼叫 Array.from。存取器函數會重複傳遞一個元素從給定的可迭代物件 (通常是 d) 和從 0 開始的索引 (i)。

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

由於會忽略未定義的值，因此可以使用存取器函數來忽略值。例如，若要取得非 Z 的最不常見字母的頻率

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

如果可迭代物件不包含任何可比較的值，則會傳回未定義。

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 不同，此方法會忽略未定義、null 和 NaN 值，這對於忽略遺失的資料很有用。

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

可以指定一個選用的存取器函數，這類似於在計算最大值之前呼叫 Array.from。存取器函數會重複傳遞一個元素從給定的可迭代物件 (通常是 d) 和從 0 開始的索引 (i)。

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

由於會忽略未定義的值，因此可以使用存取器函數來忽略值。例如，若要取得非 E 的最常見字母的頻率

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

如果可迭代物件不包含任何可比較的值，則會傳回未定義。

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)

範例 · 原始碼 · 傳回指定的 iterable 中，根據指定的 comparator 最小的元素。

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），則傳回未定義。

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)

範例 · 原始碼 · 傳回指定的 iterable 中，根據指定的 comparator 或 accessor 最大的元素。如果指定的 iterable 不包含任何可比較的元素（例如，在將每個元素與其本身進行比較時，比較器傳回 NaN），則傳回未定義。如果未指定 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]

可以指定一個選用的 accessor 函數，這等於在計算範圍之前呼叫 Array.from。

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

如果 iterable 不包含任何可比較的數值，則傳回 [undefined, undefined]。

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

mode(iterable, accessor)

範例 · 原始碼 · 傳回給定 iterable 的模式，即出現次數最多的值。忽略未定義、null 和 NaN 值。

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

可以指定一個選用的 accessor 函數，這等於在計算模式之前呼叫 Array.from。

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

如果相等，則傳回相關值的開頭。如果 iterable 不包含任何可比較的數值，則傳回未定義。

sum(iterable, accessor)

範例 · 原始碼 · 傳回給定數字 iterable 的總和。忽略未定義、null 和 NaN 值。

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

可以指定一個選用的 accessor 函數，這等於在計算總和之前呼叫 Array.from。

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

如果 iterable 不包含任何數字，則傳回 0。另請參閱 fsum。

mean(iterable, accessor)

範例 · 原始碼 · 傳回給定數字 iterable 的平均值。忽略未定義、null 和 NaN 值。

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

可以指定一個可選的accessor函式，這等於在計算平均值之前呼叫 Array.from。

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

如果 iterable 不包含數字，則傳回未定義。

median(iterable, accessor)

範例 · 原始碼 · 使用 R-7 方法傳回給定數字的iterable中位數。忽略未定義、null 和 NaN 值。

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

可以指定一個可選的accessor函式，這等於在計算中位數之前呼叫 Array.from。

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

如果 iterable 不包含數字，則傳回未定義。

medianIndex(array, accessor)

原始碼 · 如同 median，但傳回中位數左側元素的索引。

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

cumsum(iterable, accessor)

範例 · 原始碼 · 傳回給定數字的iterable累積總和，作為相同長度的 Float64Array。

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

可以指定一個可選的accessor函式，這等於在計算累積總和之前呼叫 Array.from。

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

此方法會忽略未定義和 NaN 值；這對於忽略遺失資料很有用。如果 iterable 不包含數字，則傳回零。另請參閱 fcumsum。

quantile(iterable, p, accessor)

範例 · 原始碼 · 傳回給定數字的iterable的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

可以指定一個可選的accessor函式，這等於在計算分位數之前呼叫 array.map。

quantileIndex(array, p, accessor)

原始碼 · 類似於 quantile，但會傳回小於 p 的索引。

quantileSorted(array, p, accessor)

範例 · 原始碼 · 類似於 quantile，但預期輸入為值的有序 array。與 quantile 相反，accessor 僅會呼叫計算 quantile 所需的元素。

rank(iterable, comparator)

範例 · 原始碼 · 傳回 iterable 中每個值的名次，也就是當 iterable 排序後，該值的零為基準的索引。Nullish 值會排序到最後，並排名為 NaN。可以指定一個選用的 comparator 或 accessor 函式；後者等於在計算名次之前呼叫 array.map。如果未指定 comparator，它會預設為 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 演算法傳回給定數字 iterable 的母體變異數的 無偏估計值。如果 iterable 少於兩個數字，則傳回未定義。可以指定一個選用的 accessor 函式，這等於在計算變異數之前呼叫 Array.from。此方法會忽略未定義和 NaN 值；這對於忽略遺失資料很有用。

deviation(iterable, accessor)

範例 · 原始碼 · 傳回給定數字iterable的標準差，定義為偏差修正變異數的平方根。如果iterable少於兩個數字，則傳回未定義。可以指定一個accessor函式，這等於在計算標準差之前呼叫Array.from。此方法會忽略未定義和NaN值；這對於忽略遺失資料很有用。

every(iterable, test)

原始碼 · 如果給定的test函式對給定iterable中的每個值傳回true，則傳回true。此方法會在test傳回非真值或所有值都已反覆運算後立即傳回。等同於array.every

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

some(iterable, test)

原始碼 · 如果給定的test函式對給定iterable中的任何值傳回true，則傳回true。此方法會在test傳回真值或所有值都已反覆運算後立即傳回。等同於array.some

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