1. ES6提供了默认参数值机制，允许你为参数设置默认值，防止在函数被调用时没有传入这些参数:
const required = () => {throw new Error('Missing parameter')};
const add = (a = required(), b = required()) => a + b;
add(1, 2) //3
add(1) // Error: Missing parameter.
2,变量的解构赋值
2-1.数组的解构赋值：左边和等号右边的形式要统一，如果不统一解构将失败。
let [a,b,c]=[1,2,3]; let [a,[b,c],d]=[1,[2,3],4];
// 解构赋值是允许你使用默认值的
let [foo = true] =[];
console.log(foo); //控制台打印出true
let [a,b="name"]=['小明']
console.log(a+b); //控制台显示“小明name”
null相当于有值，但值为null.undefined相当于什么都没有,如果值不对应就会报undefined
let [a,b="name"]=['小明',null];
console.log(a+b); //控制台显示“小明null”
2-2. 对象的解构赋值
let {foo,bar} = {foo:'Hello',bar:'World'};
console.log(foo+" "+bar); // Hello World
// 如果在解构之前就定义了变量，要在解构的语句外边加一个圆括号
let foo;
({foo} ={foo:'Hello'});
console.log(foo); // Hello
2-3. 字符串解构
const [a,b,c,d,e]="Hello"; console.log(a); //H
3,对象方法属性可以简写
const o = {
method(){
return "Hello!";
}
};
// 等同于
const o = {
method: function() {
return "Hello!";
}
}
5, 动态写key名
let keys= 'foo';
let obj = { [keys]: true, ['a' + 'bc']: 123};
console.log(obj.foo) //true
console.log(obj.abc) //123
6. 扩展运算符和rest运算符
对象扩展运算符（…）。它们可以很好的为我们解决参数和对象数组未知情况下的编程
function argment(...arg){
console.log(arg[0]);
console.log(arg[1]);
console.log(arg[2]);
console.log(arg[3]);
}
argment(1,2,3); // 1,2,3，undefined
7. 数组赋值,扩展运算符
let arr1=['a','b','c'];
let arr2=arr1;
console.log(arr2); //['a','b','c']
arr2.push('d');
console.log(arr1); //['a','b','c','d']
console.log(arr2); //['a','b','c','d']
//声明两个数组arr1和arr2，然后我们把arr1赋值给arr2，然后我们改变arr2的值，你会发现arr1的值也改变了，因为我们这是对内存堆栈的引用，而不是真正的赋值
let arr1=['a','b','c'];
let arr2=[...arr1]; // 也可合并多个[...arr1, ...arr2, ...arr3]
console.log(arr2); //['a','b','c']
arr2.push('d');
console.log(arr2); //['a','b','c','d']
console.log(arr1); //['a','b','c']
// 现在控制台预览时，arr1并没有改变
8. 循环输出rest参数和扩展运算符
function loopFun1(...arg){
for(let val of arg){
console.log(val);
}
}
function loopFun(reset1,...arg){
console.log(arg);
// console.log(arg.length);
}
loopFun1(1,2，3); //1,2,3
loopFun(1,2，3); //[2,3]
let [a,b,..c]= [1,2,3,4,5]
console.log(a) // [1]
console.log(b) // [2]
console.log(c) // [3,4,5]
9,字符串模版
let a='alice';
document.write( `I am ${a} ${1+2} age`); //I am alice 3 age
10. ES6数字操作
Binary,二进制的开始是0（零），然后第二个位置是b（注意这里大小写都可以实现）
let binary = 0B010101;
console.log(binary); //21
八进制的英文单词是Octal，也是以0（零）开始的，然后第二个位置是O（欧），然后跟上八进制的值就可以了。
let b=0o666;
console.log(b); //438
数字验证Number.isFinite( xx )
可以使用Number.isFinite( )来进行数字验证，只要是数字，不论是浮点型还是整形都会返回true，其他时候会返回false。
let a= 11/4;
console.log(Number.isFinite(a));//true
console.log(Number.isFinite('Hello'));//false
console.log(Number.isFinite(NaN));//false
console.log(Number.isFinite(undefined));//false
NaN是特殊的非数字，可以使用Number.isNaN()来进行验证。
console.log(Number.isNaN(NaN));//true
判断是否为整数Number.isInteger(xx)
let a=123.1; console.log(Number.isInteger(a)); //false
整数转换Number.parseInt(xxx)和浮点型转换Number.parseFloat(xxx)
let a='9.18'; console.log(Number.parseInt(a)); //9 console.log(Number.parseFloat(a)); //9.18
最大安全整数
console .log(Number.MAX_SAFE_INTEGER); Math.pow(2,53)-1;
最小安全整数
console.log(Number.MIN_SAFE_INTEGER);
安全整数判断isSafeInteger( )
let a= Math.pow(2,53)-1; console.log(Number.isSafeInteger(a));//false
11.es6新特性
11-1, JSON数组格式转换(key为数组序号)
let json = {
'0': 'I',
'2': 'LOVE',
'1': 'YOU',
length:3
}
let arr=Array.from(json);
console.log(arr) // ["I", "YOU", "LOVE"]
11-2, Array.of()方法：（它负责把一堆文本或者变量转换成数组类似eval）
let arr =Array.of(3,4,5,6); console.log(arr); //[3, 4, 5, 6]
11-3, find( )实例方法:
所谓的实例方法就是并不是以Array对象开始的，而是必须有一个已经存在的数组，然后使用的方法，这就是实例方法。这里的find方法是从数组中查找。在find方法中我们需要传入一个匿名函数，函数需要传入三个参数：
value：表示当前查找的值。
index：表示当前查找的数组索引。
arr：表示当前数组。
let arr=[1,2,3,4,5,6,7,8,9];
console.log(arr.find(function(value,index,arr){
return value > 5;
})) // 6
11-4, fill( )实例方法：
fill()也是一个实例方法，它的作用是把数组进行填充，它接收三个参数，第一个参数是填充的变量，第二个是开始填充的位置，第三个是填充到的位置。
let arr=[0,1,2,3,4,5,6,7,8,9];
arr.fill('a',2,5);
console.log(arr); //[0, 1, "a", "a", "a", 5, 6, 7, 8, 9]
11-5, for...in和for...of区别
for...in
1.循环出来的是index索引，是字符串型的数字；2.遍历顺序有可能不是按照实际数组的内部顺序；
3.使用for in会遍历数组所有的可枚举属性，包括原型上的以及数组自定义的属性；
所以for in更适合遍历对象，不要使用for in遍历数组。,在遍历数组的时候的时候使用for...of；
for...in循环出的是key，for...of循环出的是value；
注意，for...of是ES6新引入的特性。修复了ES5引入的for...in的不足；
for...of不能循环普通的对象，需要通过和Object.keys()搭配使用；
Object.prototype.objCustom = function () {};
Array.prototype.arrCustom = function () {};
let iterable = [3, 5, 7];
iterable.foo = "hello"; //数组中key为数字
for (let i in iterable) {
console.log(i); // 0, 1, 2, "foo", "arrCustom", "objCustom"
}
for (let i of iterable) {
console.log(i); // 3, 5, 7
}
11-6，同时输出数组的内容和索引：我们用entries()这个实例方法，配合我们的for…of循环就可以同时输出内容和索引了
let arr=['a','b','c']
for (let [index,val] of arr.entries()){
console.log(index+':'+val); //0:a 1:b 2:c
}
11-7, entries( )实例方法：
entries()实例方式生成的是Iterator形式的数组，那这种形式的好处就是可以让我们在需要时用next()手动跳转到下一个值。我们来看下面的代码：
let arr=['a','b','c'] let list=arr.entries(); console.log(list.next().value); //[0, "a"] console.log(list.next().value); //[1, "b"] console.log(list.next().value); //[2, "c"]
12. 函数解构
12-1,对象的函数解构
let json = {
a:'1',
b:'2'
}
function fun({a,b='1'}){
console.log(a,b);
}
fun(json); //1 2
12-2, 数组的函数解构
let arr = ['a','b','c'];
function fun(a,b,c){
console.log(a,b,c);
}
fun(...arr); //a,b,c
13. in 是用来判断对象或者数组中是否存在某个值的
let obj={
a:'1',
b:'2'
}
console.log('a' in obj); //true
console.log(0 in arr1); //如果是数组则为索引
// 遍历
let arr=['a','b','c'];
console.log(arr.map(x=>'d')); // d,d,d
arr.some(x=>console.log(x)); //a,b,c
arr.filter(x=>console.log(x));// a,b,c
14 Object.is( ) 对象比较
console.log(+0 === -0); //true
console.log(NaN === NaN ); //false
console.log(Object.is(+0,-0)); //false
console.log(Object.is(NaN,NaN)); //true
===为同值相等，is()为严格相等。
15. Object.assign( )合并对象
//way1
var a={a:'1'};
var b={b:'2'};
var c={c:'3'};
let d=Object.assign(a,b,c)
console.log(d); //{a: "1", b: "2", c: "3"}
//way2
const person = { a:1 };
const tools = { b:2 };
const attributes = { c:3 };
const summary = {...person, ...tools, ...attributes}; // {a:1,b:2,c:3}
16.声明Symbol
var a = new String;
var b = new Number;
var c = new Boolean;
var d = new Array;
var e = new Object;
var f= Symbol();
console.log(typeof(d));
17.Symbol对象元素(key)的保护作用
let obj={name:'hw',skill:'angry'};
let age=Symbol();
obj[age]=18;
for (let item in obj){
console.log(obj[item]); //hw angry
}
console.log(obj) //{name: "hw", skill: "angry", Symbol(): 18}
18：Set和WeakSet数据结构（Set的数据结构是以数组的形式构建的）
Set和Array 的区别是Set不允许内部有重复的值，如果有只显示一个，相当于去重。虽然Set很像数组，但是他不是数组。
Set的声明：
let setArr = new Set(['a','b','c','a']);
console.log(setArr);//Set {"a", "b", "c"}
追加add：
setArr.add('d'); //Set {"a", "b", "c", "d"}
删除delete：
用has进行值的查找，返回的是true或者false。
.size相当与length
setArr.clear() //清空
for (let item of setArr){ //循环
console.log(item);
}
setArr.forEach((value)=>console.log(value));
WeakSet的声明（弱）
let weakObj=new WeakSet();
let obj={a:'aa',b:'bb'}
weakObj.add(obj);
console.log(weakObj);
（总结：在实际开发中Set用的比较多，WeakSet用的并不多，但是他对传入值必须是对象作了很好的判断，我们灵活应用还是有一定的用处的。）
19,map数据结构
Map的灵活性要更好，你可以把它看成一种特殊的键值对，但你的key可以设置成数组，值也可以设置成字符串，让它不规律对应起来。
let json = {
name:'hw',
skill:'angry'
}
var map=new Map();
map.set(json,'iam');
console.log(map); //当然也可key字符串，value是对象
console.log(map.get(json)); //取值get -->iam
map.delete(json); //删除delete
console.log(map.size); //0
console .log(map.has('a')) //false
map.clear()
20. 用Proxy进行预处理
声明Proxy
new Proxy({},{});
var pro = new Proxy({
add: function (val) {
return val + 10;
},
name: 'I am hw'
}, {
get:function(target,key,property){
console.log('come in Get');
return target[key];
}
});
console.log(pro.name); //先输出了come in Get。相当于在方法调用前的钩子函数31
20-1. get属性
get属性是在你得到某对象属性值时预处理的方法，他接受三个参数
target：得到的目标值
key：目标的key值，相当于对象的属性
property：这个不太常用，用法还在研究中，还请大神指教。
20-2. set属性
set属性是值你要改变Proxy属性值时，进行的预先处理。它接收四个参数。
target:目标值。
key：目标的Key值。
value：要改变的值。
receiver：改变前的原始值。
var pro = new Proxy({
add: function (val) {
return val + 10;
},
name: 'I am hw'
}, {
get:function(target,key){
console.log('come in Get');
return target[key];
},
set:function(target,key,value,receiver){
console.log(` setting ${key} = ${value}`);
return target[key] = value;
}
});
console.log(pro.name);
pro.name='qc';
console.log(pro.name);
21. function test(fruit = '默认值') {
// 改写多个||判断
const redFruits = ['apple', 'strawberry', 'cherry', 'cranberries'];
if (redFruits.includes(fruit)) {
console.log('red');
}
}
22. 数组去重
console.log(new Set([1, 2, 3, 3])); >> [1,2,3]
过滤空值:空值指的是没有具体意义的一些值，比如0，undefined，null，false，空字符串等
let res = [1,2,0,undefined,null,false,''].filter(Boolean); >> 1,2
const isRequired = () => {
throw new Error('param is required');
};
const hello = (name = isRequired()) => {
console.log(`hello ${name}`)
};
// 抛出一个错误，因为参数没有传 hello()；
// 没有问题 hello('hello')
原文地址：https://www.cnblogs.com/chuanq/p/11018914.html
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。