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)

 }

 // 用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

 }