Javascript中的基本数据类型，如何判断数据类型，作用域链的理解

            typeof 1  // numbertypeof ‘a‘ //  stringtypeoffalse// boolean
typeof undefined  // undefinedtypeof [] // objecttypeof {} // objecttypeofnull// object
const a = function(){}

typeof a // function typeofnew Set()  // objecttypeofnew Map() // objecttypeof Symbol // functiontypeof Symbol() // symbol

            new Number(1) instanceof Number // truenew String(‘str‘) instanceof String  // true new Boolean(false) instanceof Boolean // true
[] instanceof Array // true
{} instanceof Object // true
console.log instanceof Function // true
console.log instanceof Function // true
new Map() instanceof Map // true
new Set() instanceof Set() // true

            function
             getType(param) {
    
            if( arguments.length === 0 ) {
         return ‘请传入参数‘
    }

    if(param === null) {
         return ‘null‘
   }

    const type = typeof param 
    
    if( type !== ‘object‘) { // 基本类型数据或symbol或functionreturn type
    } else { // 引用类型
       if(param instanceof  Array){
          return ‘array‘
       } elseif(param instanceof Set ) {
           return ‘set‘
       } elseif(param instanceof Map) {
           return ‘map‘
       } else if(param instanceof Object) {
           return ‘object‘
       }
    }
}

getType(1) // number
getType(‘a‘) // string
getType(false) // boolean
getType([]) // array
getType(null) // null
getType(undefined) // undefined
getType({}) // object
getType(new Set()) // set
getType(new Map())  // map
getType(Symbol())  // symbol
getType(Symbol) // function
getType(console.log)  // function

const num = new Number(1) 

typeof num // ‘object‘typeof Number(1) //  number
num.__proto__ === Number.prototype

// Number.ptototype 下有多个方法 valueOf, toString,toFixed等，实际上对数字调用这些方法其实是调用Number.prototype上的方法
num.toString() //  1
Number(1) === 1

Number(1) === new Number(1)  // false 
Number(1) == new Number(1)  // true

1.toSting()  // 该方法会报错，因为JS无法分别.是小数点还是操作符
正确做法是 const a = 1, a.toString()

或者1[‘toString‘]()

或者(1).toString()
 

const  bol = new Boolean(false) 

console.loog(bol) // Boolean{false}typeof bol // ‘object‘typeof Boolean(false) // ‘boolean‘
Boolean(false) === false// true
Boolean(false) === new Boolean(false) // false
Boolean(false) == new Boolean(false) // true
bol上同样有一个__proto__属性，指向Boolean.prototype，上面有valueOf, toString,constructor三个属性

const str = new String(‘str‘)

console.log(str) // String{0： ‘s‘, 1: ‘t‘, 2: ‘r‘}
String(‘str‘) === ‘str‘ // true
String(‘str‘) === str // false 
String(‘str‘) ==  str // true
str[0] === String(‘str‘)[0]

str实际上是一个对象，该对象中有三个属性，还有长度属性，

str.__proto__ === String.prototype 

String(‘str‘).__proto__ === String.prototype

const num = 1

const str = ‘a‘

const bol = false

const obj = {}

const arr = []

const sym = new Symbol(）

const set = new Set()

const map = new Map()

const fun = function() {}

num.__proto__  ===  Number.prototype // true
str.__proto__ === String.prototype // true
bol.__proto__ == Boolean.prototype // true
obj.__proto__ == Object.prototype // true
arr.__proto__ === Array.prototype // true
sym.__proto__ === Symbol.prototype // true

map.__proto__ === Map.prototype // true
set.__proto__ === Set.prototype // true
fun.__proto__ === Function.prototype // true

Number.__proto__ === Function.prototype

Boolean.__proto__ === Function.prototype

String.__proto__ === Function.prototype

Array.__proto__ === Function.prototype

Map.__proto__ === Function.prototype

Set.__proto__ === Function.prototype

Symbol.__proto__ === Function.prototype

// 也就是说所有构造函数的原型，最终指向Function的显式原型对象
那么Function.__proto__ 会指向谁呢，
因为Function本事也属于构造函数，他的隐式原型，当然指向自身的显示原型对象

Function.__proto__ === Function.prototype

const obj = {}

实际上相当于

const obj = new Object()

那么

obj.__proto__ === Object.prototype

最终问题来了，构造函数的显式原型对象，本身也是一个对象，他的__proto__会指向哪里呢？

结果是

除了Object构造函数以外，任意构造函数的显式原型属性的__proto__，都指向Object.prototype

也就是说
Array.prototype.__proto__ === Object.prototype

Number.prototype.__proto__ === Object.prototype

所有其他数据Boolean, Set, Map, Symbol, Promise等类型同理

特殊的
Function.prototype.__proto__ === Object.prototype

而原型链的顶端：

Object.prototype.__proto__ ===  null

因为对象的显式原型对象也是一个对象，也该指向Object.prototype，
单位了防止死循环，就把Object.prototype.__proto__ 指向了null, 也就到达了
原型链的最顶端

            function
             Animal() {
    
            this.name = ‘猫‘
}

Animal.name = ‘狗‘

Function.prototype.name1 = ‘猪‘

Object.prototype.name2 = ‘羊‘

const animal = new Animal()

console.log(animal.name ,animal.name1, animal.name2) // 猫， undefined, 羊