帮酷LOGO
  • 显示原文与译文双语对照的内容
文章标签:ordering  ARR  求和  ord  searching  搜索  MAN  Manipulation  
Array manipulation, ordering, searching, summarizing, etc.

  • 源代码名称:d3-array
  • 源代码网址:http://www.github.com/d3/d3-array
  • d3-array源代码文档
  • d3-array源代码下载
  • Git URL:
    git://www.github.com/d3/d3-array.git
  • Git Clone代码到本地:
    git clone http://www.github.com/d3/d3-array
  • Subversion代码到本地:
    $ svn co --depth empty http://www.github.com/d3/d3-array
    Checked out revision 1.
    $ cd repo
    $ svn up trunk
  • d3-array

    JavaScript中的数据通常由 array 表示,因这里可以以在可以视化或者分析数据时操作数组。 一些常见的操作形式包括采用一个连续的切片( 子集),使用谓词函数过滤一个,并使用转换函数将一个 array 映射到一个并行的值集合。 先查看这个模块提供的实用程序集,然后熟悉内置的强大的 array 方法以实现 JavaScript 。

    JavaScript包含了的变异方法,用于修改 array:

    还有访问方法,返回 array的某些表示形式:

    finally 对 array 中元素应用函数的迭代方法:

    • 使用predicate创建一个新的array,只包含一个谓词,其中包含一个谓词。
    • array foreach - 调用 array 中的每个元素。
    • 每个元素都有一个值,每个元素都满足一个谓词。
    • 使用调用函数的结果创建一个新的array,该结果在 array 中的每个元素调用一个函数。
    • 确定是否至少有一个元素满足谓词的条件。
    • 将函数缩减为单个值( 来自 left-to-right )的方法。
    • 将函数应用到单个值( 来自 right-to-left ) 中。

    安装

    如果你使用 NPM,npm install d3-array 。 否则,下载最新版本的。 你也可以直接从 d3js.org 加载,或者作为一个独立库,或者作为D3 4.0的一部分。 支持 AMD,CommonJS和香草环境。 在vanilla中,导出了一个 d3 全局:

    <scriptsrc="https://d3js.org/d3-array.v1.min.js"></script>
    <script>var min =d3.min(array);</script>

    在浏览器中尝试 d3-array 。

    API参考

    统计

    计算基本汇总统计的方法。

    # d3.min(array [, accessor] ) <>

    使用自然顺序返回给定 array 中的最小值。 如果 array 为空,则返回未定义的。 可以指定可选的访问器函数,这相当于在计算最小值之前调用 array 。

    内置 Math.min 不同,这里方法忽略未定义。空和NaN值;这对于忽略丢失的数据非常有用。 此外,使用自然顺序而不是数值顺序对元素进行比较。 例如字符串 ["20","3"]的最小为" 20",而数字 [20, 3 ]的最小值为 3 。

    请参见扫描范围。

    # d3.max(array [, accessor] ) <>

    返回给定 array 中的最大值,使用自然顺序。 如果 array 为空,则返回未定义的。 可以指定可选的访问器函数,这相当于在计算最大值之前调用 array 。

    内置 Math.max 不同,这里方法忽略未定义的值;这对于忽略丢失的数据非常有用。 此外,使用自然顺序而不是数值顺序对元素进行比较。 例如字符串 ["20","3"]的最大字符串为" 3",而数字 [20, 3 ]的最大值为 20.

    请参见扫描范围。

    # d3.extent(array [, accessor] ) <>

    返回给定值的最小值和最大值( 以natural为单位),使用自然次序。 如果 array 为空,则返回 [undefined, undefined] 。 可以指定可选的访问器函数,这相当于在计算范围之前调用 array. map( accessor ) 。

    # d3.sum(array [, accessor] ) <>

    返回给定数字的和,即数字的array 。 如果 array 为空,则返回 0. 可以指定可选的访问器函数,这相当于在计算和之前调用 array. map( accessor ) 。 这里方法忽略未定义和NaN值;这对于忽略丢失的数据非常有用。

    # d3.mean(array [, accessor] ) <>

    返回给定值的平均值,即数字。 如果 array 为空,则返回未定义的。 可以指定可选的访问器函数,这相当于在计算平均值之前调用 array. map( accessor ) 。 这里方法忽略未定义和NaN值;这对于忽略丢失的数据非常有用。

    # d3.median(array [, accessor] ) <>

    返回给定 array的中值,使用 R-7 方法 。 如果 array 为空,则返回未定义的。 可以指定可选的访问器函数,这相当于在计算中间值之前调用 array 。 这里方法忽略未定义和NaN值;这对于忽略丢失的数据非常有用。

    # d3.quantile(array, p [, accessor] ) <>

    返回 sorted sorted sorted sorted sorted array的-quantile p is是 range range的一个数。 比如 median median median median,median quartile = 0.25,第三个四分位数为,第三个四分位数为 0.75,为。 这个特定实现使用 R-7 方法,这是 R 编程语言和Excel的默认工具。 例如:

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

    可以指定可选的访问器函数,这相当于在计算分位数之前调用 array. map( accessor ) 。

    # d3.variance(array [, accessor] ) <>

    返回一个样本值的无偏估计,该估计值的值为 numbers,。 如果 array的值少于两个,则返回未定义的值。 可以指定可选的访问器函数,这相当于在计算方差之前调用 array. map( accessor ) 。 这里方法忽略未定义和NaN值;这对于忽略丢失的数据非常有用。

    # d3.deviation(array [, accessor] ) <>

    返回标准偏差,该偏差定义为给定值的平方 root的平方值( 已经纠正的方差)的平方。 如果 array的值少于两个,则返回未定义的值。 可以指定可选的访问器函数,这相当于在计算标准偏差之前调用 array. map( accessor ) 。 这里方法忽略未定义和NaN值;这对于忽略丢失的数据非常有用。

    全文搜索

    用于搜索特定元素的数组的方法。

    # d3.scan(array [, comparator] ) <>

    对指定的array 进行线性扫描,根据指定的比较器返回最少元素的索引。 如果给定的array 不包含可以比较元素( 。 但是,比较器在比较每个元素时返回 NaN,返回未定义的。 如果不指定比较器,则默认为递增 。 例如:

    var array = [{foo:42}, {foo:91}];d3.scan(array, function(a, b) { returna.foo-b.foo; }); // 0d3.scan(array, function(a, b) { returnb.foo-a.foo; }); // 1

    这个函数类似于 ,只是它允许使用比较器而不是访问器,它返回索引而不是访问值。 请参见 bisect 。

    # d3.bisectLeft(array, x [, lo[, hi] ]) <>

    返回 array的插入点,以保持排序顺序。 可以用来指定 array的子集,也可以用来指定应该考虑的子集;默认情况下,整个 array 被用来指定一个子集。 如果 x 已经在 array,则插入点将位于( 在左边) 之前,任何现有条目都是。 返回值适合作为接头的第一个参数,假定 array 已经排序。 returned array/,partitions,partitions,. slice( lo, i ),,,,,partitions,partitions,partitions,partitions,partitions,partitions,partitions,partitions,partitions,partitions,partitions,partitions 。

    # d3.bisect(array, x [, lo[, hi] ]) <>
    # d3.bisectRight(array, x [, lo[, hi] ]) <>

    类似于 bisectLeft,但返回一个插入点,在( 右边的)的任何现有条目中都有一个插入点,array 。 returned array//partitions/partitions/.slice( lo, i )/.slice( i, hi )//////。

    # d3.bisector(accessor) <>
    # d3.bisector(comparator) <>

    使用指定的存取器或者比较器函数返回一个新的bisector 。 这个方法可以用来分割对象数组,而不是被限制为简单的基元数组。 例如给定以下对象的array:

    var data = [
     {date:newDate(2011, 1, 1), value:0.5},
     {date:newDate(2011, 2, 1), value:0.6},
     {date:newDate(2011, 3, 1), value:0.7},
     {date:newDate(2011, 4, 1), value:0.8}
    ];

    可以构造一个合适的平分函数,如下所示:

    var bisectDate =d3.bisector(function(d) { returnd.date; }).right;

    这等效于指定比较器:

    var bisectDate =d3.bisector(function(d, x) { returnd.date- x; }).right;

    然后将它的应用为 bisectDate ( array, ),返回索引。 注意,比较器总是传递搜索值 x 作为第二个参数。 如果希望按照不同于自然顺序的顺序排序值,而不是按升序排序,则使用比较器而不是访问器。

    # bisector.left(array, x [, lo[, hi] ]) <>

    等价于 bisectLeft,但使用了这里bisector比较器。

    # bisector.right(array, x [, lo[, hi] ]) <>

    等价于 bisectRight,但使用了这里bisector比较器。

    # d3.ascending(a, b) <>

    Returns b Returns Returns Returns Returns Returns b b b b b b b b b,,。 这是比较自然顺序的比较函数,可以与内置的array 一起使用。排序方法按升序排列元素。 它实现为:

    functionascending(a, b) {
     return a < b ?-1: a > b ?1: a >= b ?0:NaN;
    }

    注意,如果没有对内置排序方法指定比较函数,默认的顺序是字典( 按字母顺序排列),而不是自然的 ! 这可能导致对数字的array 进行排序时出现令人吃惊的行为。

    # d3.descending(a, b) <>

    Returns大于 b b Returns Returns Returns Returns Returns b b b b b b b b b,。 这是比较自然顺序的比较函数,可以与内置 array 排序方法一起使用,以降序排列元素。 它实现为:

    functiondescending(a, b) {
     return b < a ?-1: b > a ?1: b >= a ?0:NaN;
    }

    注意,如果没有对内置排序方法指定比较函数,默认的顺序是字典( 按字母顺序排列),而不是自然的 ! 这可能导致对数字的array 进行排序时出现令人吃惊的行为。

    转换

    转换数组和生成新数组的方法。

    # d3.cross(a, b [, reducer] ) <>

    返回两个数组的笛卡尔乘积b 。 for specified array 指定的和元素在指定的中,每个元素都会调用指定的reducer reducer reducer reducer reducer 。 如果未指定 reducer reducer,则默认为一个函数,它为每个对创建两个元素:

    functionpair(a, b) {
     return [a, b];
    }

    例如:

    d3.cross([1, 2], ["x", "y"]); // returns [[1,"x"], [1,"y"], [2,"x"], [2,"y"]]d3.cross([1, 2], ["x", "y"], (a, b) => a + b); // returns ["1x","1y","2x","2y"]

    # d3.merge(arrays) <>

    将指定的数组合并为单个 array 。 这种方法类似于内置 array concat方法;惟一的区别在于,当你拥有一个数组的array 时,它更方便。

    d3.merge([[1], [2, 3]]); // returns [1, 2, 3]

    # d3.pairs(array [, reducer] ) <>

    For array 中的每个相邻元素pair按顺序调用指定的减速器函数传递元素i i i i i i 1. 如果未指定 reducer reducer,则默认为一个函数,它为每个对创建两个元素:

    functionpair(a, b) {
     return [a, b];
    }

    例如:

    d3.pairs([1, 2, 3, 4]); // returns [[1, 2], [2, 3], [3, 4]]d3.pairs([1, 2, 3, 4], (a, b) => b - a); // returns [1, 1, 1];

    如果指定的array 少于两个元素,则返回空的array 。

    # d3.permute(array, indexes) <>

    返回指定的array的置换,使用指定的索引。 返回的array 包含索引中每个索引的array 中的相应元素,顺序为。 例如 permute ( ["a","b","c"],[1, 2, 0 ] ) 返回 ["b","c","a"] 。 索引的array 与元素 array的长度是不同的,也可以以被复制或者省略索引的长度。

    这里方法还可以用于将对象中的值提取为具有稳定顺序的array 。 按顺序提取键控值对于在嵌套选择中生成数据数组很有用。 例如:

    var object = {yield:27, variety:"Manchuria", year:1931, site:"University Farm"},
     fields = ["site", "variety", "yield"];d3.permute(object, fields); // returns ["University Farm","Manchuria", 27]

    # d3.shuffle(array [, lo[, hi] ]) <>

    使用 fisher yates shuffle Randomizes指定 array的顺序。

    # d3.ticks(start, stop, count) <>

    开始和停止,返回大约计数+ 1的均匀间隔值,nicely-rounded stop 。 每一个值都是ten乘以 1,2或者 5的幂。 请参见 d3.tickIncrementd3.tickStep 和线性 。tick 。

    如果Ticks的值是精确的,那么它们就包含了 Ticks start start start stop stop stop stop stop stop stop值与推断的步骤一致 rounded rounded 。 ,returned tick t satisfies start start start start ≤ ≤ ≤ ≤ ≤ stop stop stop stop stop stop stop stop stop stop 。

    # d3.tickIncrement(start, stop, count) <>

    Like ,requires开始总是小于或者等于步骤 step step step step step step step step negative negative step step step instead instead 。 方法始终保证返回整数,并使用 d3.ticks 避免将返回的tick值精确地表示为IEEE浮点中的possible 。

    # d3.tickStep(start, stop, count) <>

    如果将相同的参数传递给 d3.ticks,则返回相邻刻度值之间的差异: 一个圆度很好的值,它的幂为10倍,1,2或者 5. 注意,由于 754浮点精度有限,返回值可能不是精确的小数;使用 d3-format 格式化人类消费的数字。

    # d3.range( [start, ] stop [, step] ) <>

    返回包含算术级数的array,类似于范围中构建的python 。 这里方法常用于循环循环数值的序列,例如 array的索引或者线性比例的刻度。 ( 请参见 d3.ticks,以获得良好的舍入值。)

    如果省略了步骤,则默认为 1. 如果开始,则默认为 0. 停止值是独占的;它不包含在结果中。 if第一步是正数start最后一个元素是最大开始 + * step step step step step step step step step step step step stop stop stop stop stop stop stop stop stop stop stop 。 返回的array 值将包含无限个值,则返回空范围。

    参数不需要为整数;但是,如果它们是一个整数,则结果更可以预测。 在返回的array 中的值定义为开始 + i i * step step步骤 step step step step step step returned returned array 。 例如:

    d3.range(0, 1, 0.2) // [0, 0.2, 0.4, 0.6000000000000001, 0.8]

    这种意外行为是由于 * 754双精度浮点,定义 0.2 3 = 0000000000001. 使用 格式的rounding格式化数字;参见 d3-scale中的linear.tickFormat 。

    同样,如果返回 array 应该具有特定长度,那么在整数范围内考虑使用 array.map 。 例如:

    d3.range(0, 1, 1/49); // BAD: returns 50 elements!d3.range(49).map(function(d) { return d /49; }); // GOOD: returns 49 elements.

    # d3.transpose(matrix) <>

    使用压缩操作符作为一个二维的矩阵转置函数。

    # d3.zip(arrays...) <>

    在数组中,返回一个数组,其中包含元素我从每个参数数组元素元素。 返回的array 在数组中的长度缩短到最短的array 。 如果数组只包含一个 array,则返回的array 包含一个元素数组。 没有参数时,返回的array 为空。

    d3.zip([1, 2], [3, 4]); // returns [[1, 3], [2, 4]]

    直方图

    Histogram

    直方图将多个离散样本分成较小的连续的非重叠的间隔。 它们通常用来可视化数值数据的分布。

    # d3.histogram() <>

    构造具有默认设置的新直方图生成器。

    # histogram(data) <>

    计算给定的数据样本的直方图。 返回容器的array,其中每个bin都是一个 array,其中包含来自输入数据的关联元素。 因此,bin的length 是该容器中的元素数。 每个bin有两个附加属性:

    • x0 - bin ( 包含)的下限。
    • x1 - bin ( 独占,除最后一个纸盒外)的上限。

    # histogram.value( [value] ) <>

    如果指定,则将值访问器设置为指定函数或者常数,并返回这里直方图生成器。 返回当前值访问器,该值默认为标识函数,如果没有指定。

    当直方图是 generated时,将为输入数据 array 中的每个元素调用值访问器,将元素 d 。索引 i 和 array data 作为3 个参数传递给。 默认值访问器假定输入数据是可以订购的( 可以比较),例如数字或者日期。 如果没有数据,则应指定返回给定数据的相应可以订购值的访问器。

    这类似于在调用直方图生成器之前将数据映射到值,但是输入数据与返回的数据库相关。

    # histogram.domain( [domain] ) <>

    如果指定,则将域访问器设置为指定函数或者 array,并返回这里直方图生成器。 如果没有指定,则返回当前域访问器,默认为范围 。 直方图域定义为 array [ min, max ],其中最小是最小可见值,最大可见值是最大可见值;两个值均包含 inclusive 。 这里域以外的任何值在直方图为生成时都将被忽略。

    例如如果你使用的直方图与线性比例x,则可能会说:

    var histogram =d3.histogram()
    . domain(x.domain())
    . thresholds(x.ticks(20));

    然后,你可以从一个数字的array 计算垃圾箱,如下所示:

    var bins =histogram(numbers);

    注意,域访问器是在实化的array 值( 而不是在输入数据页上) 上调用的。

    # histogram.thresholds( [count] ) <>
    # histogram.thresholds( [thresholds] ) <>

    如果指定了阈值,将阈值生成器设置为指定的函数或者 array,并返回该直方图生成器。 如果未指定阈值,则返回当前阈值生成器,默认情况下,将实现 Sturges'公式 。 在默认情况下,直方图值必须是数字) 阈值定义为 [ x0, x1,. . .] 值的array 。 any小于 x0 any将放在第一个 bin,大于或者等于 x0,但小于 x1 x1将放在第二个 bin,依此类推。 因此,生成的直方图将有阈值长度+ 1个箱子。 有关更多信息,请参见直方图阈值

    忽略之外的任何阈值。 bin总是等于最小域值,而最后一个 bin总是等于最大域值。

    如果specified计数指定为阈值,则将被均匀划分为大约个 bins bins bins bins ticks ticks ticks ticks 。

    直方图阈值

    这些函数通常不直接使用;相反,将它们传递给 直方图 你还可以使用三个参数来实现自己的阈值生成器: input input input值的array observable observable observable domain domain domain domain min min min max max max max max 。 生成器可以返回数字阈值的array 或者计数,在后一个例子中,域被均匀地划分为大约个 bins bins bins see ticks ticks 。

    # d3.thresholdFreedmanDiaconis(values, min, max) <>

    根据 freedman diaconis规则返回箱数;输入值必须为数字。

    # d3.thresholdScott(values, min, max) <>

    根据scott参考规则的标准返回bins数量;输入必须是数字。

    # d3.thresholdSturges(values) <>

    根据 Sturges'公式返回bins数量;输入必须为数字。



    文章标签:MAN  搜索  Manipulation  ord  ARR  array  求和  searching  

    Copyright © 2011 HelpLib All rights reserved.    知识分享协议 京ICP备05059198号-3  |  如果智培  |  酷兔英语