JS基础知识查漏补缺二（函数）

1.函数的定义

两种方式定义函数：
function func(x){}
let func = function(x){};
两种方式完全等价，第二种相当于先声明了一个匿名函数，然后将引用赋值给func。
JS会默认给每一行加一个分号，所以写return的时候要注意，不能这么写：
function func(x){
    return
    {'some code'}    
}

 2.函数的参数

       JS的函数可以传多于定义的参数，也可以传少于定义的参数，因此要注意，另外JS提供了一个原生的arguments参数，用于获取传到函数中的参数。

function func(x) {
    console.log(arguments.length);
}
func(1,2,3); //3,arguments=[1,2,3]
func(); //0,arguments=[]
func(1); //1,arguments=[1]

 3.rest参数

由于JavaScript函数允许接收任意个参数，于是我们就不得不用arguments来获取所有参数：
function foo(a, b) {
    var i, rest = [];
    if (arguments.length > 2) {
        for (i = 2; i<arguments.length; i++) {
            rest.push(arguments[i]);
        }
    }
    console.log('a = ' + a);
    console.log('b = ' + b);
    console.log(rest);
}
为了获取除了已定义参数a、b之外的参数，我们不得不用arguments，并且循环要从索引2开始以便排除前两个参数，这种写法很别扭，只是为了获得额外的rest参数，有没有更好的方法？

ES6标准引入了rest参数，上面的函数可以改写为：
function foo(a, b, ...rest) {
    console.log('a = ' + a);
    console.log('b = ' + b);
    console.log(rest);
}

foo(1, 2, 3, 4, 5);
// 结果:
// a = 1
// b = 2
// Array [ 3, 4, 5 ]

foo(1);
// 结果:
// a = 1
// b = undefined
// Array []
rest参数只能写在最后，前面用...标识，从运行结果可知，传入的参数先绑定a、b，多余的参数以数组形式交给变量rest，所以，不再需要arguments我们就获取了全部参数。如果传入的参数连正常定义的参数都没填满，也不要紧，rest参数会接收一个空数组（注意不是undefined）。

3. 高阶函数(Array中)（map(),filter(),reduce(),sort(),every(),find(),findIndex(),forEach()）

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

先看几个例子：

// 看上去正常的结果:
['Google', 'Apple', 'Microsoft'].sort(); // ['Apple', 'Google', 'Microsoft'];

//apple排在了最后，是因为字符串根据ASCII码进行排序，而小写字母a的ASCII码在大写字母之后。
['Google', 'apple', 'Microsoft'].sort(); // ['Google', 'Microsoft", 'apple']

//这是因为Array的sort()方法默认把所有元素先转换为String再排序，结果'10'排在了'2'的前面，因为字符'1'比字符'2'的ASCII码小
[10, 20, 1, 2].sort(); // [1, 10, 2, 20]

        如果不知道sort()方法的默认排序规则，直接对数字排序，绝对栽进坑里！幸运的是，sort()方法也是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序。

比较函数应该具有两个参数 a 和 b，其返回值如下：

若 a 小于 b，即 a - b 小于零，则返回一个小于零的值，数组将按照升序排列。

若 a 等于 b，则返回 0。

若 a 大于 b, 即 a - b 大于零，则返回一个大于零的值，数组将按照降序排列。

要按数字大小排序，我们可以这么写：

let func = function(a,b){
    return (a-b);
}
[100,2,1,200].sort(func); //[1,2,100,200]

every()方法 

例如，给定一个包含若干字符串的数组，判断所有字符串是否满足指定的测试条件：

[100,2,1,200].every((x)=>x>0) //true
[100,2,1,200].every((x)=>x>100) //false

 find()方法和findIndex()方法

//find()方法用于查找符合条件的第一个元素，如果找到了，返回这个元素，否则，返回undefined：
var arr = ['Apple', 'pear', 'orange'];
console.log(arr.find(function (s) {
    return s.toLowerCase() === s;
})); // 'pear', 因为pear全部是小写
console.log(arr.find(function (s) {
    return s.toUpperCase() === s;
})); // undefined, 因为没有全部是大写的元素

//findIndex()和find()类似，也是查找符合条件的第一个元素，不同之处在于findIndex()会返回这个元素的索引，如果没有找到，返回-1：
var arr = ['Apple', 'pear', 'orange'];
console.log(arr.findIndex(function (s) {
    return s.toLowerCase() === s;
})); // 1, 因为'pear'的索引是1
console.log(arr.findIndex(function (s) {
    return s.toUpperCase() === s;
})); // -1

generator函数(http://es6.ruanyifeng.com/#docs/generator)

       Generator 函数的调用方法与普通函数一样，也是在函数名后面加上一对圆括号。不同的是，调用 Generator 函数后，该函数并不执行，返回的也不是函数运行结果，而是一个指向内部状态的指针对象（Iterator ）。

       下一步，必须调用遍历器对象的next方法，使得指针移向下一个状态。也就是说，每次调用next方法，内部指针就从函数头部或上一次停下来的地方开始执行，直到遇到下一个yield表达式（或return语句）为止。换言之，Generator 函数是分段执行的，yield表达式是暂停执行的标记，而next方法可以恢复执行。

       yield表达式后面的表达式，只有当调用next方法、内部指针指向该语句时才会执行，因此等于为 JavaScript 提供了手动的“惰性求值”（Lazy Evaluation）的语法功能。

const newgener = function* (data) {
  yield data;
  yield data+1;
  yield data+2;
  return data;
}
let newgener1 = newgener(10);
console.log('1',newgener1.next())
console.log('2',newgener1.next())
console.log('3',newgener1.next())
console.log('4',newgener1.next())  
console.log('5',newgener1.next())
/*
1 { value: 10, done: false }
2 { value: 11, done: false }
3 { value: 12, done: false }
4 { value: 10, done: true }
5 { value: undefined, done: true }

*/

Generator 函数可以不用yield表达式，这时就变成了一个单纯的暂缓执行函数。

function* f() {
  console.log('执行了！')
}

var generator = f();

setTimeout(function () {
  generator.next()
}, 2000);

上面代码中，函数f如果是普通函数，在为变量generator赋值时就会执行。但是，函数f是一个 Generator 函数，就变成只有调用next方法时，函数f才会执行。