一、变量let和常量const定义
1、变量定义let
var 定义的变量:只有全局作用域和函数作用域
let 定义的变量:有全局作用域和函数作用域,块级作用域
let作用域只限于当前代码
{ let a =12; } console.log(a); #报错,a不存在
let声明的变量作用域不会被提升
console.log(a); #报错 let = 12;
在相同的作用域下不能声明相同的变量
{ let a = 10; let a = 11; //报错 }
for循环体现let的父子作用域
//使用var声明,需要用到“闭包” var btns = document.querySelectorAll("button"); for(var i=0;i<btns.length;i++){ (function(i){ btns[i].onclick= function (){ alert("点击了"+i+"个按钮") } })(i); } //let声明 let btns = document.querySelectorAll("button"); for(let i=0;i<btns.length;i++){ btns[i].onclick= function (){ alert("点击了"+i+"个按钮") } }
2、常量定义const
(1)、const作用域只限于当前代码块
(2)、const声明的变量作用域不会被提升
(3)、在相同的作用域下不能重复声明
(4)、声明的同时必须赋值,声明后值无法改变
{ const b; //报错 const a = 123; a = 222; //报错 }
针对对象就不一样了
{ const obj = { name:"lisi" } console.log(obj.name); //lisi obj.name = "zhaoliu"; console.log(obj.name);//zhaoliu } //在上面中定义的是一个常量对象,对象是储存在内存的“堆区”,通过一个地址描述出来,在“栈区”关联此地址。所以,obj存储的是地址,而不是值,是可以做修改的。
二、字符串模板引擎(字符串拼接)
Es6的这种新的“字符串拼接”方法比较简单,没有繁琐的加号和引号,只需要在所需要的字符串“边界”加上``即可。(键盘 tab上面那个键 ${变量} 键盘 tab上面那个键)
var name = 'Datura'; var age = 18; var sex = '其它'; var hobby = '敲代码'; var str1 = `我是${name},今年${age}岁,性别${sex}的了,爱好${hobby}`; //注意此处有两个“ `` ” var str2 = '我是'+name+',今年'+a
let {time=1000,id=0} = {}; console.log(time,id); // 1000 0
ge+'岁,性别'+sex+',爱好'+hobby+''; //这个是原来的写法 alert(st1r);
三、解构赋值
就根据“对应”赋值,请看以下几个例子:
'use strict'; let a = 12; let b = 5; let c = 8; //相当于 let [a,b,c] = [12,5,8]; console.log(a,b,c); //12 5 8
json格式的赋值
let {a,b,c} = {a:12,b:5,c:8}; console.log(a,b,c); //12 5 8 //数组里面嵌套数组 let [a,[b,c],d] = [12,[1,3],8]; console.log(a,b,c,d); // 12 1 3 8
与顺序无关,与结构有关(左右结构一致):
let {a,b,c} = {b:5,a:12,c:8}; console.log(a,b,c); //12 5 8
应用,我们现在利用jsonp获取了一组数据
let json = { q:"aaa", p:false, s:["aaa云主机","爱奇艺vip免费试用","啊aaaaaaaa视频","aaaa","爱奇艺","aaa电池","工商银行","aaai","aaa短信轰炸机"] }; let {s,q} = json; console.log(s,q); //s为那组数组的数据,q为字符串aaa
解构赋值的默认值问题
let {time=1000,id=0} = {}; console.log(time,id); // 1000 0
四、扩展运算符:三个点
我之前的文章曾提到过数组或者对象的深浅拷贝问题,今天我们就利用es6的三个点来处理下。
var arr = [12,5,8]; arr2 =arr; arr2.pop(); alert(arr); // 12 5
上面的代码就是arr2与arr公用一段内存地址,所以导致srr2数据改变的时候arr也必然会变的。这就是浅拷贝。那么我们下面就简单的说几种深度复制数组方式。
方式一:利用for循环把原数组的每一项都遍历,然后扔到新的数组中。
var arr = [12,5,8]; var arr2 =[]; for(var i = 0;i<arr.length;i++){ arr2.push(arr[i]); } arr2.pop(); alert(arr); // 12 5 8
方式二:利用Array.from(原数组);
var arr = [12,5,8]; var arr2 = Array.from(arr); arr2.pop(); console.log(arr2); // 12 5 alert(arr); // 12 5 8
方式三:三个点
var arr = [12,5,8]; var arr2 = [...arr] arr2.pop(); console.log(arr2);//12 5 alert(arr); //12 5 8
说了这么多,我们现在就说下“三个点”的应用把,我们知道函数的参数是一个集合(arguments)并不是一个真正的数组。那么我们怎么才能在这个arguments中加一项呢??
function show(){ //因为类数组对象,并不具备数组的那些方法。所以此会报错 arguments.push(8); console.log(arguments); }
show(12,5); function show(...arr){ arr.push(8); console.log(arr); } show(12,5); //12 5 8
当然还有很多的对象深拷贝方式请参照(http://www.jianshu.com/p/4e613af9509c),这里就不一一论述了。
扩展:
将一个数组转化为用逗号分隔的参数数列
console.log(...[1, 2, 3]) // 1 2 3 console.log(1, ...[2, 3, 4], 5) // 1 2 3 4 5
主要用于函数调用
array.push(...items)和add(...numbers)这两行,都是函数的调用,它们的都使用了扩展运算符。该运算符将一个数组,变为参数序列
function push(array, ...items) { array.push(...items); } function add(x, y) { return x + y; } var numbers = [4, 38]; add(...numbers) // 42
// ES5 的写法 Math.max.apply(null, [14, 3, 77]) // ES6 的写法 Math.max(...[14, 3, 77]) // 等同于 Math.max(14, 3, 77);
合并数组
// ES5 [1, 2].concat(more) // ES6 [1, 2, ...more] var arr1 = ['a', 'b']; var arr2 = ['c']; var arr3 = ['d', 'e']; // ES5 的合并数组 arr1.concat(arr2, arr3); // [ 'a', 'b', 'c', 'd', 'e' ] // ES6 的合并数组 [...arr1, ...arr2, ...arr3] // [ 'a', 'b', 'c', 'd', 'e' ]
与解构赋值结合使用:
扩展运算符可以与解构赋值结合起来,用于生成数组
// ES5 a = list[0], rest = list.slice(1) // ES6 [a, ...rest] = list 下面是另外一些例子。 const [first, ...rest] = [1, 2, 3, 4, 5]; first // 1 rest // [2, 3, 4, 5] const [first, ...rest] = []; first // undefined rest // []: const [first, ...rest] = ["foo"]; first // "foo" rest // []
如果将扩展运算符用于数组赋值,只能放在参数的最后一位,否则会报错
const [...butLast, last] = [1, 2, 3, 4, 5]; // 报错 const [first, ...middle, last] = [1, 2, 3, 4, 5]; // 报错
var dateFields = readDateFields(database); var d = new Date(...dateFields);
字符串:
扩展运算符还可以将字符串转为真正的数组。
[...'hello'] // [ "h", "e", "l", "l", "o" ]
'x\uD83D\uDE80y'.length // 4
[...'x\uD83D\uDE80y'].length // 3
function length(str) { return [...str].length; } length('x\uD83D\uDE80y') // 3
凡是涉及到操作 32 位 Unicode 字符的函数,都有这个问题。因此,最好都用扩展运算符改写。
let str = 'x\uD83D\uDE80y'; str.split('').reverse().join('') // 'y\uDE80\uD83Dx' [...str].reverse().join('') // 'y\uD83D\uDE80x'
上面代码中,如果不用扩展运算符,字符串的reverse操作就不正确。
( 5 )实现了 Iterator 接口的对象
任何 Iterator 接口的对象,都可以用扩展运算符转为真正的数组。
var nodeList = document.querySelectorAll('div'); var array = [...nodeList];
上面代码中,querySelectorAll方法返回的是一个nodeList对象。它不是数组,而是一个类似数组的对象。这时,扩展运算符可以将其转为真正的数组,原因就在于NodeList对象实现了 Iterator 接口。
对于那些没有部署 Iterator 接口的类似数组的对象,扩展运算符就无法将其转为真正的数组。
let arrayLike = { '0': 'a', '1': 'b', '2': 'c', length: 3 }; // TypeError: Cannot spread non-iterable object. let arr = [...arrayLike];
上面代码中,arrayLike是一个类似数组的对象,但是没有部署 Iterator 接口,扩展运算符就会报错。这时,可以改为使用Array.from方法将arrayLike转为真正的数组。
( 6 ) Map 和 Set 结构, Generator 函数
扩展运算符内部调用的是数据结构的 Iterator 接口,因此只要具有 Iterator 接口的对象,都可以使用扩展运算符,比如 Map 结构。
let map = new Map([ [1, 'one'], [2, 'two'], [3, 'three'], ]); let arr = [...map.keys()]; // [1, 2, 3]
Generator 函数运行后,返回一个遍历器对象,因此也可以使用扩展运算符。
var go = function*(){ yield 1; yield 2; yield 3; }; [...go()] // [1, 2, 3]
上面代码中,变量go是一个 Generator 函数,执行后返回的是一个遍历器对象,对这个遍历器对象执行扩展运算符,就会将内部遍历得到的值,转为一个数组。
如果对没有iterator接口的对象,使用扩展运算符,将会报错。
var obj = {a: 1, b: 2}; let arr = [...obj]; // TypeError: Cannot spread non-iterable object