Answers:
我刚刚看过WebKit（Chrome，Safari…）源。根据数组的类型，使用不同的排序方法：
使用C ++标准库函数对数值数组（或原始类型的数组）进行排序，该函数std::qsort实现了快速排序（通常是introsort）的某些变体。
如果可用（以获得稳定的排序）或qsort没有可用的合并排序，则使用mergesort 对非数字类型的连续数组进行字符串化和排序。
对于其他类型（非连续数组，大概是关联数组），WebKit使用选择排序（它们称为“ min”排序），或者在某些情况下，它通过AVL树进行排序。不幸的是，这里的文档含糊不清，因此您必须跟踪代码路径以实际查看使用哪种排序方法的类型。
再就是像宝石此评论：
// FIXME: Since we sort by string value, a fast algorithm might be to use a
// radix sort. That would be O(N) rather than O(N log N).–我们只希望真正“解决”此问题的人比这篇评论的作者对渐近运行时有更好的理解，并意识到基数排序比简单的O（N）稍微复杂一些。
（感谢phsource指出了原始答案中的错误。）
JS没有使用特定排序算法的草稿要求。正如许多人在此处提到的那样，Mozilla使用合并排序。但是，在今天的Chrome v8源代码中，它对较小的数组使用QuickSort和InsertionSort。
从807-891行
var QuickSort = 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;
}
if (to - from > 1000) {
third_index = GetThirdIndex(a, from, to);
} else {
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;
}
}
};更新 截至2018年V8使用TimSort，感谢@celwell。资源
ECMAscript标准未指定要使用哪种排序算法。实际上，不同的浏览器具有不同的排序算法。例如，在对地图进行排序时，Mozilla / Firefox的sort（）不稳定（按单词的排序意义）。IE的sort（）是稳定的。
Array.sort；看到这个问题。
我认为这取决于您所指的浏览器实现。
每种浏览器类型都有自己的JavaScript引擎实现，因此要视情况而定。您可以检查Mozilla和Webkit / Khtml的源代码存储库以了解不同的实现。
IE是封闭源，因此您可能不得不问微软的某个人。
JavaScript的Array.sort（）函数具有内部机制，可以根据数组元素的数据类型选择最佳的排序算法（QuickSort，MergeSort等）。
试试这个快速排序：
function sort(arr, compareFn = (a, b) => a <= b) {
if (!arr instanceof Array || arr.length === 0) {
return arr;
}
if (typeof compareFn !== 'function') {
throw new Error('compareFn is not a function!');
}
const partition = (arr, low, high) => {
const pivot = arr[low];
while (low < high) {
while (low < high && compareFn(pivot, arr[high])) {
--high;
}
arr[low] = arr[high];
while (low < high && compareFn(arr[low], pivot)) {
++low;
}
arr[high] = arr[low];
}
arr[low] = pivot;
return low;
};
const quickSort = (arr, low, high) => {
if (low < high) {
let pivot = partition(arr, low, high);
quickSort(arr, low, pivot - 1);
quickSort(arr, pivot + 1, high);
}
return arr;
};
return quickSort(arr, 0, arr.length - 1);
}