对于想了解js高级函数的读者，本文将是一篇不可错过的文章，我们将详细介绍js高级方法，并且为您提供关于9：偏函数，高级函数，匿名函数，参数推断，闭包，柯里化，控制抽象、C++高级函数技巧、excel高

对于想了解js高级函数的读者，本文将是一篇不可错过的文章，我们将详细介绍js高级方法，并且为您提供关于9： 偏函数，高级函数，匿名函数，参数推断，闭包，柯里化，控制抽象、C++ 高级函数技巧、excel高级函数怎么用、Head First C学习日志 第七章 高级函数 创建函数指针的有价值信息。

• js高级函数（js高级方法）
• 9： 偏函数，高级函数，匿名函数，参数推断，闭包，柯里化，控制抽象
• C++ 高级函数技巧
• excel高级函数怎么用
• Head First C学习日志 第七章 高级函数 创建函数指针

js高级函数（js高级方法）

1.判断数据类型时,我们最经常用typeof判断某一数据类型,缺点不能很好判断null,数组,正则,函数,因为这几个都是返回object,而Object.prototype.toString().call(value)很好解决了这个问题

var array = [1,2,3],
    nullobj = null,
    fn = function () {alert(1)},
    reg = /^[1-4]$/;
console.log(Object.prototype.toString.call(array)) // ''[object Array]''
console.log(Object.prototype.toString.call(nullobj)) // ''[object Null]''
console.log(Object.prototype.toString.call(fn)) // ''[object Function]''
console.log(Object.prototype.toString.call(reg)) // ''[object RegExp]''

2.函数绑定

例子2.1:

var btn = document.getElementById(''btn'')
var handler = {
    color:''red'',
    handleclick: function () {
     	console.log(this.color)
   }
}
btn.onclick = handler.handleclick // undefined,执行时this指的是DOM按钮

上面例子2.1中,this指向DOM按钮,要想this指向handler,可用闭包解决,如下例子2.2:

例子2.2:

var btn = document.getElementById(''btn'')
var handler = {
    color:''red'',
    handleclick: function () {
     	console.log(this.color)
   }
}
btn.onclick = function () {
     handler.handleclick() // red,执行时this指的是handler
}

此外,还可以写一个bind函数,可以将函数绑定到某个环境中,如下例子2.3

例子2.3:

var btn = document.getElementById(''btn'')
var handler = {
     color:''red'',
     handleclick: function (ev) {
     	console.log(ev.type)
     	console.log(this.color)
     }
}
     		
function bind(fn, context) {
     return function() {
     	return fn.apply(context,arguments) // 注意这里的arguments指的是内部函数的arguments,不是bind的
    }
}

btn.onclick = bind(handler.handleclick,handler) // 输出click和red

原生的bind与上面方法类似,都需要传入作为this的对象　

3.函数柯里化

　　函数柯里化指的是将能够接收多个参数的函数转化为接收单一参数的函数，并且返回接收余下参数且返回结果的新函数的技术。主要作用和特点就是参数复用、提前返回和延迟执行

　　创建函数柯里化的通用方式如下例子3.1

　　例子3.1:　　

function carry(fn) {
     // 获取第一个参数后的所有参数
     var args = Array.prototype.slice.call(arguments,1)
     return function () {
     	// 获取里面函数的所有参数
     	var innerargs = Array.prototype.slice.call(arguments,0)
     	// 合并参数
     	var totalargs = args.concat(innerargs)
     	return fn.apply(null,totalargs)
     }
}

例子3.2:典型应用,bind的实现

Function.prototype.bind1 = function (context) {
     var args = Array.prototype.slice.call(arguments, 1)
     var that = this
     return function () {
     	var innerargs = Array.prototype.slice.call(arguments, 0)
     	var totalargs = args.concat(innerargs)
     	that.apply(context, totalargs)
    }
}

var myobj = {
     color: ''red'',
     getColor: function (msg) {
     	console.log(msg+'':''+this.color)
     }
}
var btn = document.getElementById(''btn'')
btn.onclick = myobj.getColor.bind1(myobj,''hello'')

　例子3.3:经典面试,实现add(1, 2, 3, 4)=10,add(1)(2)(3)(4)(5)=15,add(1, 2, 3, 4)(5)(6)=21

function add() {
    // args用来收集所有的参数
    var args = Array.prototype.slice.call(arguments,0)
    function inner() {
        Array.prototype.push.apply(args, arguments)
        return inner
    }
    // 利用toString隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
    inner.toString = function () {
        return args.reduce(function (prev, now) {
            return prev + now
        })
    }
    return inner
}

9： 偏函数，高级函数，匿名函数，参数推断，闭包，柯里化，控制抽象

第十三章 函数式编程-高级

13.1 偏函数(partial function)

13.1.1 提出一个需求，引出思考

给你一个集合 val list = List(1, 2, 3, 4, "abc")，请完成如下要求:
1、将集合 list 中的所有数字 +1，并返回一个新的集合。
2、要求忽略掉 非数字 的元素，即返回的 新的集合 形式为 (2, 3, 4, 5)。

13.1.2 解决方式-filter + map 返回新的集合

13.1.3 解决方式-模式匹配

两种方式的示例代码如下：
示例代码如下：

package com.atguigu.chapter13

/**
  * 给你一个集合 val list = List(1, 2, 3, 4, "abc")，请完成如下要求:
  * 1、将集合 list 中的所有数字 +1，并返回一个新的集合。
  * 2、要求忽略掉 非数字 的元素，即返回的 新的集合 形式为 (2, 3, 4, 5)。
  */
object PartialFunDemo01 {
  def main(args: Array[String]): Unit = {
    // 思路1：filter + map 方式解决
    // 虽然可以解决问题，但是麻烦。
    val list = List(1, 2, 3, 4, "abc")
    // 先过滤，再map
    list.filter(f1)
    println(list.filter(f1).map(f2).map(f3)) // List(2, 3, 4, 5)

    // 思路2：模式匹配
    // 小结：虽然使用模式匹配比较简单，但是不够完美。
    val list2 = list.map(addOne2)
    println(list2) // List(2, 3, 4, 5, ())
  }

  // 模式匹配
  def addOne2(i: Any): Any = {
    i match {
      case x:Int => x + 1
      case _ =>
    }
  }

  // 将 List 转为 Any
  def f1(n: Any): Boolean = {
    n.isInstanceOf[Int]
  }

  // 将 Any 转为 Int [map]
  def f2(n: Any): Int = {
    n.asInstanceOf[Int]
  }

  def f3(n: Int): Int = {
    n + 1
  }
}

输出结果如下：

List(2, 3, 4, 5)
List(2, 3, 4, 5, ())

13.1.4 偏函数的基本介绍

13.1.5 偏函数的快速入门

示例代码如下：

package com.atguigu.chapter13

object PartialFunDemo02 {
  def main(args: Array[String]): Unit = {
    // 使用偏函数解决
    val list = List(1, 2, 3, 4, "hello")
    // 定义一个偏函数
    // 1. PartialFunction[Any, Int] 表示偏函数接收的参数类型是 Any，返回的类型是 Int
    // 2. isDefinedAt(x: Any) 如果返回 true，就会去调用 apply 构建对象实例，如果是 false，就过滤
    // 3. apply 构造器，对传入的值 + 1，并返回（新的集合）
    val addOne3 = new PartialFunction[Any, Int] {
      def isDefinedAt(any: Any) = if (any.isInstanceOf[Int]) true else false
      def apply(any: Any) = any.asInstanceOf[Int] + 1 // 将 any 显示转换成 Int
    }

    // 使用偏函数
    // 说明：如果是使用偏函数，则不能使用 map，应该使用 collect
    // 说明偏函数的执行流程
    // 1. 遍历 list 集合的所有元素
    // 2. 然后调用 val element = if(partialFun-isDefinedAt(list单个元素)) {partialFun-apply(list单个元素)}
    // 3. 每得到一个符合要求的元素 element，放入到新的集合，最后返回
    val list3 = list.collect(addOne3)
    println(list3) // List(2, 3, 4, 5)
  }
}

输出结果如下：

List(2, 3, 4, 5)

13.1.6 偏函数的小结

13.1.7 偏函数的简写形式

示例代码如下：

package com.atguigu.chapter13

/**
  * 偏函数简化形式
  */
object PartialFunDemo03 {
  def main(args: Array[String]): Unit = {
    // 使用偏函数的简化形式解决
    // 第一种简写形式：
    def f2: PartialFunction[Any, Int] = {
      case i: Int => i + 1 // case 语句可以自动转换为偏函数
      case j: Double => (j * 2).toInt
    }

    val list2 = List(1, 2, 3, 4, 5.6, "hello").collect(f2)
    println(list2) // List(2, 3, 4, 5, 11)

    // 第二种简写形式：
    val list3 = List(1, 2, 3, 4, "ABC").collect { case i: Int => i + 1 }
    println(list3) // List(2, 3, 4, 5)
  }
}

输出结果如下：

List(2, 3, 4, 5, 11)
List(2, 3, 4, 5)

13.2 作为参数的函数

1、基本介绍

2、快速入门案例
示例代码如下：

package com.atguigu.chapter13

object FunParameterDemo01 {
  def main(args: Array[String]): Unit = {
    def plus(x: Int) = 3 + x
    val result1 = Array(1, 2, 3, 4).map(plus(_))
    println(result1.mkString(",")) // (4,5,6,7)

    // 1. 在 scala 中，函数也是有类型，比如 plus 就是 <function1>
    println("puls的函数类型是" + (plus _))

  }
}

输出结果如下：

4,5,6,7
puls的函数类型是<function1>

3、应用案例小结

13.3 匿名函数

1、基本介绍

2、快速入门案例
示例代码如下：

package com.atguigu.chapter13

object AnonymouseFunctionDemo01 {
  def main(args: Array[String]): Unit = {
    // 对匿名函数的说明
    // 1. 不需要写 def 函数名
    // 2. 不需要写返回类型，使用类型推导
    // 3. =  变成  =>
    // 4. 如果有多行，则使用 {} 包括
    val triple = (x: Double) => 3 * x
    println(triple) // <function1>
    println(triple(3)) // 9.0
  }
}

输出结果如下：

<function1>
9.0

3、练习题
请编写一个匿名函数，可以返回2个整数的和，并输出该匿名函数的类型。
示例代码如下：

    val f1 = (n1: Int, n2: Int ) => {
      println("匿名函数被调用")
      n1 + n2
    }
    println("f1类型=" + f1) // f1类型=<function2>
    println(f1(10, 30)) // 40

13.4 高阶函数(higher-order function)

1、基本介绍
  能够接受函数作为参数的函数，叫做高阶函数 (higher-order function)。可使应用程序更加健壮。
2、高阶函数基本使用案例
扩展代码如下：

package com.atguigu.chapter13

object HigherOrderFunctionDemo01 {
  def main(args: Array[String]): Unit = {
    // test 就是一个高阶函数，它可以接收 f: Double => Double 和 f1: Double => Int
    def test(f: Double => Double, f1: Double => Int, n1: Double) = {
      f(f1(n1))
    }

    // sum 是接收一个 Double，返回一个 Double
    def sum(d: Double): Double = {
      d + d
    }

    def mod(d: Double): Int = {
      d.toInt % 2
    }

    val res = test(sum, mod, 5.0)
    println("res=" + res) // 2.0
  }
}

输出结果如下：

res=2.0

3、高阶函数可以返回函数类型
示例代码如下：

package com.atguigu.chapter13

object HigherOrderFunctionDemo02 {
  def main(args: Array[String]): Unit = {
    // 说明
    // 1. minusxy 是高阶函数，因为它返回匿名函数
    // 2. 返回的匿名函数是 (y: Int) => x - y
    // 3. 返回的匿名函数可以使用变量接收
    def minusxy(x: Int) = {
      (y: Int) => x - y // 匿名函数
    }

    // 分步执行
    // f1 就是 (y: Int) => 3 - y
    val f1 = minusxy(3)
    println("f1的类型=" + f1)
    println(f1(1)) // 2
    println(f1(9)) // -6

    // 也可以一步到位的调用（函数柯里化）
    println(minusxy(4)(9)) // -5
  }
}

输出结果如下：

f1的类型=<function1>
2
-6
-5

13.5 参数(类型)推断

1、基本介绍

2、应用案例
示例代码如下：

package com.atguigu.chapter13

object ParameterInferDemo01 {
  def main(args: Array[String]): Unit = {

    val list = List(1, 2, 3, 4)
    println(list.map((x: Int) => x + 1)) // (2,3,4,5)
    println(list.map((x) => x + 1)) // (2,3,4,5) 参数类型是可以推断时，可以省略参数类型。
    println(list.map(x => x + 1)) // (2,3,4,5) 当传入的函数，只有单个参数时，可以省去括号。
    println(list.map(_ + 1)) // (2,3,4,5) 如果变量只在=>右边只出现一次，可以用_来代替。

    println(list.reduce(f1)) // 10
    println(list.reduce((n1: Int, n2: Int) => n1 + n2)) // 10
    println(list.reduce((n1, n2) => n1 + n2)) // 10
    println(list.reduce(_ + _)) // 10
  }

  def f1(n1: Int, n2: Int): Int = {
    n1 + n2
  }
}

输出结果如下：

List(2, 3, 4, 5)
List(2, 3, 4, 5)
List(2, 3, 4, 5)
List(2, 3, 4, 5)
10
10
10
10

3、应用案例小结

13.6 闭包(closure)

1、基本介绍

2、应用案例小结

3、闭包的最佳实践
示例代码如下：

package com.atguigu.chapter13

/**
  * 请编写一个程序，具体要求如下：
  * 编写一个函数 makeSuffix(suffix: String) 可以接收一个文件后缀名(比如.jpg)，并返回一个闭包
  * 调用闭包，可以传入一个文件名，如果该文件名没有指定的后缀(比如.jpg)，则返回 文件名.jpg，如果已经有.jpg后缀，则返回原文件名。
  * 要求使用闭包的方式完成。
  * String.endsWith(xx)
  */
object ClosureDemo01 {
  def main(args: Array[String]): Unit = {
    // 使用并测试
    val f = makeSuffix(".jpg")
    println(f("dog.jpg")) // dog.jpg
    println(f("cat")) // cat.jpg

  }

  // 自定义的函数
  def makeSuffix(suffix: String) = {
    // 返回一个匿名函数，该匿名函数会使用外部函数的suffix，那么该函数和suffix整体形成一个闭包。
    (filename: String) => {
      if (filename.endsWith(suffix)) {
        filename
      } else {
        filename + suffix
      }
    }
  }
}

输出结果如下：

dog.jpg
cat.jpg

4、闭包的好处

13.7 函数柯里化(curry)

1、基本介绍

2、函数柯里化快速入门案例

3、函数柯里化最佳实践

示例代码如下：

package com.atguigu.chapter13

/**
  * 函数柯里化最佳实践
  * 比较两个字符串在忽略大小写的情况下是否相等，注意，这里是两个任务：
  * 全部转大写（或小写）
  * 比较是否相等
  * 针对这两个操作，我们用一个函数去处理的思想，其实也变成了两个函数处理的思想（柯里化）
  */
object CurryDemo02 {
  def main(args: Array[String]): Unit = {
    // 方式1：简单的方式，使用一个函数完成
    def eq(s1: String)(s2: String): Boolean = {
      s1.toLowerCase == s2.toLowerCase
    }
    println(eq("hello")("HELLO"))

    // 方式2：使用稍微高级的用法(隐式类)：形式为 str.方法()
    def eq2(s1: String, s2: String): Boolean = {
      s1.equals(s2)
    }
    // 隐式类：该隐式类扩展了String对象的功能
    implicit class TestEq(s: String) {
      // 体现了将比较字符串的事情，分解成两个任务完成：
      // 任务1：checkEq 完转换大小写
      // 任务2.：f函数完成比较任务
      def checkEq(ss: String)(f: (String, String) => Boolean): Boolean = {
        f(s.toLowerCase, ss.toLowerCase)
      }
    }
    val str1 = "hello"
    println(str1.checkEq("HeLLO")(eq2))

    // 方式2的简化写法
    str1.checkEq("HeLLO")((s1: String, s2: String) => { s1.equals(s2) })
    str1.checkEq("HeLLO")((s1: String, s2: String) => s1.equals(s2)) // 代码块只有一行代码时。可以省略{}
    str1.checkEq("HeLLO")((s1, s2) => s1.equals(s2)) // 参数类型是可以推断时，可以省略参数类型。
    str1.checkEq("HeLLO")(_.equals(_)) // 如果变量只在=>右边只出现一次，可以用_来代替。
  }
}

输出结果如下：

true
true

13.8 控制抽象函数

1、看一个需求

2、控制抽象基本介绍

3、快速入门案例
示例代码如下：

package com.atguigu.chapter13

object AbstractControlDemo01 {
  def main(args: Array[String]): Unit = {
    // myRunInThread 就是一个抽象控制函数，其参数是没有输入，也没有输出的函数 f1: () => Unit
    def myRunInThread(f1: () => Unit) = {
      new Thread {
        override def run(): Unit = {
          f1()
        }
      }.start()
    }

    myRunInThread {
      () =>
        println("干活咯！5秒完成...")
        Thread.sleep(5000)
        println("干完咯！")
    }

    // 简写形式
    def myRunInThread2(f1: => Unit) = {
      new Thread {
        override def run(): Unit = {
          f1
        }
      }.start()
    }

    // 对于没有输入，也没有返回值函数，可以简写成如下形式：
    myRunInThread2 {
      println("干活咯！5秒完成...~~~")
      Thread.sleep(5000)
      println("干完咯！~~~")
    }

  }
}

4、进阶用法：实现类似 while 的 mywhile 函数
示例代码如下：

package com.atguigu.chapter13

object AbstractControlDemo02 {
  def main(args: Array[String]): Unit = {
    var x = 10
    while (x > 0) {
      x -= 1
      println("x=" + x)
    }

    // 说明：实现类似 while 的 mywhile 函数
    // 1 函数名为 mywhile，实现了类似 while 循环的效果
    // 2. condition: => Boolean 是一个没有输入值，返回 Boolean 类型函数
    // 3. block: => Unit 没有输入值，也没有返回值的函数
    def mywhile(condition: => Boolean)(block: => Unit): Unit = {
      // 类似 while 循环，递归
      if (condition) {
        block // x=9 x=8 x=7 ...
        mywhile(condition)(block)
      }
    }

    x = 10
    mywhile(x > 0) {
      x -= 1
      println("x=" + x)
    }

  }
}

输出结果如下：

x=9
x=8
x=7
x=6
x=5
x=4
x=3
x=2
x=1
x=0
-----
x=9
x=8
x=7
x=6
x=5
x=4
x=3
x=2
x=1
x=0

本文同步分享在 博客“SoWhat1412”（CSDN）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

C++ 高级函数技巧

原文链接: C++ 高级函数技巧

上一篇: CodeForces 245G

下一篇: POJ 2785

获取两个集合的相同元素

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>

#define LL long long
int const MAX = 1e6 + 1;
int const INF = 1 << 30;
double const EPS = 0.00000001;
using namespace std;

int main(){
    vector<int> v1, v2;
    //0 1 2 3 4
    for(int i = 0 ; i < 5 ; i++)
        v1.push_back(i);
    //3 4 5 6 
    for(int i = 3 ; i < 7 ; i++)
        v2.push_back(i);

    int a[111], tmp = 0;
    tmp = set_intersection(v1.begin(), v1.end(),
                           v2.begin(), v2.end(), a) - a;
    cout << tmp << endl;
    return 0;
}

获取集合相同数字个数

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>

#define LL long long
int const MAX = 1e6 + 1;
int const INF = 1 << 30;
double const EPS = 0.00000001;
using namespace std;

int main(){

    int a[10] = { 1, 2, 3, 5, 6, 3, 2, 5, 4, 7 };

    sort(a, a + 10);
    int cnt = upper_bound(a, a + 10, 3) -
              lower_bound(a, a + 10, 3);
    cout << cnt << endl;
    return 0;
}

excel高级函数怎么用

excel 高级函数可处理复杂数据。要使用高级函数：输入函数名称、输入参数、按右括号。常见的高级函数包括财务、逻辑、查找和引用、数学和统计等函数。这些函数有助于计算贷款还款额、检查错误、查找数据、求和和统计指定条件的值，以及更多其他操作。

Excel高级函数的使用指南

Excel 中的高级函数可用于处理复杂数据并执行强大的计算。这些函数可帮助用户提高工作效率并从数据中获得更深入的见解。

如何使用高级函数？

要使用高级函数，请按照以下步骤操作：

1. 在单元格中输入函数名称，然后按左括号 (
2. 输入函数所需的参数，参数之间用逗号分隔
3. 按右括号 )

常见的高级函数

财务函数

• PMT：计算贷款或抵押贷款的每月还款额
• FV：计算未来价值，假设以固定利率投资
• PV：计算投资的现值

逻辑函数

• IFERROR：检查公式中是否存在错误，并在存在错误时返回指定的值
• ISERROR：检查特定单元格或范围中是否存在错误
• IFS：根据多个条件执行嵌套 IF 语句

查找和引用函数

• VLOOKUP：在垂直排列的数据表中查找指定值
• HLOOKUP：在水平排列的数据表中查找指定值
• INDEX：返回数据表中指定行或列的值

数学和统计函数

• SUMIF：基于指定条件对单元格求和
• AVERAGEIF：基于指定条件计算单元格的平均值
• COUNTIF：基于指定条件计数单元格
• MIN：返回指定值或单元格范围中的最小值
• MAX：返回指定值或单元格范围中的最大值

其他高级函数

• TEXTJOIN：将多个文本值连接成一个字符串
• FILTER：筛选数据并返回符合指定条件的行
• TRANSPOSE：将数据表从行转换为列，反之亦然

示例

假设您有一个包含客户销售记录的数据表。要计算每个客户的总销售额，您可以使用以下公式：

=SUMIF(A:A, D2, B:B)

其中：

• A:A 是包含客户名称的列
• D2 是您要查找的特定客户名称
• B:B 是包含销售额的列

通过使用这些高级函数，您可以高效处理复杂的数据，进行深入的数据分析，并从您的数据中获取有价值的见解。

以上就是excel高级函数怎么用的详细内容，更多请关注php中文网其它相关文章！

Head First C学习日志 第七章 高级函数 创建函数指针

1. 在c语言中，函数名也是指针变量

   函数名是指向函数的指针，当你创建一个叫test的函数的同时，也会创建一个test指针变量，变量中保存了函数的地址。该变量位于常量段。

2. 如何创建函数指针？
   

   假设我们有一个函数叫go_to_warp_speed，函数的定义是这样的。

   int go_to_warp_speed(int speed){}

   那么要创建指向它的函数指针则应该：

   
   

3. int (*warp_fn)(int);
   warp_fn=go_to_warp_speed;
   warp_fn(4);//相当于go_to_warp_speed(4)

4. 创建函数指针时，需要把函数的返回值类型和接收参数类型告诉c编译器。

例程：

寻找Mr.Right.以下是保存男生数据的字符串数组：

char *ADS[] = {
      "William: SBM GSOH likes sports, TV, dining",
      "Matt: SWM NS likes art, movies, theater",
      "Luis: SLM ND likes books, theater, art",
      "Mike: DWM DS likes trucks, sports and bieber",
      "Peter: SAM likes chess, working out and art",
      "Josh: SJM likes sports, movies and theater",
      "Jed: DBM likes theater, books and dining"
};

然后是查询条件，4个不同的函数，接收同样的参数类型，但是判断逻辑不同。

int sports_no_bieber(char *s) {
   return strstr(s, "sports") && !strstr(s, "bieber");
}

int sports_or_workout(char *s) {
   return strstr(s, "sports") || strstr(s, "working out");
}

int ns_theater(char *s) {
   return strstr(s, "NS") && strstr(s, "theater");
}

int arts_theater_or_dining(char *s) {
   return strstr(s, "arts") || strstr(s, "theater") || strstr(s, "dining");
}

查找函数，参数为一个函数指针int (*match)(char*)

void find(int (*match)(char *)) {
   int i;
   puts("Search results:");
   puts("----------------");
   for(i=0;i<NUM_ADS;i++){
      if(match(ADS[i]))
         printf("%s\n",ADS[i]);
   }
   puts("----------------");
}

会使用形参作为函数名直接传参进去，还记得吗，函数名是指向函数的指针。

主函数：

int main(){
   find(sports_no_bieber);
   find(sports_or_workout);
   find(ns_theater);
   find(arts_theater_or_dining);
   return 0;
}

在传参的时候，直接将函数名传入，没有任何修饰。

要点：

    函数名是指针。

    函数指针的声明要加括号，目的是保证*右结合，不确定符号优先级的情况下，加括号准没错。

    给函数指针赋值以后，函数指针可以像函数本身一样接收参数，因为函数名的本质也是指针，它们指向同一个函数。

    函数指针作为参数时，将函数名直接传入。

    几个概念要区分开，函数，函数名，函数指针。函数是执行运算的本体，函数名是指向函数的指针，函数指针可以用声明类型的函数赋值。

    在函数指针的调用，赋值等运算中，本质上传递的是函数的地址（个人理解），调用函数指针时，可以加*，给函数指针赋值时，可以用&函数名，来获取函数的地址，可以不写，便于阅读，c编译器可以识别。

附代码：https://github.com/AlexTuan1024/egsonhfc

我们今天的关于js高级函数和js高级方法的分享就到这里，谢谢您的阅读，如果想了解更多关于9： 偏函数，高级函数，匿名函数，参数推断，闭包，柯里化，控制抽象、C++ 高级函数技巧、excel高级函数怎么用、Head First C学习日志 第七章 高级函数 创建函数指针的相关信息，可以在本站进行搜索。