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);
什么是伪数组?
- 拥有 length 属性,其它属性(索引)为非负整数(对象中的索引会被当做字符串来处理,这里你可以当做是个非负整数串来理解)
- 不具有数组所具有的方法
常见的伪数组有:
- 函数内部的
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():遍历字典的所有成员