使用 sort() 理解一贯的错误行为

Question

我有以下代码：

let arr = [];

for (i = 14; i <= 31; i++) {
  let d = "2018-08-" + String(i);
  arr.push({
    date: d
  });
}

arr.sort((a, b) => a.date - b.date);

console.log(arr);

1. 我知道sort() 应该只用于数字
2. 我知道将字符串与 - 进行比较是个坏主意
3. 我已经本地化并修复了代码中的原始错误，但是...

这个有缺陷的代码让我着迷：结果。

从另一个字符串中减去一个字符串得到NaN，所以我希望数组保持不变（14, 15, 16, 17... 31），或者可能完全翻转（31, 30, 29, 28... 14）。

相反，实际（一致的）结果是

我很想知道为什么sort() 会输出该字符串序列。为什么31、15 和23 会被移动，为什么它们会被移动到这些特定位置？

Answer 1

使用更简单的数组可能更容易理解这种行为。

例如：

let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

arr.sort(() => NaN)

console.log(arr)

在 chrome 中，这会返回一个数组顺序，例如：[0,11,2,3,4,5,1,7,8,9,10,6]。

这很奇怪，但是如果您查看 V8 代码中的排序实现，您会发现快速排序和插入排序的混合。事实上，如果将递归调用快速排序，直到被递归的数组长度小于 10，那么它将切换到插入排序。

快速排序选择枢轴的方式解释了您所看到的行为。这是一个带有来自 V8 的略微截断的代码的 sn-p：

arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

function comparefn(a,b){
    return NaN
}
function InsertionSort(a, from, to) {
    for (var i = from + 1; i < to; i++) {
      var element = a[i];
      for (var j = i - 1; j >= from; j--) {
        var tmp = a[j];
        var order = comparefn(tmp, element);
        if (order > 0) {
          a[j + 1] = tmp;
        } else {
          break;
        }
      }
      a[j + 1] = element;
    }
  };

function QuickSort(a, from, to) {
    var third_index = 0;
    while (true) {
      // Insertion sort is faster for short arrays.
      if (to - from <= 10) {
        InsertionSort(a, from, to);
        return;
      }
      third_index = from + ((to - from) >> 1);
      
      // Find a pivot as the median of first, last and middle element.
      var v0 = a[from];
      var v1 = a[to - 1];
      var v2 = a[third_index];
      var c01 = comparefn(v0, v1);
      if (c01 > 0) {
        // v1 < v0, so swap them.
        var tmp = v0;
        v0 = v1;
        v1 = tmp;
      } // v0 <= v1.
      var c02 = comparefn(v0, v2);
      if (c02 >= 0) {
        // v2 <= v0 <= v1.
        var tmp = v0;
        v0 = v2;
        v2 = v1;
        v1 = tmp;
      } else {
        // v0 <= v1 && v0 < v2
        var c12 = comparefn(v1, v2);
        if (c12 > 0) {
          // v0 <= v2 < v1
          var tmp = v1;
          v1 = v2;
          v2 = tmp;
        }
      }
      // v0 <= v1 <= v2
      a[from] = v0;
      a[to - 1] = v2;
      var pivot = v1;
      var low_end = from + 1;   // Upper bound of elements lower than pivot.
      var high_start = to - 1;  // Lower bound of elements greater than pivot.
      a[third_index] = a[low_end];
      a[low_end] = pivot;

      // From low_end to i are elements equal to pivot.
      // From i to high_start are elements that haven't been compared yet.
      partition: for (var i = low_end + 1; i < high_start; i++) {
        var element = a[i];
        var order = comparefn(element, pivot);
        if (order < 0) {
          a[i] = a[low_end];
          a[low_end] = element;
          low_end++;
        } else if (order > 0) {
          do {
            high_start--;
            if (high_start == i) break partition;
            var top_elem = a[high_start];
            order = comparefn(top_elem, pivot);
          } while (order > 0);
          a[i] = a[high_start];
          a[high_start] = element;
          if (order < 0) {
            element = a[i];
            a[i] = a[low_end];
            a[low_end] = element;
            low_end++;
          }
        }
      }
      if (to - high_start < low_end - from) {
        QuickSort(a, high_start, to);
        to = low_end;
      } else {
        QuickSort(a, from, low_end);
        from = high_start;
      }
    }
  };

// run it
QuickSort(arr, 0, arr.length)

console.log(arr)

如果您查看这一点，尤其是选择枢轴的方式以及切换到插入排序时，您会明白为什么结果按原样排序。

当比较函数总是返回 NaN 时，代码中的所有ifs 都会被绕过，如下所示：

var c12 = comparefn(v1, v2);
if (c12 > 0) { /* etc /*}

意味着整个排序减少到更小：

arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

function comparefn(a,b){
    //console.log(a, b)
    return NaN
}

 function QuickSort(a, from, to) {
    var third_index = 0;
    while (true) {
      // Insertion sort is faster for short arrays.
      if (to - from <= 10) {
        return;
      }
       third_index = from + ((to - from) >> 1);
      // Find a pivot as the median of first, last and middle element.
      var v0 = a[from];
      var v1 = a[to - 1];
      var v2 = a[third_index];
      
      a[from] = v0;
      a[to - 1] = v2;
      var pivot = v1;
      var low_end = from + 1;   // Upper bound of elements lower than pivot.
      var high_start = to - 1;  // Lower bound of elements greater than pivot.
      a[third_index] = a[low_end];
      a[low_end] = pivot;
      partition: for (var i = low_end + 1; i < high_start; i++) {
        var element = a[i];
      }
      if (to - high_start < low_end - from) {
        QuickSort(a, high_start, to);
        to = low_end;
      } else {
        QuickSort(a, from, low_end);
        from = high_start;
      }
    }
  };
QuickSort(arr, 0, arr.length)
console.log(arr)