[js] Array方法polyfill

[wang1dot0]

1. Array.from

   if (!Array.from) {
   Array.from = function() {
   const toString = Object.prototype.toString;
   const toInteger = function(val) {
     const num = Number(val);
     if (Number.isNaN(num)) return 0;
     if (num === 0 || !Number.isFinite(num)) return num;
     return (num > 0 ? 1 : -1) * Math.floor(Math.abs(num));
   }
   const isCallable = function(fn) {
     return typeof fn === 'function' || toString.call(fn) === '[object Function]';
   }
   const maxSafeInteger = Math.pow(2, 53) - 1;
   const toLenghth = function(len) {
     return Math.min(Math.max(0, len), maxSafeInteger);
   }
   
   return function from(arrayLike) {
     const C = this;
     const items = Object(arrayLike);
     const mapFn = arguments.length > 1 ? arguments[1] : void undefined;
     if (typeof mapFn !== 'undefined') {
       if (arguments.length > 2) {
         T = arguments[2];
       }
     }
   
     const len = toLen(items.length);
     const A = isCallable(C) ? Object(new C(len)) : new Array(len);
   
     let loop = 0;
     let loopVal;
     while(loop < len) {
       loopVal = items[loop];
       if (mapFn) {
         A[loop] = typeof T === 'undefined' ? mapFn(item[loop], loop) : mapFn.call(T, item[loop], loop);
       } else {
         A[loop] = item[loop];
       }
       loop ++;
     }
   
     A.length = len;
   
     return A;
   }
   }
   }

2. Array.isArray

   if(!Array.isArray) {
   Array.isArray = function(args) {
   return Object.prototype.toString.call(arg) === '[object Array]';
   }
   }

3. Array.of

   if (!Array.of) {
   Array.of = function() {
   return Array.prototype.slice.call(arguments);
   };
   }

4. Array.prototype.fill

   if (!Array.prototype.fill) {
   Object.defineProperty(Array.prototype, 'fill', {
   value: function(value) {
     if (this == null) {
       throw new TypeError('this is null or not defined');
     }
   
     var O = Object(this);
   
     var len = O.length >>> 0;
   
     var start = arguments[1];
     var relativeStart = start >> 0;
   
     var k = relativeStart < 0 ?
       Math.max(len + relativeStart, 0) :
       Math.min(relativeStart, len);
   
     var end = arguments[2];
     var relativeEnd = end === undefined ?
       len : end >> 0;
   
     var final = relativeEnd < 0 ?
       Math.max(len + relativeEnd, 0) :
       Math.min(relativeEnd, len);
   
     while (k < final) {
       O[k] = value;
       k++;
     }
   
     return O;
   }
   });
   }