Typeof

变量类型和计算
-
题目：

-typeof 能判断哪些类型

-何时使用=== 和==

-值类型和引用类型的区别

-手写深拷贝

知识点：

值类型和引用类型

let a = 100
let b = a
a = 200
console.log(b)

//引用类型

let a = {age:20}
let b = a 
b.age =21
console.log(a.age)

对于对象，是a指向了内存地址1，内存地址1是{age：20}，接下来也是给b指向了内存地址1，所以当b.age更改为21的时候，a.age也会更改

常见值类型

let a // undefined; 
const s = 'abc' 
const n = 100
const b = true
const s = Symbol('s')

常见引用类型

const obj ={x :100}
const arr =['a','b','c']
const n = null //特殊引用类型，指针指向为空地址
// 特殊引用类型，但是不用于存储数据，所以没有‘拷贝复制函数’这一说

Typeof 运算符

识别所有值类型

识别函数

判断是否是引用类型(不可以再细分)

//判断所有值类型
 let a;   typeof a   //'undefined'
 const str = 'abc'  typeof str  //'string'
 const n = 100; typeof n  // 'number'
 const b = true  typeof b  //'boolean'
 const s =Symbol('s');  typeof s //'Symbol'

//判断函数
typeof console.log //'function'
typeof function (){} // 'function'

   //能识别引用类型(不能再继续识别)
typeof null //'object'
typeof ['a','b'] //'object'
typeof {x : 100}  //'object'

深拷贝，考点：递归

<!DOCTYPE html>
    <html lang="en">
        <head>
            <meta  http-equiv="Contect-Type" charset="utf-8">
            <title>deepclone</title>
        </head>
        <body>
        </body>
        <p>deepclone</p>
        <script>
            const obj1={
                age:20,
                name:'James',
                address:{
                   city:'Chengdu',
                   street:'Zhonghe'
                },
                arr :['a','b','c','d']
            }
            const obj2 =deepClone(obj1)

            obj2.address.city ='shanghai';
            console.log(obj1.address.city);
            console.log('deepClone');
            function deepClone(obj={}){
                if(typeof obj !== 'object'|| obj == null){
                // obj  is  null, just return 
                   return obj
                }
                    //初始化返回结果
                    let result
                    if(obj instanceof Array){
                        result =[]
                    }else {
                        result ={}
                    }
                    for(let key in obj){
                        if(obj.hasOwnProperty(key)){
                            //保证Key不是原型的属性,递归
                            result[key] =deepClone(obj[key])
                        }
                    }

                return result
            }

            </script>
        </html>

所谓深拷贝就是拷贝的对象的具体内容，其内容地址是自助分配的，拷贝结束之后，内存中的值是相同的，但是内存地址是不一样的，所以两个对象之间相互不影响，也不干涉

字符串拼接
‘==’
if语句和逻辑运算

字符串拼接 +

const a =100 +10  //110
const b =100+'10' //'10010'
const c =true +'10' // 'true10'

==运算符通过发生转换去相等

100 == '100' //true
0 ==' '   //true
0 == false //true
false ==' ' //true
null == undefined // true

//除了 == null 之外，其他都用===

const obj ={x : 100}
if (obj.a == null){}
//if（obj.a===null|| obj.a===undefined）

if语句和逻辑运算符

truly变量 !!a === true 的变量
falsely变量 !!a === false 的变量

//以下是falsely变量，初次之外都是truly变量
!!0 === false
!!NaN === false
!!'' === false
!!null === false
!!undefined === false
!!false === false

if语句里
//truly 变量
const a = true
if(a){
    //...
}
const b = 100
if(b){
    //...
}

//falsely变量
const c = ''
if(c){
    //
}
const d = null
if(d){
//
}
let e
if(e){
    //
}

逻辑判断

console.log(10 && 0) //0
console.log(''||'abc') //'abc'
console.log(!windows.abc) //true