Jquery的深浅拷贝涉及到的知识点

1、安全的类型检测

　　Object.prototype.toString.call(obj) => "[object NativeConstructorName]"

 /**
  * 判断变量的类型
  * @param {*} obj 需要判断的变量
  * @return string "boolean/number/string/function/array/date/regExp/undefined/null/object"
  */
 function getType (obj) {
   const class2Type = {
     '[object Boolean]': 'boolean',
     '[object Number]': 'number',
     '[object String]': 'string',
     '[object Function]': 'function',
     '[object Array]': 'array',
     '[object Date]': 'date',
     '[object RegExp]': 'regExp',
     '[object Undefined]': 'undefined',
     '[object Null]': 'null',
     '[object Object]': 'object'
   }
   return class2Type[Object.prototype.toString.call(obj)] || 'object'
 }

2、判断一个对象是否是window对象

 // 判断obj是否是window对象
 function isWindow (obj) {
   return obj !== null && obj === obj.window
 }

3、判断一个对象是否是数组

 // 判断一个对象是否是数组
 function isArray (obj) {
   return Array.isArray ? Array.isArray(obj) : getType(obj) === 'array'
 }

4、判断一个对象自身属性中是否具有指定的属性，非继承的属性

　　Object.prototype.hasOwnProperty.call('propsName')

 o = new Object();
 o.prop = 'exists';
 o.hasOwnProperty('prop');             // 返回 true
 o.hasOwnProperty('toString');         // 返回 false
 o.hasOwnProperty('hasOwnProperty');   // 返回 false

 // 判断一个对象是否是纯粹的对象(通过 "{}" 或者 "new Object" 创建的)
 function isPlainObject (obj) {
   // Object的hasOwnProperty()方法返回一个布尔值，判断对象是否包含特定的自身（非继承）属性,true表示是自身的属性
   const hasOwn = Object.prototype.hasOwnProperty

   // 不拷贝非对象、DOM对象、window对象
   if (!obj || getType(obj) !== 'object' || obj.nodeType || isWindow(obj)) {
     return false
   }
   try {
     // Not own constructor property must be Object
     if (obj.constructor &&
         !hasOwn.call(obj, 'constructor') &&
         !hasOwn.call(obj.constructor.prototype, 'isPrototypeOf')) {
       return false
     }
   } catch (e) {
     // IE8,9 Will throw exceptions on certain host objects #9897
     return false
   }

   // Own properties are enumerated firstly, so to speed up,
   // if last one is own, then all properties are own.
   var key
   for (key in obj) {}

   return key === undefined || hasOwn.call(obj, key)
 }

5、深浅拷贝

 // 用JQ中的extend的方法来进行对象的深浅拷贝
 export function merge () {
   let options
   let name
   let src
   let copy
   let copyIsArray
   let clone
   let target = arguments[0] || {} // 获取第一个参数的值
   let i = 1
   let length = arguments.length // 获取传入参数的个数
   let deep = false // 深浅拷贝标识，true表示深拷贝，false表示前拷贝

   // 判断第一个参数是否是boolean值，如果是，那么应该从第3个参数开始进行深拷贝，否则进行浅拷贝
   // merge(deep,target,source1,source2...)
   if (typeof target === 'boolean') {
     deep = target
     i = 2
     target = arguments[1] || {} // 获取目标源
   }

   // 对目标源target进行判断
   if (typeof target !== 'object' && getType(target) !== 'function') {
     target = {}
   }

   // 如果只传入两个参数，没有源数据
   // merge(true,{})
   if ( length === i ) {
         --i;
     }

   for (; i < length; i++) {
     // 处理非空的源参数
     if ((options = arguments[i]) !== null) {
       // 获取源参数中的key值
       for (name in options) {
         // 通过key值获取目标源和源中的值
         src = target[name]
         copy = options[name]

         // 避免死循环
         if (target === copy) {
           continue
         }
         // 深拷贝，只拷贝纯粹的obj或者数组
         if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
           // 拷贝的是数组
           if (copyIsArray) {
             copyIsArray = false
             clone = src && isArray(src) ? src : []
           } else {
             clone = src && isPlainObject(src) ? src : {}
           }
           target[ name ] = merge(deep, clone, copy)
         } else if (copy !== undefined) {
           target[ name ] = copy
         }
       }
     }
   }
   return target
 }

PS：使用JSON.stringify()和JSON.parse()也可以实现深拷贝，也可以使用JSON.stringify来判断两个对象是否相等。