myCopyWithin.html

<script src="..\my-jsArrayMethods\simpletest.js"></script>
<script>
  // The copyWithin() method shallow copies part of an array 
    // into another location in the same array.
  // Returns the modified array, without modifying its size.

  // List of unfamaliar concepts to investigate later:
    // TypedArray constructor.
    // TypedArray.prototype.
    // TypedArray.prototype.copywithin.
    // ArrayBuffer object prototype.
    // DataView object prototype.
  
  // Parameters

    // target
      // Zero based index at which to copy the sequence to. 
        // If negative, target will be counted from the end.
        // If target is at or greater than arr.length, nothing will be copied. 
        // If target is positioned after start, the copied sequence will be trimmed to fit arr.length.
    // start Optional
      // Zero based index at which to start copying elements from. 
        // If negative, start will be counted from the end.
        // If start is omitted, copyWithin will copy from the start (defaults to 0).
    // end Optional
      // Zero based index at which to end copying elements from. 
      // copyWithin copies up to but not including end. 
      // If negative, end will be counted from the end.
      // If end is omitted, copyWithin will copy until the end (default to arr.length).

  // Return value
    // The modified array.

  Array.prototype.myCopyWithin = function(target, optionalStart, optionalEnd) {
    var arr = this;
    var originalArr = []; // to be used as temp storage during execution.
    var startIndex = optionalStart || 0;
    var endIndex = optionalEnd || arr.length;

    // copy values of input array into a temp stoarge variable.
    for (var i = 0; i < arr.length; i++) {
      // do not copy indexes containing holes.
      if (arr.hasOwnProperty(i)) {
        originalArr[i] = arr[i];
      }
    }
    
    if (target < 0) {
      target = arr.length + target;
    }
    if (target > arr.length || target < 0) {
      return arr;
    }
    
    // refactored to account for negative start index.
    if (startIndex < 0) {
      startIndex += arr.length;
    }

    // refactored to account for negative end index.
    if (endIndex < 0) {
      endIndex += arr.length;
    }
    
    // 2/22: refactored to ensure holes remain.
    for (var i = startIndex; i < endIndex; i++) { 
      if (target < arr.length) {
        // do not copy indexes that contain holes.
        if (originalArr.hasOwnProperty(i)) {
          arr[target] = originalArr[i];
        } else {
          delete arr[target];
        }
        target ++;
      }
    }

    return arr;
  
  }

  tests({
    '1. It should return the array unmodified if called without any arguments.': function() {
      var myArray = ['an element', 'a second element'];
      myArray.myCopyWithin();
      eq(myArray[0], 'an element');
      eq(myArray[1], 'a second element');
    },
    '1a. If no startIndex, it should return the array unmodified if passed target of 0.': function() {
      var myArray = ['an element', 'a second element'];
      myArray.myCopyWithin(0);
      eq(myArray[0], 'an element');
      eq(myArray[1], 'a second element');
    },
    '2. It should return the same array passed in, without modifying its size.': function() {
      var myArray = [1, 2, 3];
      var test = myArray.myCopyWithin(1);
      eq(myArray.length, test.length);
      eq(myArray.myCopyWithin(2, 1), myArray);
    },
    '3. If no optionalStart, it should copy array elements starting with index 0, and insert them beginning at arr[target].': function() {
      var myArray = [1, 2, 3];
      myArray.myCopyWithin(1);
      eq(myArray[0], 1);
      eq(myArray[1], 1);
    },
    '4. If no optionalEnd, it should default final copy index to array.length.': function() {
      var myArray = [1, 2, 3];
      myArray.myCopyWithin(1)
    },
    '5. If target is >= array.length, nothing should be copied.': function() {
      var myArray = [1, 2];
      myArray.myCopyWithin(2);
      eq(myArray[0], 1);
      eq(myArray[1], 2);
    },
    '6. If target is negative, it should insert the copied elements beginning at an index offset from end of the array.': function() {
      var myArray = [1, 2, 3];
      myArray.myCopyWithin(-1);
      eq(myArray[2], 1);
    },
    '7. If calculated target (positive or negative) is > array.length, nothing should be copied.': function() {
      var myArray = [1, 2];
      myArray.myCopyWithin(3);
      myArray.myCopyWithin(-4);
      eq(myArray[0], 1);
      eq(myArray[1], 2);
    },
    '8. If target is after startIndex, the copied sequence should be trimmed to fit array.length.': function() {
      var myArray = [1, 2, 3, 4];
      myArray.myCopyWithin(2, 1);
      eq(myArray.length, 4);
    },
    '9. If optionalStart, it should use this as index to begin copying elements.': function() {
      var myArray = [1, 2, 3];
      myArray.myCopyWithin(0, 1);
      eq(myArray[0], 2);
      eq(myArray[1], 3);
      eq(myArray[2], 3);
    },
    '10. It should work identically on bool, undefined, NaN, null data types.': function() {
      var myArray = ['string', 2, true, false, NaN, undefined, null];
      myArray.myCopyWithin(0, 2);
      eq(myArray[0], true);
      eq(myArray[1], false);
      eq(isNaN(myArray[2]), true);
      eq(myArray[3], undefined);
      eq(myArray[4], null);
    },
    // refactored to preserve holes: 2/22/19
    '11. It should preserve holes in the array.': function() {
      var holesArray = [0, , 2];
      holesArray.myCopyWithin(0, 1);
      eq(0 in holesArray, false);
    },
    // Original Test Modified
    '12. It should work generically on an object.': function() {
      var weirdObject = {length: 5, 3: 1};
      Array.prototype.myCopyWithin.call(weirdObject, 0, 3);
      eq(weirdObject[0], 1);
      eq(weirdObject[3], 1);
      eq(weirdObject.length, 5);
    },
    '13. It should work on nested arrays.': function() {
      var nestedArray = [['nested'], 'not nested', 3];
      nestedArray.myCopyWithin(2, 0);
      eq(Array.isArray(nestedArray[2]), true);
    },
    // test added: 2/21
    '14. If negative start index, it should be subtracted from array.length.': function() {
      var copied = [1, 2, 3, 4, 5].myCopyWithin(2, -2, 5);
      eq(copied[2], 4);
      eq(copied[3], 5);
      eq(copied[4], 5);
    },
    '15. If negative end index, it should be subtracted from array.length.': function() {
      var copied = [1, 2, 3, 4, 5].myCopyWithin(2, 1, -2);
      eq(copied[2], 2);
      eq(copied[3], 3);
      eq(copied[4], 5);
    }
  })
</script>