array常见基础数组实现原理

push：在数组末尾添加一个或多个元素，并返回新的长度。

因为源码中有很多内部函数做了很多的校验，所以我会先写一个简易的核心逻辑理解一下

简易的核心逻辑：

function Push(x, ...elements) {
    const length = x.length;

    for (let i = 0; i < elements.length; i++) {
        x[length + i] = elements[i];
    }

    return x.length;
}

v8的源码https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js第540行，

function ObservedArrayPush() {
//是为响应式什么的做准备的
  var n = TO_LENGTH_OR_UINT32(this.length);
  var m = %_ArgumentsLength();

  try {
    ObserveBeginPerformSplice(this);
    for (var i = 0; i < m; i++) {
      this[i+n] = %_Arguments(i);
    }
    var new_length = n + m;
    this.length = new_length;
  } finally {
    ObserveEndPerformSplice(this);
    ObserveEnqueueSpliceRecord(this, n, [], m);
  }

  return new_length;
}


// Appends the arguments to the end of the array and returns the new
// length of the array. See ECMA-262, section 15.4.4.7.
function ArrayPush() {
  CHECK_OBJECT_COERCIBLE(this, "Array.prototype.push");

  if (%IsObserved(this))
    return ObservedArrayPush.apply(this, arguments);

  var array = TO_OBJECT(this);
  var n = TO_LENGTH_OR_UINT32(array.length);
  var m = %_ArgumentsLength();

  // It appears that there is no enforced, absolute limit on the number of
  // arguments, but it would surely blow the stack to use 2**30 or more.
  // To avoid integer overflow, do the comparison to the max safe integer
  // after subtracting 2**30 from both sides. (2**31 would seem like a
  // natural value, but it is negative in JS, and 2**32 is 1.)
  if (m > (1 << 30) || (n - (1 << 30)) + m > kMaxSafeInteger - (1 << 30)) {
    throw MakeTypeError(kPushPastSafeLength, m, n);
  }
//核心方法
  for (var i = 0; i < m; i++) {
    array[i+n] = %_Arguments(i);
  }

  var new_length = n + m;
  array.length = new_length;
  return new_length;
}

pop()：移除并返回数组的最后一个元素。

简易的核心逻辑：

  function pop(array , n) {
      var n = array.length;
      n--;
      var value = array[n];
      delete array[n];
      array.length = n;
      return value;
    }

v8的源码https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js第497行

function ArrayPop() {
  CHECK_OBJECT_COERCIBLE(this, "Array.prototype.pop");

  var array = TO_OBJECT(this);
  var n = TO_LENGTH_OR_UINT32(array.length);
  if (n == 0) {
    array.length = n;
    return;
  }

  if (%IsObserved(array))
    return ObservedArrayPop.call(array, n);

  n--;
  var value = array[n];
  %DeleteProperty_Strict(array, n);
  array.length = n;
  return value;
}

shift：移除并返回数组的第一个元素。

简易的核心逻辑：

function shift() {
    if(this.length === 0) {
        return undefined;
    }

    var firstElement = this[0];

    for (var i = 0; i < this.length; i++) {
        this[i] = this[i + 1];
    }

    this.length--;

    return firstElement;
}

v8的源码https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js第684行

function ArrayShift() {
  CHECK_OBJECT_COERCIBLE(this, "Array.prototype.shift");

  var array = TO_OBJECT(this);
  var len = TO_LENGTH_OR_UINT32(array.length);

  if (len === 0) {
    array.length = 0;
    return;
  }

  if (%object_is_sealed(array)) throw MakeTypeError(kArrayFunctionsOnSealed);

  if (%IsObserved(array))
    return ObservedArrayShift.call(array, len);

  var first = array[0];

  if (UseSparseVariant(array, len, IS_ARRAY(array), len)) {
    SparseMove(array, 0, 1, len, 0);
  } else {
    SimpleMove(array, 0, 1, len, 0);
  }

  array.length = len - 1;

  return first;
}

unshift():向数组的开头添加一个或多个元素，并返回新的长度

简易的核心逻辑：

function unshift(x ,...arguments) {
    // 将类数组对象转换为数组
    var array = Array.prototype.slice.call(x);

    // 获取传入参数的个数
    var num_arguments = arguments.length;

    // 计算新数组的长度
    var new_length = array.length + num_arguments;

    // 将数组往后推
    for (var i = new_length - 1; i >= num_arguments; i--) {
        array[i] = array[i - num_arguments];
    }
    // 给数组第一个位置赋值
    for (var j = 0; j < num_arguments; j++) {
        array[j] = arguments[j];
    }

    // 更新数组的长度
    array.length = new_length;
}

v8的源码https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js第735行

function ArrayUnshift(arg1) {  // length == 1
  CHECK_OBJECT_COERCIBLE(this, "Array.prototype.unshift");

  if (%IsObserved(this))
    return ObservedArrayUnshift.apply(this, arguments);

  var array = TO_OBJECT(this);
  var len = TO_LENGTH_OR_UINT32(array.length);
  var num_arguments = %_ArgumentsLength();

  if (len > 0 && UseSparseVariant(array, len, IS_ARRAY(array), len) &&
      !%object_is_sealed(array)) {
    SparseMove(array, 0, 0, len, num_arguments);
  } else {
    SimpleMove(array, 0, 0, len, num_arguments);
  }

  for (var i = 0; i < num_arguments; i++) {
    array[i] = %_Arguments(i);
  }

  var new_length = len + num_arguments;
  array.length = new_length;
  return new_length;
}