function deepClone (param) {
// 一开始生成新的数组或者对象
const objOrArrCreate = param.constructor === Array ? [] : {}
// 判断param里面的参数是引用类型还是基本类型
for (let key in param) {
if (param.hasOwnProperty(key)) {
// 如果是引用类型，则递归深拷贝
if (param[key] && typeof param[key] === 'object') {
// const objOrArrCreate[key] = param[key].constructor === 'Array' ? [] : {}
objOrArrCreate[key] = deepClone(param[key])
} else {
objOrArrCreate[key] = param[key]
}
}
}
return objOrArrCreate[key]
}
// typeof 它能准确判断出的数据类型有：Number，String，Boolean，Undefined，Symbol，BigInt，Function
// typeof：检测基础数据类型和函数很好用
console.log(typeof '1') // string
console.log(typeof 1) // number
console.log(typeof NaN) // number
console.log(typeof true) // boolean
console.log(typeof []) // object
console.log(typeof {}) // object
console.log(typeof null) // object
console.log(typeof undefined) // undefined
console.log(typeof function(){}) // function
// constructor：返回实例对象的构造函数
// constructor 是返回该数据类型的原型方法，所以不用 === 'String' 不是判断字符串
let constructorTemp = '1'
console.log(constructorTemp.constructor) // function String() { [native code] }
console.log(constructorTemp.constructor === String)
constructorTemp = 1
console.log(constructorTemp.constructor) // function Number() { [native code] }
constructorTemp = true
console.log(constructorTemp.constructor) // function Boolean() { [native code] }
constructorTemp = []
console.log(constructorTemp.constructor) // function Array() { [native code] }
constructorTemp = {}
console.log(constructorTemp.constructor) // function Object() { [native code] }
// null和undefined没有constructor
// null，undefined 没有构造函数，自然也就访问不到该属性，因此不能使用此属性来判断
// constructor 可以被改写，所以不一定准确
// instanceof：沿着原型链去找
// 不能检测基本数据类型
// 原型链可能被修改，导致检测结果不准确
// 只要能在原型链上找到构造函数，就返回 true，所以类型可能不准确
// *******instanceof关键字判断数据类型可以判断由构造方式创建的基本数据
let instanceofTemp = '1'
console.log(instanceofTemp instanceof String) // function String() { [native code] }
instanceofTemp = 1
console.log(instanceofTemp instanceof Number) // function Number() { [native code] }
instanceofTemp = true
console.log(instanceofTemp instanceof Boolean) // function Boolean() { [native code] }
instanceofTemp = []
console.log(instanceofTemp instanceof Array) // function Array() { [native code] }
instanceofTemp = {}
console.log(instanceofTemp instanceof Object) // function Object() { [native code] }
instanceofTemp = new String('222')
console.log(instanceofTemp instanceof String, instanceofTemp) // function String() { [native code] }
// 看名字它是用来将一个值转为字符串的，但其实并不是，它是一个专门检测数据类型的方法。
// 它返回的值是一个形如 [object Object] 的字符串，比如：
console.log(toString.call('123')) // [object String]
console.log(toString.call(null)) // [object Null]
console.log(toString.call(true)) // [object Boolean]
console.log(toString.call({})) // [object Object]
console.log(toString.call([])) // [object Array]
console.log(toString.call(function(){})) // [object Function]
console.log(toString.call(new Map)) // [object Map]
console.log(toString.call(new WeakSet)) // [object WeakSet]
// 通常会编写一个函数，对返回的字符串从第8位做一个截取，截取到倒数第一位，再去做类型比较。
// Symbol.toStringTag：自定义类型
// 上面的 Object.prototype.toString 方法，之所以对不同的数据类型，返回不同的标识字符串，
// 就是因为 Symbol.toStringTag 。
// Symbol.toStringTag 是一个内置符号属性，
// 它的值是一个字符串，用于表示一个对象的默认描述，
// 也就是调用 Object.prototype.toString 会返回的内容，比如：
let obj = {}
obj[Symbol.toStringTag] = 'ABC'
console.log(Object.prototype.toString.call(obj)) // [object ABC]
// 对于自定义对象，调用上面的方法，都只会返回 [object Object]。此时就可以使用 Symbol.toStringTag
// 来指定一个确定的类型了，比如：
class Person{
get[Symbol.toStringTag](){
return 'Person'
}
}
let person = new Person()
console.log(Object.prototype.toString.call(person)) // [object Person]
// 作者：昆吾kw
// 链接：https://juejin.cn/post/7175905067843715127
// 来源：稀土掘金
// 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
// Object.prototype.isPrototypeOf：和 instanceof 类似
// isPrototypeOf 和 instanceof 类似，
// 都是基于原型链和原型对象去做判断的。它用来检查一个对象是否存在于另一个对象的原型链上。
function Person() {
}
let person = new Person()
console.log(Person.prototype.isPrototypeOf(person))
console