塊級(jí)作用域let和const

let聲明變量，const聲明常量；都是塊級(jí)作用域

//通常用var聲明的變量，會(huì)有變量提升例如： 
!function(bool){
    if(bool){
        var test='test';
    }else{
        console.log(test);//undefined,說(shuō)明test變量確實(shí)是被申明了，否者會(huì)打印test is not defined
    }
}(false)

!function(bool){
    if(bool){
        let test='test';
    }else{
        console.log(test)//is not defined ,說(shuō)明test未被申明，
        //只存在if(bool){ let test='test';}作用域里面，可以理解為{}里面即是申明變量的作用域
    }
}(false)

//const申明常量,改變其值，會(huì)報(bào)錯(cuò)，例如：
const name='ouyang';
name='wei';// Assignment to constant variable.

var arr=[];
for(var i=0;i<10;i++){
    arr.push(
        function(){
            console.log(i);
        }
    )
}
arr.forEach(function(fun){
    fun();//10次10，只就是var申明i導(dǎo)致的，循環(huán)10，i的值一直在改變；
})

//如果用let來(lái)申明i，又會(huì)怎么樣呢？
var arr=[];
for(let i=0;i<10;i++){
    arr.push(
        function(){
            console.log(i);
        }
    )
}
arr.forEach(function(fun){
    fun();//從0打印到9，這說(shuō)明用let的變量的作用域，
    //只存在function(){console.log(i)};
})

//又或者用閉包來(lái)寫(xiě)
var arr=[];
for(var i=0;i<10;i++){
    arr.push(
        (function(args){
            return function(){
                console.log(args);
            }
        })(i)
    )
};
console.log(arr);
arr.forEach(function(fun){
    fun();
})

模板字符串

拼接字符串 用${}來(lái)劃界

//${}字符串拼接
//es5
var name='ouyang';
console.log(name+'wei');//ouyangwei
//es6
console.log(`${name}wei`);//ouyangwei注意用``

反引號(hào)``

//es5用反斜來(lái)拼接多行字符
var text='hello \
ouyang';
console.log(text);//hello ouyang
//es6直接用反引號(hào)
var words=`hello 
world!`
console.log(words);//hello(換行)
//world!

// 1.includes：判斷是否包含然后直接返回布爾值
let str = 'hahay'
console.log(str.includes('y')) // true
// 2.repeat: 獲取字符串重復(fù)n次
let s = 'he'
console.log(s.repeat(3)) // 'hehehe'
 //如果你帶入小數(shù), Math.floor(num) 來(lái)處理

變量的解構(gòu)賦值

es6 允許按照一定模式，從數(shù)組和對(duì)象中提取值，對(duì)變量進(jìn)行賦值，這被稱(chēng)為解構(gòu)

\\數(shù)組解構(gòu)賦值
let [a,b,c]=[1,2,3];
\\對(duì)象解構(gòu)
let {foo,bar}={foo:"aaa",bar:"bbb"}
\\字符串解構(gòu)
const [a, b, c, d, e] = 'hello';
a // "h"
b // "e"
c // "l"
d // "l"
e // "o"

寫(xiě)法屬于“模式匹配”，只有等號(hào)兩邊的模式相同，左邊的變量就會(huì)被賦予相應(yīng)的值，如果解構(gòu)不成功，變量的值就等于undefined

let [foo, [[bar], baz]] = [1, [[2], 3]];
foo // 1
bar // 2
baz // 3

let [ , , third] = ["foo", "bar", "baz"];
third // "baz"

let [x, , y] = [1, 2, 3];
x // 1
y // 3

let [head, ...tail] = [1, 2, 3, 4];
head // 1
tail // [2, 3, 4]

let [x, y, ...z] = ['a'];
x // "a"
y // undefined
z // []

不完全解構(gòu)，即左邊的變量，與右邊的值個(gè)數(shù)不匹配，能匹配幾個(gè)就是幾個(gè)

let [x, y] = [1, 2, 3];
x // 1
y // 2

let [a, [b], d] = [1, [2, 3], 4];
a // 1
b // 2
d // 4

函數(shù)

默認(rèn)值

//默認(rèn)值
function fun(num){
    var num=num||20;
    console.log(num);
}
fun(0)//20因?yàn)?被當(dāng)成false;
//es6的默認(rèn)值問(wèn)題
function fun1(num=20){
    var num=num;
    console.log(num);
}
fun1(0)//0
//與解構(gòu)賦值默認(rèn)值結(jié)合使用
function foo({x,y=5}){
  console.log(x,y);
}
foo({})//undefined 5
foo({x:1})// 1 5
foo({x:1,y:2})//1 2
foo()//typeError:Cannot red property 'x' of undefined

rest 參數(shù)

ES6引入rest參數(shù)（形式為：...變量名），用戶(hù)獲取函數(shù)的多余參數(shù)，rest參數(shù)搭配的變量是一個(gè)數(shù)組，改變量講多余的參數(shù)放入數(shù)組中,可以替換arguments

function add(...values){
  let sum=0;
  for(var val of values){
    sum+=val;
  }
  return sum;
}
add(2,5,3)

name屬性

函數(shù)name屬性，返回該函數(shù)的函數(shù)名

 function foo(){}
foo.name//foo

箭頭函數(shù)(=>)

箭頭函數(shù)，例子：

var f=v => v
//等同于
var f=function(v){
  return v;
}
//多個(gè)參數(shù)或不需要參數(shù)的時(shí)候，使用園括號(hào)
var f = () => 5
//等同于
var f=function(){
  return 5;
}
var sum=(num1,num2) => num1+num2;
//等同于
var sum=function(num1,num2){
  return num1+num2;
}

如果要返回對(duì)象，必須在對(duì)象外面加上括號(hào)

let getTempItem = id => ({id:id,name:'temp'});
//等同于
let getTempItem=function(id){
  return {
    id:id,
    name:'temp'
  }
}

箭頭函數(shù)this的指向問(wèn)題，函數(shù)體內(nèi)的this對(duì)象，就是定義時(shí)所在的對(duì)象，而不是使用時(shí)所在的對(duì)象

function foo(){
    setTimeout(function(){
        console.log('id:',this.id);
    },1000);
}
var id=21;
foo.call({id:42});//id:21
//setTimeout全局函數(shù)，this指向全局變量
//如果換成箭頭函數(shù)呢？
function fun(){
    setTimeout(()=>{
        console.log('id:',this.id);
    },1000);
}

fun.call({id:42});//id:42
//說(shuō)明箭頭函數(shù)this指向其定義的對(duì)象

對(duì)象表達(dá)式

const foo = 'bar';
const baz = {foo};
baz // {foo: "bar"}

// 等同于
const baz = {foo: foo};

promise對(duì)象

promise異步編程的一種解決方案，比傳統(tǒng)的解決方案，回調(diào)函數(shù)和事件，更合理和強(qiáng)大。
所謂promise，簡(jiǎn)單來(lái)說(shuō)就是一個(gè)容器，里面保存著某個(gè)未來(lái)才會(huì)結(jié)束的事件（通常是一個(gè)異步操作）的結(jié)果。promise是一個(gè)對(duì)象，從它可以獲取異步操作的消息。promise提供統(tǒng)一的api,各種異步操作都可以用同樣的方法進(jìn)行處理。