手撕js中常见方法

array.fill

Array.prototype.fill2 = function (value, start, end) {
  const length = this.length; // 获取数组的长度
 
  start = start >> 0; // 将start转换为整数
  // 如果end参数未填写，则默认为数组的长度，否则将end转换为整数
  end = typeof end === 'undefined' ? length : end >> 0;
  // 将start限制在合法范围内，最小值为0，最大值为数组的长度
  start = start >= 0 ? Math.min(start, length) : Math.max(start + length, 0);
  // 将end限制在合法范围内，最小值为0，最大值为数组的长度
  end = end >= 0 ? Math.min(end, length) : Math.max(end + length, 0);
  // 使用指定的value填充从start到end范围内的数组索引
  while (start < end) {
    this[start] = value;
    start++;
  }
  // 返回被修改后的数组
  return this;
}

这段代码实现了一个自定义的fill2方法，用于在数组中指定的范围内填充指定的值。它接受三个参数：value表示要填充的值，start表示填充的起始索引，end表示填充的结束索引（不包含在内）。

在代码中，首先获取了数组的长度。然后对start和end参数进行处理，将它们转换为整数，并进行范围限制，确保它们在合法的范围内。接下来，使用一个循环从start索引开始，逐个将数组的元素设置为指定的value值，直到达到end索引为止。最后，返回被修改后的数组。

通过使用这个自定义的fill2方法，我们可以在数组中指定的范围内快速填充指定的值。 

array.map

Array.prototype.myMap = function (callbackFn, thisArg) {
  if (this == "undefined" || this == "null") {
    throw new TypeError("can not read property 'map' of undefined or null");
  }
  if (typeof callbackFn !== "function") {
    throw `${callbackFn} is not a function`;
  }
  let O = Object(this); // 将当前数组对象转换为对象类型
  let T = thisArg; // 设置回调函数的this值
  let len = O.length >>> 0; // 获取数组的长度
  let A = new Array(len); // 创建一个新的数组，用于存储映射后的值
  for (let k = 0; k < len; k++) {
    for (k in O) {
      let KValue = O[k]; // 获取当前索引的值
      let mapValue = callbackFn.call(T, KValue, k, O); // 调用回调函数进行映射操作
      A[k] = mapValue; // 将映射后的值存储到新数组中
    }
  }
  return A; // 返回映射后的新数组
}
 
let arr = [1, 2, 3, 4];
let arr2 = arr.myMap(function (currentValue, index, Array) {
  console.log(currentValue, index, Array);
  return currentValue + 1;
});
console.log(arr2);

    Array.prototype.myMap = function (callbackFn, thisArg) {
        if (this == "undefined" || this == "null") {
            throw new TypeError("can not read property 'map' of undefined or null")
        }
        if (typeof callbackFn !== "function") {
            throw `${callbackFn} is not a function`
        }
        let length = Object(this).length >>> 0
        let newArrray = []
        let i = 0
        while (i < length) {
            if (i in this) {
                //2. call修改了函数callbackFn的this指向，指向thisArg，后面的this还是指向的 arr，作为参数传给函数
                newArrray.push(callbackFn.call(thisArg, this[i],i,this))
            }
            i++
        }
        return newArrray
    }
 
    let arr = [1,2,3,4]
    // 1.绑定实例：用类实例对象去调用成员方法，此时this的指向为调用的实例对象  arr
    let arr2 = arr.myMap(function(currentValue,index,Array){
        // 3.此时的参数 currentValue,index,Array 对应2.传入的参数：this[i],i,this
        // 此时this为callbackFn的指向  this.Args  也就是 {message:"🐟"}
        console.log(currentValue,index,Array,this);
        return ++currentValue
    },{message:"🐟"})
    console.log(arr2);

节流函数

    function myThrottle(myFn,myDelay){
        let initState = true
        return function(...args){
            if(!initState) return
            initState = false
            setTimeout(() => {
                myFn.apply(this,args)
                initState = true
            }, myDelay);
        }
    }
 
    function mytest(arguments){
        console.log('test'+ arguments);  //testppp
    }
    const oneTest = myThrottle(mytest,500)
    oneTest('ppp')

防抖函数

    function debounce(fn,delay){
        var initWaitTime = null
        return function(...args){
            clearTimeout(initWaitTime)
            initWaitTime = setTimeout(() => {
                fn.apply(this,args)
            },delay)
        }
    }
 
    function testDebounce(){
        console.log('防抖');
    }
    const test4 = debounce(testDebounce,1000)
    console.log(test4);
    test4()
    test4()
    test4()

异步并发调度器Scheduler

    class Scheduler {
        constructor(max) {
            this.max = max
            this.count = 0
            this.queue = []
        }
        add(p) {
            this.queue.push(p)
            this.start()
        }
        start() {
            if (this.count >= this.max || !this.queue.length) return
            this.count++
            this.queue.shift()().finally(() => {
                this.count--
                this.start()
            })
        }
    }
 
    // 延迟函数
    const sleep = time => new Promise(resolve => setTimeout(resolve, time));
 
    // 同时进行的任务最多2个
    const scheduler = new Scheduler(2);
 
    // 添加异步任务
    // time: 任务执行的时间
    // val: 参数
    const addTask = (time, val) => {
        scheduler.add(() => {
            return sleep(time).then(() => console.log(val));
        });
    };
 
    addTask(1000, '1');
    addTask(500, '2');
    addTask(300, '3');
    addTask(400, '4');
// 2
// 3
// 1
// 4

class Scheduler {
  constructor(maxNum) {
    this.maxNum = maxNum; // 最大同时执行任务的数量
    this.count = 0; // 当前正在执行的任务数量
    this.taskList = []; // 任务列表，用于存储待执行的任务
  }
 
  addTask(time, val) {
    this.taskList.push([time, val]); // 将任务添加到任务列表中
  }
 
  start() {
    if (!this.taskList.length) return; // 如果任务列表为空，则直接返回
    if (this.count < this.maxNum) { // 如果当前正在执行的任务数量小于最大值
      const [time, val] = this.taskList.shift(); // 从任务列表中取出一个任务
      this.count++; // 增加正在执行的任务数量
      setTimeout(() => { // 使用setTimeout延迟执行任务
        console.log(val); // 打印任务的值
        this.count--; // 减少正在执行的任务数量
        this.start(); // 继续执行下一个任务
      }, time * 1000); // 将时间转换为毫秒，并设置延迟执行的时间
      this.start(); // 继续执行下一个任务
    }
  }
}

深拷贝函数：

    function deepClone(target, hashMap = new WeakMap()) {
 
 
        // 基本数据类型，直接返回
        if (typeof target !== "object" || target == null) {
            /* 
            函数，则调用函数并返回结果（虽然这里是同一个存储空间
            但是如果修改函数时，相当于重写函数，会自动分配堆内存存放新函数，也就是不会改变原函数)
            */
            if (target instanceof Function) return target.call(this, ...arguments);
            return target;
        }
 
        // 日期对象，则创建一个新的日期对象并返回
        if (target instanceof Date) return new Date(target);
 
        // 正则表达式对象，则创建一个新的正则表达式对象并返回
        if (target instanceof RegExp) return new RegExp(target);
 
        // 创建一个与目标对象构造函数相同的新对象
        let res = new target.constructor();
 
        // 如果哈希表中已经存在目标对象，则直接返回对应的新对象
        if (hashMap.get(target)) return hashMap.get(target);
 
        // 将新对象和目标对象存入哈希表中
        hashMap.set(res, target);
 
        // 遍历目标对象的属性
        for (let key in target) {
            // 递归调用深拷贝函数，复制目标对象的属性值，并赋值给新对象的对应属性
            res[key] = deepClone(deepClone(target[key], hashMap));
        }
 
        // 返回新对象
        return res;
    }