深入学习D3JS：d3-array Search部分

d3.scan(iterable[, comparator])

返回数组最小值下标，具体见上一部分。

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

返回x在数组中的插入点，lo，hi为可选数组范围，默认为整个数组，如果x已经存在返回该值左侧。

d3.bisector(comparator)

d3.bisector(accessor)

这里构造一个平分器，可以向个人构造的对象插入值，获取值的位置。用法如下：

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

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

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

然后可以使用bisectDate(array, date)，返回一个下标

import ascending from "./ascending.js";

export default function(compare) {
  if (compare.length === 1) compare = ascendingComparator(compare);
  return {
    left: function(a, x, lo, hi) {
      if (lo == null) lo = 0;
      if (hi == null) hi = a.length;
      while (lo < hi) {
        var mid = lo + hi >>> 1;
        if (compare(a[mid], x) < 0) lo = mid + 1;
        else hi = mid;
      }
      return lo;
    },
    right: function(a, x, lo, hi) {
      if (lo == null) lo = 0;
      if (hi == null) hi = a.length;
      while (lo < hi) {
        var mid = lo + hi >>> 1;
        if (compare(a[mid], x) > 0) hi = mid;
        else lo = mid + 1;
      }
      return lo;
    }
  };
}

function ascendingComparator(f) {
  return function(d, x) {
    return ascending(f(d), x);
  };
}

如果传入比较函数参数为1，默认为升序比较。之后将两个函数作为返回值，使用二分查找查x。

d3.bisect(array, x[, lo[, hi]])

import ascending from "./ascending.js";
import bisector from "./bisector.js";

var ascendingBisect = bisector(ascending);
export var bisectRight = ascendingBisect.right;
export var bisectLeft = ascendingBisect.left;
export default bisectRight;

这个是数组的平分器，就是在对象的平分器传入默认升序函数。

d3.ascending(a, b)

d3.descending(a, b)

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

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

升序降序的代码实现，这样写避免很多错误。