手写一下数组去重四种方案和防抖节流

一.数组去重

1.第一种是采用双层for循环，给新数组值，然后遍历对比这个数值在原数组有没有

// 数组去重 第一种
function unique(arr) {
  if (!Array.isArray(arr)) {
    console.log("type error!");
    return;
  }
  const res = [arr[0]];
  for (let i = 1; i < arr.length; i++) {
    let flag = true;
    for (let j = 0; j < res.length; j++) {
      if (arr[i] === res[j]) {
        flag = false;
        break;
      }
    }
    if (flag) {
      res.push(arr[i]);
    }
  }
  return res;
}
const res1 = unique([1, 2, 55, 7, 8, 8, 8, 6, 74]);
console.log(res1);

2.第二种是利用数组里的api indexOf，定义元素首次出现的位置，然后把对应的值给到新数组

// 数组去重 第二种
function unique(arr) {
  if (!Array.isArray(arr)) {
    console.log("type err");
    return;
  }
  const res = [];
  for (let i = 0; i < arr.length; i++) {
    if (res.indexOf(arr[i]) === -1) {
      // indexOf 定义元素首次出现的位置
      res.push(arr[1]);
    }
  }
  return res;
}

3.第三种是先对数组进行排序，然后判断前后元素是否相同

// 数组去重 第三种
function unique(arr) {
  if (!Array.isArray(arr)) {
    console.log("type err");
    return;
  }
  arr = arr.sort();
  let res = [];
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] !== arr[i - 1]) {
      res.push(arr[i]);
    }
  }
  return res;
}

4.第四种用ES6 新增的set 判断是否是唯一值

//数组去重  第四种
function unique(arr) {
  if (!Array.isArray) {
    console.log("type err");
    return;
  }
  return Array.from(new Set(arr));
}

二、防抖节流

防抖：通过定时器实现

function debounce(fn, wait) {
    let timeout

    return function() {
        let args = arguments
        let context = this
        clearTimeout(timeout)
        timeout = setTimeout(()=>{
            fn.apply(context,args)
        }, wait)
    }
}

节流：通过是时间戳 或者 设置节流阀

function throttle(fn, delay) {
  let prev = null;
  return function () {
    let args = arguments;
    let now = Date.now();
    if (now - prev >= delay) {
      fn.apply(this, args);
      prev = now;
    }
  }
}