//this.hello() //ES 6变量申明
//this.extendOperater(1,2,3) //扩大运算符 ...
//this.restOperater(1,2,3,4,5,6,7,8)
this.add(1,2,3,4,5)
//this.stringTemplate()
//this.numOperate()
//this.arrOperate()
/*this.getJson({
a:'aa',
//b:'bb'
})*/
//this.defObj()//ES6容许把申明的变量间接赋值给对象
//this.assignObj() //Object.assign( )合并对象
this.setFun() // set 办法
//this.mapFun() //mapmapFun() {
let a = {a: 1, b: 2}
var map=new Map();
map.set(a,'cc');
console.log(map);
},
setFun() {
let arr = ['aa','去掉反复的','cc','dd','cc','删除一个', '去掉反复的','是否有这一项']
let setArr = new Set(arr) // 能够去掉反复的
//Array.from办法能够将Set构造转换为数组
//console.log(Array.from(setArr))
//console.log([...new Set(arr)]) //另一个数组去重办法
//setArr.add('减少一个')
//setArr.delete('删除一个');
//console.log(setArr.has('是否有这一项'))//true
//setArr.clear() //清空set内容
//console.log(setArr.size) //长度
//console.log(setArr) //
//map办法
//console.log([1,2,3].map(x => x*2))
//filter
console.log([1, 2, 3, 4, 5].filter(x => x%2==0))
let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);
//Set 能够很容易地实现并集（Union）、交加（Intersect）和差集（Difference）
// 并集
//let union = new Set([...a, ...b]);
// 交加
//let union = new Set([...a].filter(x => b.has(x)));
// 差集
let union = new Set([...a].filter(x => !b.has(x)));
// Set {1}
//console.log(Array.from(union))
},
//Object.assign( )合并对象
assignObj(){
let a = {a: 1, b: 2}
let c = {b: 3, d: 'xnw'}
let d = Object.assign(a, c)
console.log(d)
},
getJson ({a,b='xnw'}){//json作为参数传递 能够设置默认值
console.log(a,b);
},
defObj (){//ES6容许把申明的变量间接赋值给对象
let name="aaa";
let sex= 'male';
var obj= {name,sex};
console.log(obj); //Object {name: "aaa", sex: "male"}
},
hello () {//ES 6变量申明
var a = 2
{
let a = 3
//console.log(a)
}
//console.log(a)
},
extendOperater(...arg) {
//扩大运算符 ...
console.log(arg[0])
console.log(arg[1])
console.log(arg[2])
console.log(arg[3])
//控制台输入了 1,2,3，undefined，这阐明是能够传入多个值，并且就算办法中援用多了也不会报错
},
restOperater(a,...arg) {//rest运算符
console.log(arg.length)
for(let val of arg){//for…of的循环能够防止咱们开辟内存空间，减少代码运行效率
console.log(val);
}
},
//将所有参数相加的函数
add(...x){
//console.log(x.reduce((m,n)=>m+n))
},
//传递任意个数的参数
stringTemplate() {
let a ='一个变量';
let c = 5
let d = 3
let b = `<b>能够加html</b>，and ${a} ,反对运算${c+d}`
console.log(b)
document.getElementById('stringTemplate').innerHTML = b
console.log(b.startsWith('<'))//判断结尾是否存在某个字符
console.log(b.endsWith(8))//判断开端是否存在某个字符
},
numOperate() {
//数字验证Number.isFinite( xx )
//能够应用Number.isFinite( )来进行数字验证，只有是数字，不论是浮点型还是整形都会返回true，其余时候会返回false。
let a= 11/4;
console.log(Number.isFinite(a))//true
console.log(Number.isFinite('aac'))//false
console.log(Number.isFinite(NaN))//false
console.log(Number.isFinite(undefined))//false
//判断是否为整数Number.isInteger(xx)
console.log(Number.isInteger(1.22))
},
arrOperate() {
//ES6中新增的数组常识
let json = {
'0': '12',
'1': '33',
'2': 'yyy',
length:3
}
let arr=Array.from(json) //这样的json对象能够转为数组 key值需从0开始
//console.log(arr)
let arr2 =Array.of('www','xnw','.','com') //创立一个数组
//console.log(arr2);
let arr3=[1,2,3,4,5,6,7,8,9]
/*console.log(arr3.find(function(value,index,arr3){//返回满足条件的值
return value > 5
}))
console.log(arr3.findIndex(function(value,index,arr3){//返回满足条件的index
return value > 5
}))*/
//console.log( arr3.map((n)=>n-1) )//[0, 1, 2, 3, 4, 5, 6, 7, 8]
//arr.fill(value, start, end)实例办法value：填充值。start：填充起始地位，能够省略。end：填充完结地位，能够省略，理论完结地位是end-1。
let arr4=[0,1,2,3,4,5,6,7,8,9];
arr4.fill('xnw',2,4);
console.log(arr4);
}
ES6 Map遍历、filter()筛选对象
目录：
——– 1、map()
——– 2、filter():
————- 2.1、filter函数能够看成是一个过滤函数，返回符合条件的元素的数组
——– 3、filter() 筛选符合条件项
——– 4、filter() 数组去重
——– 5、filter() 去掉空字符串、undefined、null
——– 6、filter() 筛选数组对象
———— 6.1、单个条件筛选：筛选出对象.a属性不等于苹果的对象汇合
———— 6.2、多个筛选条件：筛选数组对象中a属性是苹果，b属性是面包的对象汇合
map():
map和forEach等遍历办法不同，在forEach中return语句是没有任何成果的，而map则能够扭转以后循环的值，返回一个新的被扭转过值之后的数组（map需return），个别用来解决须要批改某一个数组的值。
复制代码
let arr1 = [1,2,3];
let arr2 = arr1.map((value,key,arr) => {
console.log(value) // 1，2，3
console.log(key) // 0，1，2
console.log(arr) //[1,2,3] [1,2,3] [1,2,3]
return value * value;})
console.log(arr1); // [ 1, 2, 3 ]
console.log(arr2); // [ 1, 4, 9 ]
复制代码
filter():
filter函数能够看成是一个过滤函数，返回符合条件的元素的数组
filter须要在循环的时候判断一下是true还是false，是true才会返回这个元素；
复制代码
let arr1 = [1,2,3];
let arr2 = arr1.filter((value,key,arr) => {
console.log(value) // 1，2，3
console.log(key) // 0，1，2
console.log(arr) // [1,2,3]
return value >= 3 ? false : true; //外部走的就是value>=3 成立吗，成立的局部返回，不成立的局部不返回。})
console.log(arr1); // [ 1, 2, 3 ]
console.log(arr2); // [ 1, 2 ]
复制代码
filter() 筛选符合条件项
//返回数组中大于等于 2的新数组
console.log(“————–筛选出（大于等于2的）———————–“)
let arr = [1, 2, 3]
let newArr = arr.filter(item => item >= 2)
console.log(newArr)
filter() 数组去重
let arr5 = [1, 2, 2, 3, 4, 5, 5, 6];
let newArr4 = arr5.filter((x, index, self) => {
return self.indexOf(x) === index})
console.log(newArr4) //[1,2,3,4,5,6]
filter() 去掉空字符串、undefined、null
//filter() 去掉空字符串、undefined、null
let arr4 = [”, ‘1’, ‘2’, undefined, ‘3.jpg’, undefined]
let newArr3 = arr4.filter(item => item)
console.log(newArr3); //[‘1’, ‘2’, ‘3.jpg’]
filter() 筛选数组对象
单个条件筛选：筛选出对象.a属性不等于苹果的对象汇合
复制代码
let arr = [
{a:'苹果',b:'面包',c:'吃'},
{a:'香蕉',b:'面包',c:'不吃'},
{a:'香蕉',b:'苹果',c:'吃'},
{a:'苹果',b:'香蕉',c:'不吃'},]
let newarr8 = arr7.filter((value, index, arr) => {
return value.a != ‘苹果’
})
console.log(newarr8) //[{a:’香蕉’,b:’面包’,c:’不吃’},{a:’香蕉’,b:’苹果’,c:’吃’}]
复制代码
多个筛选条件：筛选数组对象中a属性是苹果，b属性是面包的对象汇合：
复制代码
let a = ‘苹果’; //筛选参数a
let b = ‘面包’; //筛选参数b
let c = ” //筛选参数c
let arr = [
{a:'苹果',b:'面包',c:'吃'},
{a:'香蕉',b:'面包',c:'不吃'},
{a:'香蕉',b:'苹果',c:'吃'},
{a:'苹果',b:'香蕉',c:'不吃'},];
if (a != ”) {
arr = arr.filter(item => item.a === a)}
if (b != ”) {
arr = arr.filter(item => item.b === b)}
if (c != ”) {
arr = arr.filter(item => item.c === c)}
console.log(arr) // 筛选后果: [{a:’苹果’,b:’面包’,c:’吃’}]
原文：https://www.cnblogs.com/wangw…
发表回复