变量提升： var

var tmp = new Date()
function f(){

console.log(tmp) //作用于死区
if(false){

var tmp = 'hello world'
}
}

f() tmp undefine var 变量提升

5 变量的结构赋值：
let arr = [1,2,3]
let b =arr[1]

let [a,b,c] = arr;
let [x,y,z] = [1,2] z undefine
let [x, y, z = 5] = [1,2] 设置默认值

let [m,n] = [1,2,3] m =1, n = 3;
宗旨： 一一对应
var obj ={ // 定义变量
a: 2,
b: 3

}

let obj = {
a, //=> a:a
b: b,
add(){} // =>add: function(){} //对象简写
}

let dates = { //定义对象

name: 'ss',
age: 12
}

let name = dates.name

let {name: name, age: age} = dates; //声明变量
改变量名
let {name: nm, age: ag} = dates;
let {name,age} = dates;

对象解构赋值
面向对象： 原型。 __proto__: object 原型
赋值原型属性。
let ss = [1,2,3]

let {length: len} = ss //结构赋值
len
>> 3
let datas = {
name: "aa",
age: 13,
sex: false

}
let {name,age,sex: sx=true} = datas; 修改名字

以数组形式的解构

let str = "abcdefg"
let [abc,io] = str; //abc =a, io = b
以字符串形式解构

let {indexof, length,slice} = str // 原型赋值

展开运算符： const arr = [1,2,3] // 展开后： ...[1,2,3] => 1,2,3
const s = [...[1,2,3]] // s=== arr false 地址不一样
var o = {...obj}
var person = {

name: 'aaa';
age: 12;
...obj // 合并对象
}

var newObj = {...obj,...person} //合并对象
function add(...arr){ // ...[1,2,3]

console.log(arr)
}

add(...arr); //展开运算符

字符串扩展： 模板字符串
const name = '小明'；
const age = 12;
const str = name + age;
const newstr = `${name}今年${age}了`; //模板字符串{} 可以放任意表达式，但是一定要有返回值。
标签模板：

function add(...arr){

console.log(arr)
}

add`${name}今年${age}了${age}`; // 三个参数

类：对实例的抽象
实例：类的具体表现
原型：
const date = new Date()
console.dir();

<div id='box'> </box>
<span id='span'></span>
const oBox = document.getElementById('box')

每个标签都有自己的类。 console.dir(obj)

一切皆对象

this supper
判断的是this指向；
this 指向windows 一般只出现在函数内部。
意义让同一个函数在不同环境下执行有不同的效果。实例的方法调用的类的原型。

只有函数执行的时候才能： 判断this指向。
函数内部的this指向当前函数执行的环境。函数所挂靠的实例对象。
this指向实例对象。实例原型对象。
super调用父类的方法。
super 和this 用同样的特性。
super 指向当前函数的执行环境。所属的类原型。（property)
书写时不能单独写在函数中。
Object.property.abc = 123;
cosnt obj = {
name : "zhang",
say(){
console.log(super.abc);
console.log(this.name);

}

}

修改函数this的方法：
function 是一个实例。 通过函数推算他的类。

方法： call 参数， 返回值， this 指向， 功能。
const obj={

name: "zhang";
sayProp(){
console.log(super.abc);
console.log(this.name);
}
}
function add(a,b,c){
console.log(a,b,c);
console.log(this);

}
add.call(obj,1,2,3)
a. call 功能： 让函数执行。
apply 和call 是一样的。

bind方法： 挂载函数的类的原型上。
不能使调用bind的函数执行。
改变函数内部的this.
会生成新的函数。

箭头函数： const add = function(){}
const dis = (/*形参*/)=>{
}
简写小括号和花括号在一定情况下可以简写：
参数是一个的时候小括号可以省略；
代码块仅有一句话时花括号可以省略；

const add (a) =>{

return a+10;
}
简写： add = a =>a+10;
作为对象属性；
const obj = {
add: ()=>{}
}
箭头函数是没有this; 指的时上一级环境。

const obj={

add: ()=>{
console.log(this); //指向上一级对象
}
dis(){
const m = ()=>{
console.log(this);
}

const oo = {m}
oo.m();
}
}

const person = {
say(){
const m = ()=>{
console.log(this); //指向person

}
m();
}

}

类基本用法：
代码中有很多类。
首字母大写。
class Person{

//针对类的描述
constructor(){ 成员方法， this都指向生成实例。接受参数。实例化的参数会被constructor接受到。
this.name = '张三'; // this 指向实例。
this.age = 12;
this.height = 178;
this.weight = 100;

} //构造函数；每个类都有
say(){

const {name,age, height,weight} = this;
console.log(`我叫${name},我的年龄${age},我的身高${height},我的体重${weight}`)
}
doAction(){}
doThing(){}
}

const p1 = new Person();
实例和类。

类里面的成员的方法都挂在类的原型上。