1.变量类型

  • 值类型vs引用类型
  • typeof运算符
  • 深拷贝

2.变量计算

值类型

  1. //值类型
  2. let a = 100
  3. let b = a
  4. a=200
  5. console.log(b)  //100

引用类型

  1. let a = {age:20}
  2. let b = a
  3. b.age =21
  4. console.log(a.age)  //21

常见的值类型

  1. let a //undefined
  2. const s = 'abc'
  3. const n = 100
  4. const b = true
  5. const s = Symbol('s')

常见的引用类型

  1. const obj = {x:100}
  2. const arr = ['a','b','c']
  3. const n = null //特殊引用类型，指针指向为空地址
  4. //特殊引用类型，但不用于存储数据，所以没有“拷贝、复制函数”这一说
  5. funcion fn(){}

3.typeof运算符

  • 识别所有的值类型
  • 识别函数
  • 判断是否是引用类型（不可再细分）

应用

识别所有的值类型

  1. let a;                      typeof a //undefined
  2. const s = 'abc';            typeof str//string
  3. const n = 100                                typeof n //number
  4. const b = true              typeof b //boolean
  5. const s = Symbol('s')       typeof s //symbol
  6. typeof console.log    //function
  7. typeof function(){}   //function
  8. //能识别引用类型（不能再继续识别）
  9. typeof null       //object
  10. typeof['a','b']   //object
  11. typeof {x:100}    //object

浅拷贝

  1. //浅拷贝   浅拷贝是指, 修改B对象的属性和方法会影响到A对象的属性和方法, 我们称之为浅拷贝
  2. const obj1  = {
  3.             age:20,
  4.             name:'xxx',
  5.             address:{
  6.                 city:'beijing'
  7.             },
  8.             arr:['a','b','c']
  9.         }
  10.          const obj2 =obj1
  11.          obj2.address.city = 'shanghai'
  12.          console.log(obj1.address.city)    //shanghai

深拷贝

  1.   //深拷贝   深拷贝是指, 修改B对象的属性和方法不会影响到A对象的属性和方法, 我们称之为深拷贝
  2.   function deepClone(obj = {}){
  3.             if(typeof obj !== 'object'  ||  obj ==null ){
  4.                 return obj;  //obj是null,或者不是对象或者数组
  5.             }
  6.             //初始化返回结果  
  7.             let result
  8.             if(obj instanceof Array){
  9.                 result= [];
  10.             }else{
  11.                 result = {}
  12.             }
  13.             for(let key in obj){
  14.               //保证key不是原型上的属性
  15.                 if(obj.hasOwnProperty(key)){
  16.                     result[key] = deepClone(obj[key])  //递归
  17.                 }
  18.             }
  19.             return result;
  20.         }
  21.         const obj2 = deepClone(obj1)
  22.         obj2.address.city = 'shanghai'
  23.         console.log(obj1.address.city)    //beijing

4.变量计算-类型转换

场景
  • 字符串拼接
  • ==
  • if语句和逻辑运算

应用

字符串拼接

  1. //字符串拼接
  2. const a = 100 +10        //110     
  3. const b = 100+'10'       //'10010'
  4. const c = true + '10'    //'true10'

==运算符

  1. 100 == ‘100’     //true
  2. 0 == ''          //true
  3. 0 == false       //true
  4. false == ''      //true
  5. null == undefined  //true 
  7. //除了==null之外，其他一律用 ===，例如：
  8. const obj = {x:100}
  9. if(obj.a == null){}
  10. //相当于 if(obj.a ===null || obj.a === undefined) {}

if语句和逻辑运算

truly变量：!!a === true的变量

falsely变量： !!a === false的变量

  1. !!0 === false
  2. !!NaN === false
  3. !!'' === false
  4. !!null == false
  5. !!undefined == false
  6. !!false === false
  8. //truly变量   走if逻辑
  9. const a = true
  10. if(a){ 
  11.     //...... 
  12. }  
  13. const b= 100
  14. if(b){
  15.     //.....
  16. }
  19. //falsely变量    不走if逻辑
  20. const c = ''
  21. if(c){
  22.     //...
  23. }
  24. const d = null
  25. if(d){
  26.     //...
  27. }
  28. let e
  29. if(e){
  30.     //...
  31. }

逻辑判断

  1. console.log(10 && 0)        //0
  2. console.log('' || 'abc')    //'abc'
  3. console.log(!window.abc)    //true

5.典型题

1.typeof能判断哪些类型

  • 识别所有值类型
  • 识别函数
  • 判断是否是引用类型（不可再细分）

2.何时使用==，何时使用===

  • 判断是否为null和undefined之外都用====

3.值类型和引用类型的区别

  • 值类型赋值改变赋值的值时原值不变
  • 引用类型赋值改变赋值的值时原值改变

4.深拷贝

  • 注意判断值类型和引用类型
  • 注意判断是数组还是对象
  • 递归