常见手写

深拷贝

/**
 * 判断是否是基本数据类型
 * @param value
 */
function isPrimitive(value) {
  return (
    typeof value === "string" ||
    typeof value === "number" ||
    typeof value === "symbol" ||
    typeof value === "boolean"
  );
}

/**
 * 判断是否是一个js对象
 * @param value
 */
function isObject(value) {
  return Object.prototype.toString.call(value) === "[object Object]";
}

/**
 * 深拷贝一个值
 * @param value
 */
function cloneDeep(value) {
  // 记录被拷贝的值，避免循环引用的出现
  let memo = {};

  function baseClone(value) {
    let res;
    // 如果是基本数据类型，则直接返回
    if (isPrimitive(value)) {
      return value;
      // 如果是引用数据类型，我们浅拷贝一个新值来代替原来的值
    } else if (Array.isArray(value)) {
      res = [...value];
    } else if (isObject(value)) {
      res = { ...value };
    }

    // 检测我们浅拷贝的这个对象的属性值有没有是引用数据类型。如果是，则递归拷贝
    Reflect.ownKeys(res).forEach((key) => {
      if (typeof res[key] === "object" && res[key] !== null) {
        //此处我们用memo来记录已经被拷贝过的引用地址。以此来解决循环引用的问题
        if (memo[res[key]]) {
          res[key] = memo[res[key]];
        } else {
          memo[res[key]] = res[key];
          res[key] = baseClone(res[key]);
        }
      }
    });
    return res;
  }

  return baseClone(value);
}

手写 instanceof

具体使用

instanceof 运算符用于检测构造函数的 prototype 属性是否出现在某个实例对象的原型链上。 判断一个实例是否是其父类或者祖先类型的实例。

var simpleStr = "This is a simple string";
var myString = new String();
var newStr = new String("String created with constructor");
var myDate = new Date();
var myObj = {};
var myNonObj = Object.create(null);

simpleStr instanceof String; // 返回 false，非对象实例，因此返回 false
myString instanceof String; // 返回 true
newStr instanceof String; // 返回 true
myString instanceof Object; // 返回 true

myObj instanceof Object; // 返回 true，尽管原型没有定义
({}) instanceof Object; // 返回 true，同上
myNonObj instanceof Object; // 返回 false，一种创建非 Object 实例的对象的方法

myString instanceof Date; //返回 false

myDate instanceof Date; // 返回 true
myDate instanceof Object; // 返回 true
myDate instanceof String; // 返回 false

具体实现

function instanceOf(target, type) {
  while (target) {
    if (Object.getPrototypeOf(target) === type.prototype) {
      return true;
    }
    target = Object.getPrototypeOf(target);
  }
  return false;
}

数组的 map 方法

实现

Array.prototype.map = function (fn, value) {
  let res = [];
  value = value || window;

  let arr = this;
  for (let i in arr) {
    if (arr.hasOwnProperty(i)) {
      res.push(fn.call(value, arr[i], i, arr));
    }
  }
  return res;
};

Array.prototype.myMap = function (fn, thisValue) {
  var res = [];
  thisValue = thisValue || [];
  this.reduce(function (pre, cur, index, arr) {
    return res.push(fn.call(thisValue, cur, index, arr));
  }, []);
  return res;
};

手写 reduce

实现

Array.prototype.myReduce = function (cb, initValue) {
  let _arr = this;
  let num = initValue == undefined ? _arr[0] : initValue;
  let i = initValue == undefined ? 1 : 0;
  for (i; i < _arr.length; i++) {
    num = cb(num, _arr[i], i, _arr);
  }
  return num;
};
let arr = [1, 2, 3, 4];
arr.myReduce(function (num, item, index, arr) {
  return num + item;
});