ES2015 (ES6) 出现

参数

  1. target
    1. 替换开始索引
  2. start
    1. 替换元素集合开始
      1. 闭距离
    2. 可选
  3. end
    1. 替换元素集合开始
      1. 开距离
    2. 可选 ```javascript const arr = [1, 2, 3, 4, 5]; arr.copyWithin(0, 3, 4); // [4, 2, 3, 4, 5] // 1. 3 - 4 [3, 4) // 2. target 从 … 即被替换的开始 // 3. end > length - 1 取到末尾

arr.copyWithin(5, 1, 2); // [1, 2, 3, 4, 5] // 4. target > length -1 不发生任何替换

arr.copyWithin(3, 1, 3); // [1, 2, 3, 2, 3] // 5. target > start 正常替换

arr.copyWithin(0, -3, -1); // [3, 4, 3, 4, 5] // 6. start或end是负数 start+length end+length

arr.copyWithin(3); // [1, 2, 3, 1, 2] // 7. 没有start和end 取整个数组元素 arr.copyWithin(1, 3); // [1, 4, 5, 4, 5] // 没有end 取start开始至数组末尾的元素 // copyWithin不改变数组长度

const newArr = arr.copyWithin(1, 3); newArr === arr //true // 8. 返回是原数组引用

  1. 相当于C++的memcpy，用于数组元素
  3. 1. 复制 （同一引用）
  4.    1. 全选target及符合复制的元素集合的长度元素集合
  5. 2. 粘贴
  7. **this不一定非要指向一个数组，也可以指向一个对象**
  8. ```javascript
  9. var obj = {
  10.     0: 1,
  11.   1: 2,
  12.   2: 3,
  13.   3: 4,
  14.   4, 5,
  15.   lenght: 5
  16. }
  18. const newObj = [].copyWithin.call(obj, 0, 2, 4); 
  19. /*
  20. {
  21.     0: 3,
  22.   1: 4,
  23.   2: 3,
  24.   3: 4,
  25.   4, 5,
  26.   lenght: 5
  27. }
  28. */
  30. obj === newObj // true

polyfill

Array.protoype.myCopyWithin = function(target){
  if(this == null){
      throw new TypeError('this is null or not defined');
  }

  var obj = Object(this), //变为一个对象引用值
      len = obj.length >>> 0, //保证是正整数,如果是非数字会为0
      start = arguments[1],
      end = arguments[2],
      count = 0,
      dir = 1;

  target = target >> 0; //保证是整数
  target = target < 0 ? 
                 Math.max(len + target, 0) : 
                     Math.min(target, len);

  start = start ? start >> 0 : 0;
  start = start < 0 ?
                Math.max(len + start, 0) :
                  Math.min(start, len);

  end = end ? end >> 0 : len;
  end = end < 0 ? 
            Math.max(len + end, 0) :
              Math.min(end, len);

    count = Math.min(end - start, len - target);

  if(start < target && target < (start + count)){
    dir = -1;
    start += count - 1;
      target += count - 1;
  }

  while(count){
    if(start in obj){
      obj[target] = obj[start];
    }else{
        delete obj[target];
    }

    start += dir;
    target += dir;
    count --;
  }

  return obj;
}