js温习回顾（一）

对象（Object）类型

function test(person) {//函数传参，传递的是对象的指针副本
  person.age = 26
  person = {//p1作为入参，此时重新赋值
    name: 'yyy',
    age: 30
  }

  return person
}
const p1 = {
  name: 'yck',
  age: 25
}
const p2 = test(p1)
undefined
p2
{name: "yyy", age: 30}
p1
{name: "yck", age: 26}//震惊！！

typeof 是否能正确判断类型？不能

typeof console.log
"function"
typeof null
"object" //null:指向空对象的指针，{}才是空对象

（已声明但未赋值是：undefined）

instanceof 能正确判断对象的原理是什么？ 内部机制是通过原型链来判断的

A instanceof B :B是否在A的原型链上

闭包：函数 A 内部有一个函数 B，函数 B 可以访问到函数 A 中的变量，那么函数 B 就是闭包。

for (var index = 0; index < 5; index++) {
  console.log(index); 
}
VM138:2 0
VM138:2 1
VM138:2 2
VM138:2 3
VM138:2 4

for (var i = 1; i <= 5; i++) {
  setTimeout(function timer() {
    console.log(i)//因为 setTimeout 是个异步函数，所以会先把循环全部执行完毕
  },1000)
} 
5VM179:3 6

解决方案一：

for (var i = 1; i <= 5; i++) {
 (function(j){
  setTimeout(function timer() {
    console.log(j)
  }, j * 1000)
 })(i) //使用立即执行函数，将i绑定到函数内部
}
undefined
VM184:4 1
VM184:4 2
VM184:4 3
VM184:4 4
VM184:4 5

解决方案二：

for (var i = 1; i <= 5; i++) {
  setTimeout(
    function timer(j) {
      console.log(j)
    },
    i * 1000,
    i   //将i作为参数传入setTimeout的第一个参数
  )
}

解决方案三：

for (let i = 1; i <= 5; i++) { //let有块级作用域
  setTimeout(function timer() {
    console.log(i)
  }, i * 1000) 
}

回顾： var： 1存在变量提升 2无块级作用域 3可重复声明

if(1){
  var a=2
}
console.log(a);
VM237:4 2

let: 1无变量提升 2有块级作用域 3可重复声明

if(1){
  let aaa=2
}
console.log(aaa);
VM314:4 Uncaught ReferenceError: aaa is not defined
    at <anonymous>:4:13

const: 1无变量提升 2有块级作用域 3禁止重复声明 4只能声明常量，一旦声明不可再次修改其值。（const声明对象时，可修改对象）

const obj={
  name:'dfd',
  setName:function (params) {
    console.log(this.name);
    
  }
}
obj.name='qgz'
"qgz"
obj['age']=11
11
obj
{name: "qgz", age: 11, setName: ƒ}

浅拷贝

Object.assign

let a = {
  age: 1
}
let b = Object.assign({}, a) 
a.age = 2
2
b
{age: 1}
b=a //给了指针
{age: 2}
b
{age: 2}

...扩展符

let b = { ...a }

let a = {
  age: 1,
  jobs: {
    first: 'FE'
  }
}
let b = { ...a }//浅拷贝只解决了第一层的问题
a.jobs.first = 'native'
"native"
b
{age: 1, jobs: {…}}
age: 1
jobs:
first: "native"//第二层中还有对象的话，会享有相同的地址
__proto__: Object
__proto__: Object