bfe.dev刷题记录

1.柯里化实现

function curry(fn) {
  return function innerFun(...args) {
    //判断是否收集完参数
    if (args.length >= fn.length) {
      //没有收集完
      return fn.apply(this, args);
    } else {
      return function (...args2) {
        //收集参数
        return innerFun(...args, ...args2);
      };
    }
  };
}

 另一种实现方式，箭头函数。

const curry = (fn, ...args) => 
    // 函数的参数个数可以直接通过函数数的.length属性来访问
    args.length >= fn.length // 这个判断很关键！！！
    // 传入的参数大于等于原始函数fn的参数个数，则直接执行该函数
    ? fn(...args)
    /**
     * 传入的参数小于原始函数fn的参数个数时
     * 则继续对当前函数进行柯里化，返回一个接受所有参数（当前参数和剩余参数） 的函数
    */
    : (..._args) => curry(fn, ...args, ..._args);

2.实现array.flat

思路：递归，累加

const flat = (arr, level) => {
  if (level == 0) return arr;
  return arr.reduce((pre, cur) => {
    if (Array.isArray(cur) && level > 0) {
      return pre.concat(flat(cur, level - 1));
    } else { 
      return pre.concat(cur);
    }
  }, []);
};

 3.throttle 实现

基本，无拓展实现

const throttle = (fn, delay) => {
  let timer = null;
  return function (...args) {
    if (!timer) {
      // 立即执行一次
      fn.apply(this, args);
      // 设置定时器，在延迟时间后清除定时器
      timer = setTimeout(() => {
        timer = null;
      }, delay);
    }
  };
};

本题目中你需要实现一个增强的throttle()，使其支持第三个参数option: {leading: boolean, trailing: boolean}

leading: 是否立即执行

trailing: 是否在冷却后执行

增强实现思路：1.第一次执行加入leading的判断 2.冷却后执行：指的是定时器结束时，需要执行上次被打断的执行，这里需要记录上一次的this

const throttle = (fn,delay,options = { leading: true, trailing: true }) => {
    const { leading, trailing } = options;
    let timer = null;
    let lastArgs = null
    let lastThis = null
    return function (...args) {
        //立即执行判断
        if(!timer && leading){
            fn.apply(this,args);
            
        }else{
           lastArgs = args
            lastThis = this
        }
        if(timer) return
        timer = setTimeout(()=>{
            if(trailing && lastArgs){
                //执行完后需要清空已存的内容
            fn.apply(lastThis,lastArgs)
            lastArgs = null
            lastThis = null
            }
        timer = null
        },delay)
        
    }
27 }

4.debounce 实现

const debounce = (fn, delay) => {
  let timer = null; // 用于保存定时器

  return function (...args) {
    // 如果已经有定时器，清除之前的定时器
    if (timer) {
      clearTimeout(timer);
    }

    // 设置新的定时器
    timer = setTimeout(() => {
      // 在延迟时间结束后执行函数
      fn.apply(this, args);
      // 重置 timer 为 null，允许下一次调用
      timer = null;
    }, delay);
  };
};

增强，实现立即执行和冷却执行，冷却执行的意思是在定时器结束时执行

const debounce = (fn, delay, options = { leading: true, trailing: true }) => {
  const { leading, trailing } = options;
  let timer = null; // 定时器
  let isLeadingCalled = false; // 标记 leading 是否已经执行

  return function (...args) {
    // 如果 leading 为 true，且没有定时器，立即执行
    if (leading && !timer) {
      fn.apply(this, args);
      isLeadingCalled = true; // 标记 leading 已执行
    } else {
      isLeadingCalled = false; // 重置标记
    }

    // 清除之前的定时器
    if (timer) {
      clearTimeout(timer);
    }

    // 设置新的定时器
    timer = setTimeout(() => {
      // 如果 trailing 为 true，且 leading 未执行过，执行最后一次调用
      if (trailing && !isLeadingCalled) {
        fn.apply(this, args);
      }

      // 重置定时器和标记
      timer = null;
      isLeadingCalled = false;
    }, delay);
  };
};

5.洗牌算法 我自己的实现，时间复杂度O(n²)

function shuffle(arr) {
  const result = [];
  let len = arr.length;

  while (len--) {
    // 生成均匀的随机索引
    const randomIndex = Math.floor(Math.random() * len);
    // 使用 splice 删除该索引的元素，并添加到结果中
    result.push(arr.splice(randomIndex, 1)[0]);
    11   }

  return result;
}

标准答案，一次遍历交换

　　　　从前向后
　　　function shuffle(arr) {
  for (let i = 0; i < arr.length; i++) {
    // 随机生成一个索引（i 到 arr.length - 1）
    const j = Math.floor(Math.random() * (arr.length - i)) + i;
    // 交换 arr[i] 和 arr[j]
    [arr[i], arr[j]] = [arr[j], arr[i]];
  }
  return arr;
}

为什么从后向前遍历更好

Fisher-Yates 洗牌算法通常从后向前遍历数组，原因如下：

1. 随机索引的范围：

   • 在每次迭代中，随机索引的范围是 [0, i]，其中 i 是当前索引。

   • 这样可以确保每个元素都有机会被交换到任何位置。

2. 概率均匀：

   • 从后向前遍历时，每个元素被交换到当前位置的概率是均匀的。

   • 例如，最后一个元素 arr[n-1] 可以被交换到任何位置（包括它自己的位置）。

   • 这样可以保证每个元素被选中的概率一致。

3. 逻辑简单：

   • 从后向前遍历的逻辑更简单，代码更容易理解和实现。

function shuffle(arr) {
  // 从后向前遍历数组
  for (let i = arr.length - 1; i > 0; i--) {
    // 随机生成一个索引（0 到 i）
    const j = Math.floor(Math.random() * (i + 1));
    // 交换 arr[i] 和 arr[j]
    [arr[i], arr[j]] = [arr[j], arr[i]];
  }
  return arr;
}

6.解密消息 有点类似z字型变换 ，同时考虑不规则数组，感觉这个也不需要考虑

const caesarDecrypt = (arr) => {
  //最长宽度
  let row = arr.length;
  let col = 0;
  let res = [];
  arr.forEach((element) => {
    col = Math.max(col, element.length);
  });
  let j = 0;
  for (let i = 0; i < col; i++) {
    if (arr[j][i] !== undefined) {
      if (j < row-1) {
        res.push(arr[j][i]);
        j++;
      } else {
        res.push(arr[j][i]);
        j--;
      }
    }
  }
  return res.join(",");
};

 7.实现instanceof

const chain = (L, R) => {
  while (L !== null) {
    if (L.__proto__ == R.prototype) {
      return true;
    }
    L = L.__proto__;
  }
  return false;
};
// 更推荐使用 Object.getPrototypeOf() 来访问原型。 Object.getPrototypeOf(L) === R.prototype

8.实现new操作符

const myNew = (fn, ...args) => {
  let obj = Object.create(fn.prototype);
  let res = fn.apply(obj, args);
  return res instanceof Object ? res : obj;
};

解释为什么最后的返回值需要判断res是否是对象实例

• 构造函数返回对象：

  • 如果构造函数显式地返回了一个对象，JavaScript 会认为你想要使用这个对象作为 new 表达式的结果。这种行为允许构造函数返回一个预先创建的对象，而不是默认创建的新对象。

• 构造函数不返回对象：

  • 如果构造函数没有返回对象（或者返回了原始值），JavaScript 会忽略这个返回值，并返回默认创建的新对象 obj。这是大多数情况下 new 操作符的行为。

 new操作可能会对null,undefined等非引用对象进行操作，所以需要判断类型

 

9.dfs bfs