ES6mapreducefiltersort箭头函数class继承yield

Posted tommymarc

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了ES6mapreducefiltersort箭头函数class继承yield相关的知识,希望对你有一定的参考价值。

map

var arr = [1,2,3,4,5,6,7,8,9];
var s = arr.map(String);
console.info(s)


function pow(x){
        return x * x;
}

var results = arr.map(pow);
console.info(results);


const arr =  [1,2,3,4,5,6,7,8,9];
const arr = arr.map(String);
console.log(s);

const results = arr.map(x=>x*x);
console.log(results)

//(9) ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
//(9) [1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce

这个函数必须接受连个参数,reduce()把结果继续和序列的下一个元素做累积计算

var func = function(x,y){
      return x + y;
}

var arr = [1,3,5,7,9];
var result = arr.reduce(func);

console.log(result)

const arr = [1,3,5,7,9];
const result = arr.reduce((x,y)=>x+y)
//结果是25

 

filter

和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是true还是false 决定 保留还是丢弃该元素

var arr = [1,2,4,5,6,9,10,15];
var r = arr.filter(function(x){
      return x%2 !== 0;
})
console.log(r);
const arr = [1,2,4,5,6,9,10,15];
const r = arr.filter(x => x%2 !== 0);
console.log(r);
//(4) [1, 5, 9, 15]

filter接受的回调函数,其实可以有多个参数。通常我们仅使用第一个参数,表示Array的某个元素。回调函数还可以接受另外两个参数,表示元素的位置和数组本身

var arr = [‘A‘,‘B‘,‘C‘];
var r = arr.filter(function(element,index,self){
      console.log(element); //  ‘A‘ , ‘B‘ , ‘C‘
      console.log(index);    //  0 , 1 , 2
      console.log(self);       //self 就是变量 arr
      return true;
});
console.log(r);

/* A 0
["A", "B", "C"] B 1
["A", "B", "C"] C 2
["A", "B", "C"]
["A", "B", "C"]
*/

sort

这是因为Array的sort()方法默认把所有元素先转换成String再排序,结果‘10‘排在‘2‘的前面,因为字符‘1‘比字符‘2‘的ASCII码小。

var arr = [10,20,1,2];

arr.sort(function(x,y){
      if(x < y){ return -1;}
      if(x > y){ return 1 ;}
      return 0 ;
});
console.log(arr)
var arr = [10,20,1,2];

arr.sort((x,y) => x > y ? 1 : x < y ? -1 : 0);

console.log(arr);

//
[1,2,10,20]

sort()方法会直接对Array进行修改,它返回的结果仍是当前Array

var a1 = ["B", "A", "C"];
var a2 = a1.sort();
a1;     //["A", "B", "C"];
a2;     //["A", "B", "C"];
a1 === a2;  //true     a1和a2是同一个对象

 

箭头函数

为什么叫Arrow Function? 因为它的定义用的是一个箭头:

x => x * x;

上面的箭头函数等同于

function (x){
      return  x * x;
}

我们还可以这样使用

//两个参数:
(x,y) => x * x + y * y


//无参数
() => 3.14

//可变参数: (x, y, ...rest) => { var i, sum = x + y; for(i=0;i<rest.length; i++){ sum += rest[i] } return sum; }

如果要返回一个对象

x => ({ foo: x})

箭头函数看上去是匿名函数的一种简写,但实际上,箭头函数和匿名函数有个明显的区别:箭头函数的内部的this是词法作用域,由上下文确定。

var obj = {
    birth: 1990,
    getAge: function () {
        var b = this.birth; // 1990
        var fn = function () {
            return new Date().getFullYear() - this.birth; // this指向window或undefined
        };
        return fn();
    }
};

var ret = obj.getAge()
console.info(ret)

//NaN
var obj = {
    birth: 1990,
    getAge: function () {
        var b = this.birth; // 1990
        var fn = () => new Date().getFullYear() - this.birth; // this指向obj对象
        return fn();
    }
};
var ret = obj.getAge(); 
console.info(ret)

//28

 

class继承

    class Student {
        constructor(name){
            this.name = name;
        }
        hello() {
            console.log(‘Hello, ‘ + this.name + ‘!‘ )
        }
    }
    var xiaoming = new Student(‘小明‘);
    xiaoming.hello();

    class PrimaryStudent extends Student {
        constructor(name,grade){
            super(name); //记得用super调用父级的构造方法
            this.grade = grade;
        }

        myGrade(){
            console.log(‘I am at grade ‘ + this.grade)
        }
    }

    var xiaohua = new PrimaryStudent(‘小华‘,1);
    xiaohua.hello();
    xiaohua.myGrade();

//Hello, 小明!
//Hello, 小华!
//I am at grade 1

 

yield

function * fibonacci(){
    yield 1;
    yield 2;
    return 2 ;
}

var it = fibonacci();
console.log(it);        //"Generator{  }"
console.log(it.next()); //1
console.log(it.next()); //2
console.log(it.next()); //undefined


var itt = fibonacci();
//而且Itrrator的return的值不会被for...of循环到,也不会被扩展符遍历到
for(var per of itt){
    console.log(per);
}

//fibonacci {<suspended>}
// {value: 1, done: false}
// {value: 2, done: false}
// {value: 2, done: true}
// 1
// 2
function * foo(){
    yield 0;
    yield 1;
}

function * bar(){
    yield ‘x‘;
    yield* foo();
    yield ‘y‘;
}
for(let v of bar()){
    console.log(v);
}

//x
//0
//1
//y

以上是关于ES6mapreducefiltersort箭头函数class继承yield的主要内容,如果未能解决你的问题,请参考以下文章

ES6学习--箭头函数

编程词汇

常用单词

实用编程英语

JavaScript中this的使用

程序员英语单词词汇