开发中常用的函数

防抖

函数防抖(debounce)，指的是短时间内多次触发同一事件，只执行最后一次

/**
 * 函数防抖
 * @param {function} func 一段时间后，要调用的函数
 * @param {number} wait 等待的时间，单位毫秒
 */
function debounce(func, wait){
    // 设置变量，记录 setTimeout 得到的 id
    let timerId = null;
    return function(...args){
        if(timerId){
            // 如果有值，说明目前正在等待中，清除它
            clearTimeout(timerId);
        }
        // 重新开始计时
        timerId = setTimeout(() => {
            func(...args);
        }, wait);
    }
}

节流

函数节流(throttle)，指连续触发事件但是在 n 秒中只执行一次函数。即 2n 秒内执行 2 次... 。节流如字面意思，会稀释函数的执行频率。

/** 
* 函数节流 
* @param {function} func 一段时间内，要调用的函数 
* @param {number} wait 等待的时间，单位毫秒 
*/
function throttle(func, wait) {
    let context, args;
    let previous = 0;
    return function () {
        let now = +new Date();
        context = this;
        args = arguments;
        if (now - previous > wait) {
            func.apply(context, args);
            previous = now;
        }
    }
}

js 判断是否是数字

!isNaN(parseFloat(value)) && isFinite(value);

输出对称数字

思路: 对称数字,反转跟原来的值相比没有变化

function isSymmetryNum(start, end) {
    for (var i = start; i < end + 1; i++) {
        var iInversionNumber = +(i.toString().split("").reverse().join(""));

        if (iInversionNumber === i && i > 10) {
            console.log(i);
        }

    }
}
isSymmetryNum(1, 10000);

判断一个数据是否是可枚举还是可迭代

在 JavaScript 中，你可以使用以下方法来检查一个对象的属性是否可枚举，以及一个对象是否可迭代：

1. 检查属性是否可枚举：
   你可以使用 Object.getOwnPropertyDescriptor 方法来获取对象的属性描述符，并检查 enumerable 属性来确定属性是否可枚举。例如：

```javascript
const obj = {a: 1, b: 2};

console.log(Object.getOwnPropertyDescriptor(obj, 'a').enumerable); // true
console.log(Object.getOwnPropertyDescriptor(obj, 'toString').enumerable); // false (built-in method)

在这个例子中，我们使用 Object.getOwnPropertyDescriptor 方法获取了对象 obj 的属性描述符，并通过 enumerable 属性来检查属性是否可枚举。

2. 检查对象是否可迭代： 你可以使用 Symbol.iterator 来检查一个对象是否可迭代。例如：

function isIterable(obj) {
  return typeof obj[Symbol.iterator] === 'function';
}

console.log(isIterable([])); // true (数组是可迭代的)
console.log(isIterable({})); // false (普通对象不是可迭代的)

在这个例子中，我们定义了一个 isIterable 函数，它检查对象是否具有 Symbol.iterator 方法，如果有，则表示对象是可迭代的。

通过这些方法，你可以检查一个对象的属性是否可枚举，以及一个对象是否可迭代。

实现 LRU 缓存

什么是LRU缓存？
LRU缓存是一种缓存淘汰策略，它的全称是Least Recently Used，意思是最近最少使用。它的原理是认为最近使用过的数据应该是有用的，而很久没用过的数据应该是无用的，所以当缓存满了时，就优先删除那些很久没用过的数据，给新数据腾出空间。
那么我们用Map实现一下LRU缓存

class LRUCache {
  constructor(capacity) {
    this.capacity = capacity; // 缓存容量
    this.map = new Map(); // 使用Map存储键值对
  }

  // 获取键对应的值，如果不存在则返回 -1
  get(key) {
    if (this.map.has(key)) {
      let value = this.map.get(key);
      this.map.delete(key); // 删除该键值对
      this.map.set(key, value); // 将该键值对重新插入到Map末尾，表示最近使用过
      return value;
    } else {
      return -1;
    }
  }

  // 设置或更新键和值，如果超过缓存容量，则删除最久未使用的键值对
  put(key, value) {
    if (this.map.has(key)) {
      this.map.delete(key);
    } else if (this.map.size >= this.capacity) { // 如果Map中没有该键，且已达到缓存容量上限
      let oldestKey = this.map.keys().next().value; // 获取Map中第一个（最久未使用）的键
      this.map.delete(oldestKey);
    }
    this.map.set(key, value); // 将新的或更新的键值对插入到Map末尾，表示最近使用过 
  }
}