javascript 总结 -- 函数篇

看廖雪峰老师的js教程做的笔记
1. 函数定义，两种形式
- function f(a,b,c){….} 带名函数
- var f = function(a,b,c){…}; 匿名函数
2. 形参个数和实参个数不相同也没问题。 所以需要对参数个数进行检查。 每个函数都有一个argument参数，指向当前传入的参数列表，类似于Array。常用于判断传入参数的个数。rest参数 function f(a,b,…rest) {} rest参数必须写在最后，前面用…标识，可变参数列表，传进来的参数先绑定a，b，其余的参数以数组的形式传给rest。如果没有多余的参数，则rest=.
3. 可以用一个var声明函数内部定义的全部变量，js有变量提升的功能，把所有变量声明移到函数顶部，注意是声明，不是赋值。

var
 x = 1,//注意为 ，
 y = 2;

1. 全局作用域 window，不在任何函数内定义的变量默认具有全局作用域，js有一个全局对象window，全局作用域的变量实际上绑定到window的一个属性上。通过window.a（a为变量名）访问。
2. 减少冲突—- 名字空间：在自己的js文件中定义一个全局变量，自己的所有变量和函数全部绑定到自己定义的全局变量上。

var myNameSpace = {}; //自定义的全局变量
myNameSpace.name = "wangqi";//定义变量
myNameSpace.f = function(){};//定义函数

6.声明具有块级作用域的变量用let关键字，eg for()内部；声明常量用const关键字。const也只具有块级作用域。
7. 支持解构赋值：同时对一组变量进行赋值
对数组元素进行解构赋值的时候，多个元素必须用[]括起来。

var [a,b,c] = [1,2,4]; 
var [a,[b,c]] = [1,[2,4]];//也可以使用二维数组 对应赋值
var [,,a] = [1,2,4];//解构赋值可以忽略某些元素

解构赋值可以用于从一个对象中取出若干属性，属性用{}括起来

var penson = {
name:"xiaoming",
age:16,
address{
    city:"shanxi",
    street:"2"
},
id:"12"
}
var {name,age} = person;  //[属性名1，属性名2,..] = 对象名  name，age分别被赋值为对应的属性，若属性不存在，则返回undefined
var {name,age,address:{city,street}} = person;//对嵌套的对象属性进行赋值
var {name(原名字):name2(新名字),age} = person;//重命名，name被命名为name2
var {name,age = 20} = person;//使用默认值，如果有默认值则返回默认值，否则为undefined
var x,y;
{x,y} = {name:"Xiaoming",x:"1",y:"2"} //报错  对象赋值用{}
({x,y} = {...})//正确，若x，y提前定义了，则这样用，若不加(),{}会被当成代码块执行

解构赋值可以方便的用于交换变量 [x,y] = [y,x]；

1. js用{}括起来的为对象，用[]括起来的为数组
2. 在对象内部定义方法，this 指针的使用

var person = {
    name:"xiaoming",
    age:14,
    getAge : function(){return this.age} //getAge称为方法
};
person.getAge(); //执行正确 this指针指向了person变量

function getAge(){return this.age}; //直接调用getAge()返回奇怪的值
var person = {
    name:"xiaoming",
    age:14,
    getAge : getAge //调用person.getAge（）返回14
};

如果直接(单独)调用getAge，this指向了全局对象window，返回的是window.age
如果以对象形式调用 xiaoming.getAge()，this指向xiaoming
要保证this指向明确，必须用obj.f()的形式调用，
strict模式下，this始终指向undefined
若对象方法有嵌套，嵌套的方法内this也不指向该对象，指向window全局变量。
可以通过调用函数本身的apply()或者call()方法来规定this指针的指向。
apply()接受两个参数，第一个参数需要绑定的this变量，第二个参数是Array，表示函数本身的参数。
call()同apply(),只不过apply传入的是Array，而call按照顺序传入参数。
普通函数调用，将this绑定为null。

function getAge(){return this.age}; 
var person = {
    name:"xiaoming",
    age:14,
    getAge : getAge 
};
xiaoming.getAge(); //25
getAge.apply(xiaoming,[]) //无参数，传入空数组

1. 装饰器：用一个代码包装另外一个代码
   apply函数可以动态的改变函数的行为。
   修改内置函数。

"use srtict"  //使用strict模式
var oldParseInt = parseInt ; //将系统内置的函数parseInt赋值给oldParseInt
var count = 0;//这个count为全局变量
window.parenInt = function(){
    count += 1；
    return oldParseInt.apply(null,arguments);
    //这里必须调用apply，否则ParseInt本来的功能将失效
    //绑定的对象既可以为null，也可以为window
    //arguments参数为函数自带的变量，指向参数列表

}

贴几个博客吧，装饰器很重要，好好学
https://blog.csdn.net/qiqingjin/article/details/51344684
1. 高阶函数：一个函数接受另外一个函数作为参数。变量可以是函数名，函数名也就可以传入变量中。
2. array自带的map()函数：一次作用于array的每个元素，返回一个数组。array.map(f) f为函数名。array.map( function(x){return …;} )
array自带的reduce()函数，累积作用于array的两个元素，返回一个数值。[x1,x2,x3].reduce(f) == f(f(x1,x2),x3); array.reduce(function(x,y){return…;} )

//不要使用JavaScript内置的parseInt()函数，利用map和reduce操作实现一个string2int()函数：string2int("123") = 123;
"use strict";
funciton string2int(s){
    return s.split('').map(function(x){return x-'0';}).reduce(function(x,y){return x*10+y;})
    //s.split('')将字符串转换成数组 "123" => "1","2","3"
    //map(..)将字符转换成对应的数字 "1","2","3"=>1,2,3
    //reduce(..)将数字列表转换成整数 1,2,3 => 123
}

//请把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输
入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']。
function f(arr){
 return arr.map(function(x){ return x.slice(0,1).toUpperCase() +x.slice(1).toLowerCase();})
  //x.slice(0,1)函数获得首字母
  //x.slice(1)函数获取从位置1开始的全部字符串
 }

//找出bug
var arr = ['1', '2', '3'];
var t = arr.map(parseInt); 结果竟然是1, NaN, NaN
//reason:
arr.map（）会为 调用的函数 传入以下三个参数，
currentValue，数组中当前被传递的元素
index：数组中当前被传递的元素的索引
array：调用map方法的数组
而parseInt()需要两个参数，String和radix(基数)。值位于2~36之间。如果省略该值或者该值为0，则数字将以10进制进行解析，如果它以 “0x” 或 “0X” 开头，将以 16 为基数。 如果该参数小于 2 或者大于 36，则 parseInt() 将返回 NaN。如果currentValue的某位大于等于index，也会报NaN的错误。
所以实际上是执行了：
parseInt(‘1’,0,[‘1’,’2’,’3’]);//1
parseInt(‘2’,1,[‘1’,’2’,’3’]);//NaN
parseInt(‘3’,2,[‘1’,’2’,’3’]);//NaN
若arr = ['1','2','3','4']
则返回 1,NaN,NaN,2
改正方法：
r = arr.map(function(x) { return parseInt(x,10) });
或者
r = arr.map(function(x) { return parseInt(x) });

1. array自带的filter()函数，用于把array的某些元素过滤掉，作用于每个元素，根据结果为true/false选择是否保留该元素，返回一个数组。

//只保留偶数
var array = [1,2,3,4,5];
var r = arr.filter(function(x){return x%2 == 0});

//去除掉array的重复元素（完全可以放入set中）
var arr = [.....];
//和map、reduce相同传入的其实是三个参数
var r = arr.filter(function(element，index,array){
    return array.indexOf(element) == index;
})

//使用filter筛选出素数
"use strict";
function get_primes(arr){
     return arr.filter(function(element){
        if(element == 1){return false;}
        for(let i = 2; i < element; i++){
            if(element % 2 == 0){
                return false;   
            }
        }
        return true;
    });
}

array自带的sort()默认把元素转换成字符串之后按照ascII进行排序，可以自定义排序函数。
sort()会对array进行修改，map、reduce、filter不会。

//按照数字的大小排序
arr.sort(function(x,y){
    if(x<y){return -1;}
    if(x>y){return 1;}
    return 0;
})

闭包：在函数A中定义函数B，函数A返回函数B，每次调用函数A返回的函数B都不相同。
返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。(目测内部函数引用的外部变量只是指向了外部变量的地址)
感觉也不太懂这一块
创建一个匿名函数并立即执行 (function (x) { return x * x }) (3);

闭包的用处1：
function make_pow(n){
    return function(x){return Math.pow(x,n);}
}
var pow2 = make_pow(2);
pow2(3);//9
var pow3 = make_pow(3);
pow3(2);//8

箭头函数，类似于java的lambda表达式?

x => x*x;  //参数为x，函数体为 return x*x 只能包含一条语句
x => {复杂逻辑};//可以包含多条语句
(x,y) => x*x+y*y; //多个参数
(..) => {..} //多个参数+多条语句
()=>..  //无参数
（x,y,...rest） => .. //可变长参数
（）=>({})  //单表达式返回一个对象 ()=>{} {}代表对象和语句块冲突
var f = () => {} ;//标准形式

箭头函数完全修复了this的指向，this总是指向词法作用域，也就是外层调用者obj：，故在使用call()或者apply()函数时，第一个参数被省略，不起作用
箭头函数的this就是 他所在的函数 所在的 词法作用域中 的this
js中this的默认绑定规则是，谁调用了该变量(对象)，该变量(对象)的this就指向谁，
obj.f();
f()若为箭头函数，则f()中的this所在的函数为f(),f所在的词法作用域为obj，而obj的this指向调用obj的对象，显然 obj.f() 可以认为是 window.obj.f()
f()若为普通函数，则f()中的this指向调用f()的对象，也就是obj。
generator生成器：由function*定义，使用yield暂停执行返回，也可以使用return返回。同python中的生成器。
执行generator有多种方法：
- f.next()直到返回的done为true表示全部执行完，返回两个值 value和done
- 使用for…of循环，不需要判断done
generator可以在函数中执行多次，所以看上去好像一个可以记住状态的函数。