高阶函数、模板字面量、标签函数、解构赋值

一、高阶函数

定义：使用函数作为参数或者将函数做为返回值

//定义一个函数
        //作为参数的函数
        let a=()=>console.log("作为参数的函数调用了");
        //需要调用的函数
        function demo(f){
            f();
            console.log("demo函数调用");
            return ()=>console.log("返回的函数调用了");
        }
        // 调用函数
        demo(a)();

1.回调函数

定义:函数的名字作为另外一个函数的参数传入，叫做回调函数

       function hello()
       {
          console.log("作为参数的函数调用了");
       }
       function demo(f){
            f();
            console.log("demo函数调用");
        }
        demo(a);//回调函数

       function hello()
       {
          console.log("作为参数的函数调用了");
       }
       function demo(){
            hello();
            console.log("demo函数调用");
        }
        demo();//这只是在一个参数内调用另一个参数

2.偏函数

定义:将一个函数的多个参数，分多次传入，每次传入都返回一个函数已来接受多个参数，循环往复，直到接受完所有的参数

    //常规函数接收多个参数
    function sum(a,b,c,d,e){
    return a+b+c+d;
    }
    //利用偏函数,这里以每次接受两个为例
    let sum_1 = function(a,b){
          return function(c,d){
                   return a+b+c+d;
                  }
    }
    console.log(sum_1(10,20)(30,40));
    //上述例子利用箭头函数简化
    let sum_2 =(a,b)=>(c,d)=>a+b+c+d;
    console.log( sum_2(10,20)(30,40));

3.函数柯里化

定义:将函数的参数传入时，每次只能传入一个参数，也就是特殊的偏函数

   sum =function sum(a){
         return function(b){
                return function(c){
                       return function(d){
                          return a+b+c+d;
                       }
                }
         }
   }
   console.log(sum(10)(20)(30)(40));
   //箭头函数
   sum_1 = a => b=>c => d => a+b+c+d;
   console.log(sum_1(10)(20)(30)(40));

4.纯函数

定义:函数内部只是用形参，不使用函数外的参数

      let [a,b,c,d]=[10,20,30,40];
      //这个纯函数
      function sum(a1,b1){
          console.log(a1+b1);
      }
      sum(a,b);
      //这个不是纯函数，这个是用来了函数外部的变量
      function sum_1(a1,b1){
          console.log(a1+b1+d);
      }
      sum_1(a,b);

二、值传递与引用传递

1.值传递（适用于基本数据类型）

    let a =10;
    let b =a;
    console.log(a,b);
    a = 20;
    console.log(a,b);

2.引用传递（适用于对象、数组）

a.数组

//与上面的例题进行对比，一道迷惑的题目
var a = [1,2,3];
var b = a;
a = [4,5,6];
alert(b);

看完下面可能有所了解：

     let a=[10,20,30,40];
     let b=a;//将a的地址赋值给b，引用传递
     console.log(a,b); //[10,20,30,40] [10,20,30,40]
     let c=[10,20,30,40];
     let d=c;
     c = [10,30];//将c指向了[10,30]所在的地址
     console.log(c,d);//c:[10,30]  d:[10,20,30,40]
     let e =[10,20,30,40];
     let f =e;
     e.pop();
     console.log(e,f);//e,f:[10,20,30]

b.对象

  let obj1 ={name:"张三",age:18};
    //  访问方式
     console.log(obj1.name,obj1.age);
     console.log("%o",obj1);
   //引用传递
    let obj2 =obj1;
    console.log("%o",obj2);//{name: "张三", age: 18}
    obj1.name="王五";
    console.log("%o",obj1);//{name: "王五", age: 18}
    console.log(obj1 === obj2);//true

函数传参

传参永远都是值传递

  let a =10;
  function sum(abc){
     console.log(abc);
     abc=20;
     console.log(abc);
  }
  sum(a);// 10 20
  console.log(a);//10

注意：

       // 深拷贝: 值传递
      // 浅拷贝: 引用传递

三、模板字面量

1.模板字符串语法

编写字符串时，通常使用 （ ' ）或者 （ " ）
        const str1 ='hello world';
        const str2 ="hello world";
使用模板字符串的语法是:
        const str3 =`hello world`;

2.字符串拼接

普通字符串：
var p = {
  name: 'Alfred',
  nn: 'Alfy',
};
console.log('Hi, I\'m ' + p.name + '! Call me "' + p.nn + '".');
模板字符串写法可以直接使用 ${value} 嵌入表达式：
console.log(`Hi, I'm ${p.name}! Call me "${p.nn}".`);

3.换行

普通字符串：
console.log("Dear Mom,\n" + 
"Hope you are well.\n" + 
"\tLove, your son");
模板字符串：
console.log(`Dear Mom,
Hope you are well.
    Love, your son`);

1.标签函数

第一个参数是被嵌入表达式分隔的文本的数组。
第二个参数开始是嵌入表达式的内容。

例1.
let a = 1;
let b = 2;
function tagFunction(strings, aVal, bVal, sumVal) {
    console.log(strings);
    console.log(aVal);
    console.log(bVal);
    console.log(sumVal);
    return 'hahah';
}
let tag = tagFunction`${a} + ${b} = ${a+b}`;
// ['', "+", "=", ''],标签函数接收的参数依次是原始字符串数组，每个表达式求值的结果
// 1
// 2
// 3
console.log(tag); // hahah
例2.
function hello(a){
    console.log("hee"+a);
}
hello("宁皓");
hello`宁皓`;

四、解构赋值

//多次赋值
        let [a,b,c]=[10,20,30];
        console.log(a);//10
        console.log(b);//20
        console.log(c);//30
//两个值交换
        [a,b]=[b,a];
        console.log(a);//20
        console.log(b);//10

//对象解构
        let item={name:"李四",age:15};
        let {name,age}=item;
        console.log(name);
        console.log(age);

五、对象字面量的简化

   let person ={
       name:"张三",
       age:18,
       getInfo:function(){
           return `${this.name} : ${this.age}`;
       }
   };
  let {name,age} =person;
//   console.log(name,age);
  //属性与变量保持一致时,属性直接简化
  let one={
       name,
       age,
       getInfo:function(){
           return `${this.name} : ${this.age}`;
       }
  };
  //对象的方法进行简化,删除:function()
  let two={
       name,
       age,
       getInfo(){
           return `${this.name} : ${this.age}`;
       }
  };