ES6基础知识

ES6基础知识

ECMAScript 6.0（以下简称 ES6）是 JavaScript 语言的下一代标准，已经在 2015 年 6 月正式发布了。它的目标，是使得 JavaScript 语言可以用来编写复杂的大型应用程序，成为企业级开发语言。

let

ES6中新增的用于声明变量的关键字,let声明的变量只在所处于的块级有效。

if (true) {
	let a = 10;
    }
console. log (a)// a is not defined

注意:var声明的变量不具备块级作用域特性,只有全局作用域或者局部作用域。

●不存在变量提升

console. log(a) ; // a is not defined
let a = 20;

●暂时性死区

只要块级作用域内存在let命令，它所声明的变量就“绑定”（binding）这个区域，不再受外部的影响。

 if (true) {
         tmp = 'abc ';
         console.log(tmp);// Cannot access 'tmp' before initialization
         let tmp;
 }

●不允许重复声明

let不允许在相同作用域内，重复声明同一个变量。

function(){
    let a = 1;
    var a = 0;//错误
}

练习：比较var与let的区别

var arr =[];
for (var i = 0;i < 2; i++){
	arr[i]= function () {
	console. log (i) ;
	}
}
arr[0]();//2
arr[1]();//2,i是全局变量。

let arr =[];
for (let i = 0;i < 2; i++){
	arr[i]= function () {
	console. log (i) ;
	}
}
arr[0]();//0
arr[1]();//1,每次循环的时候let都会形成自己的块级作用域。

const

​ 作用:声明常量，常量就是值(内存地址)不能变化的量。

●具有块级作用域

if (true) {
	const a = 10;
	console. log(a); // a is not defined
}

●不存在变量提升

●暂时性死区

●不允许重复声明

●声明常量时必须(直接)赋值

const a;
a = 10;
console.log(a);//错误

●常量赋值后，值不能修改。

const PI = 3.14;
PI = 100; // Assignment to constant variable.
const ary = [100,200];
ary[0]= 'a' ;
ary[1] = 'b ';
console.log(ary); // [ 'a ', 'b'];
ary = [ 'a ', 'b '];//Assignment to constant variable.

常量储存的是一个地址，这个地址指向一个对象，不可变的只是这个地址，即不能把该常量指向另一个地址，但对象本身是可变的，所以依然可以为其添加新属性。如果真的想将对象冻结，应该使用Object.freeze方法。

如果存储的值不需要变化，使用const关键字的效率更高。

解构赋值

​ ES6中允许从数组中提取值，按照对应位置，对变量赋值。对象也可以实现解构。

数组解构

let [a,b,c]= [1,2,3];
console. log(a);
console.log(b);
console.log(c);
//如果解构不成功，变量的值为undefined。
let [foo] = [];
let [bar,foo] = [1];

字符串的解构赋值

字符串也可以解构赋值。这是因为此时，字符串被转换成了一个类似数组的对象（伪数组）。

const [a, b, c, d, e] = 'hello';
a // "h"
b // "e"
c // "l"
d // "l"
e // "o"

类似数组的对象都有一个length属性，因此还可以对这个属性解构赋值。

let {length : len} = 'hello';
len // 5

---

变量的解构赋值

（1）交换变量的值

let x = 1;
let y = 2;
[x,y] = [y,x];
console.log(y);  //x = 2,y = 1;1234

这样的写法不仅简洁，而且易读，语义非常清晰。

（2）从函数返回多个值
函数只能返回一个值，如果要返回多个值，只能将它们放在数组或对象里返回。有了解构赋值，取出这些值就非常方便。

// 返回一个数组
  function example() {
  return [1, 2, 3];
  }
  let [a, b, c] = example();
  console.table([a,b,c]);

对象解构

/*写法1：直接用属性名*/
let person = { name : ' zhangsan' , age : 20 };
let {name, age} = person;
console.log(name) ; //'zhangsan'
console.log(age);//20
/*写法2：别名*/
let {name: myName,age: myAge} = person;//myName myAge属于别名
console.log(myName);// 'zhangsan'
console.log(myAge);//20

箭头函数

​ ES6中新增的定义函数的方式，用来简化函数的定义方法。

const fn =(a)=>{
return a+1234;
}
fn(123);

●简写

()=>{}
const fn = ()=>{}

​ 函数体中只有一句代码，且代码的执行结果就是返回值，可以省略大括号;

​ 同样，若只有一个参数也可以省略（）

const fn = a => a+1234;
fn(123);

●箭头函数没有自己的this关键字

​ 如果在箭头函数中使用this，this关键字将指向箭头函数定义位置中的this，也因为没有this，所以也就不能用作构造函数。

function fn(){
	console.log(this);
	return ()=>{
		console. log(this);//obj
		}
	}
const obj = {name: "zhangsan'};
const resFn = fn.call(obj);//call方法可以调用函数并改变指向this的对象
resFn();

//var age = 100;
var obj = {
	age:20,
	say: ()=>{
	alert(this.age);
    }
}
obi.say();//未定义，函数被定义在了obj对象当中，但obj对象是没有作用域的，这里函数就定义在了全局作用域下，this就指向window，而window下面没有age属性。

剩余参数

​ 剩余参数语法允许我们将一个不定数量的参数表示为一个数组。

function sum (first,...args){
console.log(first) ; // 10
console.log(args) ; // [20,30],剩余的参数 被放在了args这个数组里面
}
sum (10,20,30);

●剩余参数和解构配合使用

let students = [ ' wangwu' , ' zhangsan ' , ' lisi ' ];
let [s1, ...s2] = students ;
console.log(s1) ; //'wangwu '
console.log(s2) ; //[ 'zhangsan ' , 'lisi']

Array的扩展方法

(1)扩展运算符(展开语法)

​ 扩展运算符可以将数组或者对象转为用逗号分隔的参数序列。

let ary = [1,2,3];
...ary// 1，2，3
console.log (...ary);// 1 2 3
console.log(1,2,3);// 1 2 3

●扩展运算符可以应用于合并数组。

//方法一
let ary1 = [1,2,3];
let ary2 = [3,4,5];
let ary3 = [...ary1,...ary2];
//方法二
ary1.push (...ary2);

●利用扩展运算符将伪数组转换为真正的数组

//利用扩展运算符将伪数组转换为真正的数组
var oDivs = document.getElementsByTagName('div');
consoLe.log(oDivs);
var ary = [...oDivs];
ary.push('a');//转换为数组后能使用数组的方法
consoLe.log(ary);

什么是伪数组?

1. 拥有 length 属性，其它属性（索引）为非负整数(对象中的索引会被当做字符串来处理，这里你可以当做是个非负整数串来理解)
2. 不具有数组所具有的方法

常见的伪数组有：

• 函数内部的 arguments
• DOM 对象列表（比如通过 document.getElementsByTags 得到的列表）
• jQuery 对象（比如 $("div") ）

伪数组是一个 Object，而真实的数组是一个 Array。

（2）Array.from()

​ 将类数组或可遍历对象转换为真正的数组

let arrayLike = {
	'0': 'a',
	'1': 'b',
	'2': 'c',
	length: 3 
};
let arr2 = Array.from(arrayLike); // ['a', 'b'，'c']

​ 方法还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组.

let arrayLike = {
	"0":1,
	"1":2,
	"length" : 2
let newAry = Array.from(aryLike, item =>item *2);//2,4

（2） Array.find()
用于找出第一个符合条件的数组成员，如果没有找到返回undefined

let ary =[{
	id: 1,
	name:'张三'
},{
	id: 2,
	name:'李四'
}];
let target = ary.find (item =>item.id == 2);

(3)Array.findIndex()
用于找出第一个符合条件的数组成员的索引号，如果没有找到返回-1

let ary = [1,5,10,15];
let index = ary.findIndex(item=>{return item > 9});
console.log(index); // 2

注意：只查找第一个符合条件的索引

(4)Array.includes()
表示某个数组是否包含给定的值，返回布尔值。

[1,2,3].includes(2);//true
[1,2,3].includes(4);//false

String的扩展方法

(1)模板字符串
ES6新增的创建字符串的方式，使用反引号定义。

let name = ` zhangsan `;

●模板字符串中可以解析变量。

let name ='张三';
let sayHello = `hello,my name is ${name}`; // hello,my name is zhangsan

●模板字符串中可以换行

let result = {
	name:'zhangsan',
    age: 20,
	sex:"男"
}
let html = `<div>
<span>${result.name}</span>
<span>${result.age}</span>
<span>${result.sex}</span>
</div> `;

●在模板字符串中可以调用函数。

const sayHello = function () {
	return '我是sayHello函数';
};
let greet = `${sayHello()} 我是模板字符串`;
console.log(greet);//我是sayHello函数 我是模板字符串

(2) startsWith()和endsWith()

startsWith():表示参数字符串是否在原字符串的头部，返回布尔值

endsWith():表示参数字符串是否在原字符串的尾部，返回布尔值

let str = 'Hello world!';
str.startswith ('Hello') //true
str.endswith ('!')//true

(4)repeat()

​ repeat方法表示将原字符串重复n次，返回一个新字符串。

'x'.repeat (3);//"xxx"
'hello'.repeat(2);//"hellohello"

Set数据结构

​ ES6提供了新的数据结构Set。它类似于数组，但是成员的值都是唯一的，没有重复的值,可以用于数据去重。
​ Set是一种叫做集合的数据结构，

什么是集合？

• 集合是由一组无序且唯一(即不能重复)的项组成的，可以想象成集合是一个既没有重复元素，也没有顺序概念的数组
• ES6提供了新的数据结构Set。它类似于数组，但是成员的值都是唯一的，没有重复的值
• Set 本身是一个构造函数，用来生成 Set 数据结构

const s = new set ();//Set函数可以接受一个数组作为参数，用来初始化。
const set = new set([1,2,3,4,4]);
const s3 =new Set(["a","a","b","b"]);
consoLe.log(s3.size);//set.size
const ary = [...s3];
consoLe.log(ary);

实例方法
●add(value):添加某个值，返回Set结构本身

●delete(value):删除某个值，返回一个布尔值，表示删除是否成功

●has(value):返回一个布尔值，表示该值是否为Set的成员

●clear():清除所有成员，没有返回值

const s = new set () ;
s.add(l).add(2).add (3);//向set结构中添加值
s.delete(2);
//删除set结构中的2值
s.has(1);
//表示set 结构中是否有1这个值,返回布尔值
s.clear();
//清除set结构中的所有值

●遍历set : forEach()：遍历所有成员

//遍历set数据结构从中取值
const s5 = new Set(['a', 'b', 'c']);
s5.forEach(value =>{
	consoLe.log(value);
});

Map数据结构

​ Map是一组键值对的结构，具有极快的查找速度。Map是一种叫做字典的数据结构。

​ 那么集合又和字典有什么区别呢：

• 共同点：集合、字典可以存储不重复的值
• 不同点：集合是以[值，值]的形式存储元素，字典是以[键，值]的形式存储

基本使用：

const m = new Map();
const o = {p:'Hello World'};
m.set(o,'content');
m.get(o); // "content"

m.has(o); // true
m.delete(o); // true
m.has(o); // false

属性：

• size：返回字典所包含的元素个数

操作方法：

• set(key, val): 向字典中添加新元素
• get(key):通过键值查找特定的数值并返回
• has(key):如果键存在字典中返回true,否则false
• delete(key): 通过键值从字典中移除对应的数据
• clear():将这个字典中的所有元素删除

遍历方法：

• keys():将字典中包含的所有键名以数组形式返回
• values():将字典中包含的所有数值以数组形式返回
• forEach()：遍历字典的所有成员