5.函数

1.函数参数

1.设置参数默认值在参数少传的情况下可以保证有值

    function fn(x="hello",y="haha") {
        console.log(x + y);
    }
    fn(1);//"1haha"

2.参数使用解构赋值

    function fn1({name="haha",age=19}) {
        // console.log(name);//如果没有传参{name="haha",age=19}=undefined  undefined不是对象 所以这一句会报错
     // fn1();

不传入参数

function fn2({name="hello",age=19}={}) {
    console.log(name, age);
    //如果没传参 {name="hello",age=19}={} 这一句不会报错  会使用默认值
}
fn2();//"hello" 19
fn3();//"hello" 19
function fn3({name,age}={name:"hello",age:19}) {
    //{name,age}={}
    console.log(name, age);
}
fn3({});//undefined undefined

当不传入任何参数的时候 fn2和fn3执行的结果是一模一样的使用默认值
但是在当传入空对象的时候fn2({})和fn3({})的结果却是不一样的
fn2中的name=”hello”,age=19}={} 传入空对象即为默认值

3.length属性

指的是形参的个数，

如果形参有默认值情况length就会失真，变成没有默认值形参的个数

    function fn4(x,y) {

    }
    console.log(fn4.length);//2

    function fn5(x,y=1) {

    }

    console.log(fn5.length);//1

关于参数默认值的位置:一般参数的默认值放在最后面
如果我想让第一个参数走默认值第二个参数走传递进的实参这么写显然是不行的会报错

    function fn6(x=10,y=20) {

    }
    // fn6(,1);//报错

正确方法：

function fn6(x=10,y=20) {
    console.log(x,y);
}
fn6(1)
//1 20

4. … 将函数剩下的参数变成数组，只能放到参数最后面

function sum(currency,...args){
    return currency+eval(args.join('+'));
}
console.log(sum('￥',1,2,3,4,5,6));

5.arguments

一个类数组

ES6中类似的使用方法

function fn7(...arg) {//展开参数
    console.log(arguments);
    console.log(arg);//根据解构赋值 除了arguments 我们也可以这样拿 实参
}
fn7(1,2,3,4,5);
//{ '0': 1, '1': 2, '2': 3, '3': 4, '4': 5 }
//[ 1, 2, 3, 4, 5 ]

6.参数作用域问题

函数执行的时候先给形参赋值形参也是私有变量如果给形参的默认值是一个变量先看是不是自己的私有变量不是自己的再找全局中是否有这个变量没有就报错

    let m=10,n=100;
    function fn8(x=m,y=n) {
        //私有作用域：私有变量 x,y,m,n
        //进入函数时先给形参赋值，给x赋值的时候还没有走到函数里面 所以会找到全局的
        console.log(x);
        console.log(y);
        let m = "haha";//改用var 结果与let一样
        let n = "ES6";
    }
    fn8();//10 100
    fn8(1);//1 100 说明默认值用的是全局的

若是注销函数外 m和n的声明会报错说明没有使用函数私有作用域中的m和n

    let x=100;
    function fn9(x,y=x) {
        //先进来给形参赋值找到了全局x=1，然后y=x=1
        console.log(y);//1
    }
    fn9(1);

2.函数name

1.匿名函数name

    console.log((function () {
    }).name);//""

2.特殊情况

1.通过bind方法得到一个新的函数 name是 “bound 原来函数的名字”

let fn1 = fn.bind(null);
console.log(fn1.name);//"bound fn"

2.通过构造函数方式创建一个函数它的名字是”anonymous”

new Function(“形参”,”函数体”)
new Function(“函数体”)
function fn(形参) {函数体}

let fn2 = new Function("x,y","console.log(x,y);return x+y;");
console.log(fn2(10, 100));//先执行 打印了10 100 然后打印了110
console.log(fn2.name);//anonymous

例题：如何将下面的JSON字符串变为JSON对象不使用JSON方法也不使用 eval方法

let str = '[{"name":"hello"},{"age":19}]';

let arr = (new Function("return"+str))();
//只写一个参数就是函数体  字符串可以拼接 "return [{"name":"hello"},{"age":19}]"
console.log(arr);// [{…}, {…}]
//[ { name: 'hello' }, { age: 19 } ]

3. 箭头函数

function a(){
    return {}
}
let a = ()=>({})
console.log(a());

function fn(a){
    return function(b){
        return a+b
    }
}
let fn = a=>b=>a+b;
fn(1)(2);

1.传统写法

function fn(x,y) {}

2.箭头函数，它是匿名函数

let fn = (x,y)=>{};

3.简写规则

假如函数体只有一行代码 : return xxx
可以省略{ }和return
形参只有一个可以省略小括号

let fn = x=>x+1;//相当于function (x){return x+1;}

4.使用场景

通常函数当做参数的时候(回调函数)使用箭头函数

let ary = [1,2,3,"haha"];
let a = ary.filter(item=>typeof item === "string");
console.log(a);//["haha"]

5.箭头函数没有this指向，它里面的this是上一级的作用域

let obj = {
    fn:function () {
        let f = ()=>{
            console.log(this);
        };
        f();
    }
};
obj.fn();//{fn: ƒ}

6.箭头函数没有arguments

let f1 = (...arg)=>{
    // console.log(arguments);
    console.log(arg);
};
// f1(1,23);//报错：arguments is not defined
f1(1,2,3);//[1, 2, 3]

7.箭头函数不可以用作构造函数因为不可以使用new执行

8.对象不是作用域 ,作用域之只有函数和{} 全局

let name = 1;
let obj = {
    name:2,
    fn:()=>{ // this
        console.log(this)
        console.log(this.name)
    }
}
obj.fn();

4. 展开运算符拓展运算符

… 的作用再我们的函数形参中是剩余运算符，把剩下的结果转化成数组

再对象中或数组中也可以用…

数组的拼接：

将非数组变成数组
将数组变成非数组
将类数组变为数组(具有length属性)

1.展开argument

    let str = "123";
    console.log([...str]);//["1", "2", "3"]
    console.log([...list.getElementsByTagName("li")]);//[li, li, li]

    function fn() {
        console.log([...arguments]);
    }
    fn(1,2,3,4);//[1, 2, 3, 4]

2.合并数组

    let arr1 = [1,2,3,4];
    let arr2 = [5,6,7,8];
    console.log(arr1.concat(arr2));//[1, 2, 3, 4, 5, 6, 7, 8]
    console.log([...arr1, ...arr2]);//[1, 2, 3, 4, 5, 6, 7, 8]

3.求最大值

求数组最大值,Math.max方法是不能直接传数组的，那我们就可以利用…方法来把它变成非数组

之前是想办法将它变为一个一个值，比如利用apply的方法将数组的值一个个传入

let arr = [1,2,3,4,5]
console.log(Math.min.apply(Math,arr));
console.log(Math.min(...arr));
//把arr的每一项作为函数参数一项项传入

function a(a,b){
    return a+b;
}
let fn = (n,b,c,...args)=>{
    console.log(a(...args))
}
fn(1,2,3,4,5);

…args

function a(a,b){
    return a+b;
}
let fn = (n,b,c,...args)=>{
    console.log(a(...args))
}
fn(1,2,3,4,5);