箭头函数。

声明式 function fn(){}

赋值式 var fn=function(){}

自执行函数(function(){})()

agguments 函数内部自带的属性，表示实参的集合，有形参也不影响------伪数组

箭头函数---函数简写的方式

声明式函数不能简写(匿名可以)

()=>{}   
(a,b)=>{} 
//只有一个参数可以取消(),多个和零个不能 
(a)=>{}          a=>{} 
//只有一行代码}{}可以不写 有return就要写{}   
()=>{console.log('')}         ()=>console.log('')

//只有一行代码，且return有返回值，return可以不写，写return就要写{}
()=>(return x)    ()=>x

this关键字

一、在不同场景下表示不同对象

1. 事件处理函数中：this->事件源(绑定事件的对象)

2. 在普通函数中的：this->window对象

3. 定时器(回调函数、匿名函数)参数函数中的this：this->window

4. 自执行函数：this->window

5. 对象Object方法中：this->当前正在调用执行方法的对象(当前对象)

二、在箭头函数中

在箭头函数中没有this没有指向的说法

一定要用，箭头函数中的this指向应用上下文（他外面一层范围内）的this，外面的this指向另外的对象，

改变this指向

- call: 函数名.call(要指向的对象,参数1,参数2...)

var obj = {
    name:'jack'
}
function fun(m,n){
    console.log('fun ',this,' m :',m, ' n :',n)
}
fun.call(obj,10,20) //有参就写没有就不写

- apply：函数名.apply(要指向的对象,[参数1,参数2])

var obj = {
    name:'jack'
}
function fun(m,n){
    console.log('fun ',this,' m :',m, ' n :',n)
}
fun.apply(obj,[10,30]) //有参就写没有就不写

- bind ：

函数名.bind(要指向的对象)

        =>返回改变this指向的新函数

        新函数(参数1，参数2...)----调用才会执行

var obj = {
    name:'jack'
}
function fun(m,n){
    console.log('fun ',this,' m :',m, ' n :',n)
}
var newFun = fun.bind(obj)
            newFun(30,40)

函数传递默认值

function fn(m = 10) { //ES6写法
    // m = m || 10  //ES5写法
    console.log(m)
}
fn()

变量 声明

ES6: ECMAScript 第六个版本也可以指后面最新版本

var 变量  let 变量   const (常量)

let必须先定义再使用、具有块作用域{}块外面不能访问里面，里面可以访问外面 ，不能重复声明变量

 var可以先使用再定义(预解析) 

const 不能重新赋值

解构赋值

快速获取对象或数组中的成员，交换变量 （交换变量前面的语句必须加；）

//结构赋值
		//解构对象
function test1() {
    const obj = {
    name: 'jack',
    age: 18,
}
// let name = obj.name
// let age = obj.age
    let { name, age } = obj //解构对象
    console.log('name ', name, ' age ', age)
}
//解构数组
function test2() {
    const arr = ['jack', 'rose', 'tom']
    let [a, b, c] = arr  //解构数组
    console.log('a ', a, ' b ', b, ' c ', c);
}
//交换
function test3() {
    let a = 10
    let b = 20;
// let temp = a
// a = b
// b = temp
    [a, b] = [b, a]
    console.log('a = ', a, ' b = ', b);
}

模板字符串 ·￥{}·

展开运算符 ...

        展开数组，对象

function test1(){
            const arr = [1,2,3,4]
            // console.log( ...arr );
            const arr1 = [5,6,7]
            let arr2 = [...arr,...arr1] //展开数组，合并数组的操作
            console.log(arr2);
        }
        // test1()
        function test2(){
            const obj = {
                name:'jack',
                age:18
            }
            const obj1 = {
                ...obj, //展开对象，合并对象的操作
                gender:'男'
            }
            console.log(obj1);
        }
        // test2()
       

//函数传参
        let arr = [1, 2, 3]
        function fn(a, b, c) {

        }
        fn(...arr)

        对象字面量简写

 function test3(){
            const name = 'jan'
            const age = 18
             const obj = {
                 name:name,
                 age:age
             }
//属性名和属性值相同时
            const obj = {
                name,
                age
            }
            console.log(obj);
        }
        test3()

js错误处理机制

js错误处理机制
           浏览器js引擎执行js代码，如果遇到错误代码，生成一个错误对象(Error),将错误对象抛给上层代码处理，
           如果上层没有处理错误的代码，交给系统处理,系统处理方式：
              停止程序执行，将错误信息打印显示在控制台.
          捕获错误
            try{
                //可以发生错误的代码
            }catch(e){  e = 生成的错误对象（错误对象赋值给e）
                e
            }




console.log('程序开始执行');
        try{
            const num = 100
            num = 200
        }catch(e){
            console.log('这是我捕获的错误对象e',e);
        }
        console.log('程序结束');