只适用于一堆连续渐变的属性的数据们进行查找，其中的某个符合特定条件的节点！

    1. class Dichotomy {
    2.     constructor(arr, fn) {
    3.         this.data = arr;
    4.         this.rule = fn;
    5.     }
    7.     find() {
    8.         const {data, rule} = this;
    9.         const d_length = data.length;
    10.         const getIndex = length => Math.round(length / 2) - 1;
    11.         let index = getIndex(d_length);
    12.         let min, max;
    13.         while (index) {
    14.             if (min && max && min + 1 === max) {
    15.                 this.res = max;
    16.                 return index = null;
    17.             }
    18.             const {status} = rule(index, data);
    19.             console.log(status, min, max);
    20.             if (status === "min") {
    21.                 min = min && min > index + 1 ? min : index + 1;
    22.                 index = getIndex(min + (max || d_length));
    23.             } else if (status === "max") {
    24.                 max = max && max < index + 1 ? max : index + 1;
    25.                 index = getIndex(max);
    26.             } else {
    27.                 this.res = status;
    28.                 index = null;
    29.             }
    30.         }
    31.         console.log(this.res, "r");
    32.         return this.res;
    33.     }
    34. }
    36. //只适用于一堆连续渐变的属性的数据们进行查找，其中的某个符合特定条件的节点！
    37. const dichotomy = new Dichotomy(
    38.     [
    39.         {data: 1, priority: 300},
    40.         {data: 1, priority: 200},
    41.         {data: 1, priority: 100},
    42.         {data: 1, priority: 50},
    43.         {data: 1, priority: 25},
    44.         {data: 1, priority: 12},
    45.         {data: 1, priority: 6}
    46.     ],
    47.     (index, data) => {
    48.         const obj = {data: 2, priority: 120};
    49.         if (data[0].priority < obj.priority) return {
    50.             status: 0
    51.         };
    52.         if (data[data.length - 1].priority > obj.priority)
    53.             return {
    54.                 status: data.length - 1
    55.             };
    56.         const {priority} = data[index];
    57.         if (priority > obj.priority) return {
    58.             status: "min"
    59.         };
    60.         return {
    61.             status: data[index - 1].priority > obj.priority ?
    62.                 index : "max"
    63.         };
    65.     }
    66. );
    67. dichotomy.find();
    68. console.log(dichotomy.res);