Array.prototype.sort() 이해하기

[11, 8, 1, 2, 33, 3].sort(); // [1, 11, 2, 3, 33, 8]
 
const arrayLike = { 0: 'c', 2: 'b', 123: '1ilsang', '1ilsang': 123, length: 3 };
Array.prototype.sort.call(arrayLike); // { 0: 'b', 1: 'c', 123: '1ilsang', '1ilsang': 123, length: 3 };
// ?????

const list = [3, 4, 6, 1, 5, 3];
list.sort(123); // TypeError!
Array.prototype.sort.call(list, 123); // TypeError!

Object('123'); // String {'123'}
Object([1, 2, 3]); // [1,2,3]
Object({ 1: 'a', 2: 'b' }); // {1: 'a', 2: 'b'}

const arrayLike = { 0: 'c', 1: 'a', 2: 'b', length: 3 };
console.log(arrayLike[1], arrayLike.length); // 'a', 3
Array.isArray(arrayLike); // false
arrayLike instanceof Array; // false

[11, 8, 1, 2, 33, 3].sort(); // [1, 11, 2, 3, 33, 8]

[1, , 2].sort(); // [1, 2, empty]
 
// 인덱스 1이 존재하지 않음.
const arrayLike = { 0: 'c', 2: 'b', 123: '1ilsang', '1ilsang': 123, length: 3 };
 
// 인덱스 2 가 삭제되고 1이 추가되었다.
// 또한 length를 벗어나는(혹은 성립하지 않는) 인덱스는 무시(정렬 X)된다.
Array.prototype.sort.call(arrayLike); // { 0: 'b', 1: 'c', 123: '1ilsang', '1ilsang': 123, length: 3 };

// https://github.com/v8/v8/blob/12.3.206.1/third_party/v8/builtins/array-sort.tq#L1419
transitioning javascript builtin ArrayPrototypeSort(
    js-implicit context: NativeContext, receiver: JSAny)(...arguments): JSAny {
  // 1. If comparefn is not undefined and IsCallable(comparefn) is false,
  //    throw a TypeError exception.
  const comparefnObj: JSAny = arguments[0];
  const comparefn = Cast<(Undefined | Callable)>(comparefnObj) otherwise
  ThrowTypeError(MessageTemplate::kBadSortComparisonFunction, comparefnObj);
 
  // 2. Let obj be ? ToObject(this value).
  const obj: JSReceiver = ToObject(context, receiver);
 
  // 3. Let len be ? ToLength(? Get(obj, "length")).
  const len: Number = GetLengthProperty(obj);
 
  if (len < 2) return obj;
 
  const isToSorted: constexpr bool = false;
  const sortState: SortState = NewSortState(obj, comparefn, len, isToSorted);
  ArrayTimSort(context, sortState);
 
  return obj;
}

// https://github.com/WebKit/WebKit/blob/wpewebkit-2.43.1/Source/JavaScriptCore/builtins/ArrayPrototype.js#L509sadfaefafasdf
function sort(comparator) {
  "use strict";
 
  var isStringSort = false;
  if (comparator === @undefined)
      isStringSort = true;
  else if (!@isCallable(comparator))
      @throwTypeError("Array.prototype.sort requires the comparator argument to be a function or undefined");
 
  var receiver = @toObject(this, "Array.prototype.sort requires that |this| not be null or undefined");
  var receiverLength = @toLength(receiver.length);
 
  // For compatibility with Firefox and Chrome, do nothing observable
  // to the target array if it has 0 or 1 sortable properties.
  if (receiverLength < 2)
      return receiver;
 
  var compacted = [ ];
  var sorted = null;
  var undefinedCount = @sortCompact(receiver, receiverLength, compacted, isStringSort);
 
  if (isStringSort) {
      sorted = @newArrayWithSize(compacted.length);
      @sortBucketSort(sorted, 0, compacted, 0);
  } else
      sorted = @sortMergeSort(compacted, comparator);
 
  @sortCommit(receiver, receiverLength, sorted, undefinedCount);
  return receiver;
}

// https://github.com/mozilla/gecko-dev/blob/661a7d013f6b841e9fbbe56d307cb206f62963c3/js/src/builtin/Array.js#L104
function ArraySort(comparefn) {
  // Step 1.
  if (comparefn !== undefined) {
    if (!IsCallable(comparefn)) {
      ThrowTypeError(JSMSG_BAD_SORT_ARG);
    }
  }
  // Step 2.
  var O = ToObject(this);
  // First try to sort the array in native code, if that fails, indicated by
  // returning |false| from ArrayNativeSort, sort it in self-hosted code.
  if (callFunction(ArrayNativeSort, O, comparefn)) {
    return O;
  }
  // Step 3.
  var len = ToLength(O.length);
  // Arrays with less than two elements remain unchanged when sorted.
  if (len <= 1) {
    return O;
  }
  // Step 4.
  var wrappedCompareFn = ArraySortCompare(comparefn);
  // Step 5.
  // To save effort we will do all of our work on a dense list, then create holes at the end.
  var denseList = [];
  var denseLen = 0;
  for (var i = 0; i < len; i++) {
    if (i in O) {
      DefineDataProperty(denseList, denseLen++, O[i]);
    }
  }
  if (denseLen < 1) {
    return O;
  }
  var sorted = MergeSort(denseList, denseLen, wrappedCompareFn);
  MoveHoles(O, len, sorted, denseLen);
  return O;
}