【基于 JS 函数式编程 - 2】高阶函数 | 函数代替数据传递 | 函数是一等公民 | 闭包 | 使用高阶函数实现抽象 | 数组的高阶函数

⭐️ 本文首发自 前端修罗场(点击即可加入)，一个专注 Web 技术、答疑解惑、面试辅导、职业发展的社区。

相关文章

• 【函数式编程】基于JS 进行函数式编程（一）引入 | 什么是函数式编程 | 函数式编程的优点
• 【函数式编程】基于JS进行函数式编程（二）高阶函数 | 函数代替数据传递 | 函数是一等公民 | 闭包 | 使用高阶函数实现抽象 | 数组的高阶函数
• 【函数式编程】基于JS进行函数式编程（三）柯里化 | 偏函数 | 组合与管道
• 【函数式编程】基于JS进行函数式编程（四）函子 | MayBe函子 | Monad函子

---

函数作为参数传递是js规范中的一部分。而，
允许以函数代替数据传递是一个值得关注的概念。

我们把接受函数作为其参数的函数称为高阶函数（HOC）。

理解函数代替数据传递

函数是一等公民

我们知道，js支持以下几种数据：

• Number
• String
• Boolean
• Object
• null
• undefined

但是，值得注意的是，函数也可以作为js的一种数据类型！所以，在js中与对String和Number类型的操作类似，我们可以把函数存入一个变量等方式进行传递。
那么，当一门语言允许函数作为任何其他数据类型使用时，函数就被称为“一等公民”。即，函数可被赋值给变量，作为参数传递，也可被其他函数返回。

(❤️ 现在关注【前端修罗场】，后台回复【666】，即可获取一份【免费的优质学习资料】,一起学习，一起进步~)

简言之，在js中我们就把 函数 理解为 数据 ！
既然它是数据，就可以把它存入一个变量，如：

let fn = () =>{} //fn是一个指向函数类型的变量 ,fn是函数的引用
fn(); //调用,指向fn指向的函数

• 那么，具体是怎么“传递函数”呢？
  我们看下面这段示例代码：

let fn = () => {console.log('本函数fn作为作为数据进行传递')}
let tellType = (arg) => {
	if(typeof arg === "function"){arg();}
	else {console.log('传递过来的数据是'+ arg)}
}
tellType(fn); //输出 ：本函数fn作为作为数据进行传递

• 那，怎么返回函数呢？

let fn = () => {return String}
fn(); //String() { [native code ]} //返回一个指向String函数的函数引用（fn值返回函数引用，并没有调用。）
fn()("abc"); //调用

由此可见，高阶函数式接受函数作为参数，并且/或者返回函数作为输出的函数。

闭包

高阶函数的运行机制，得益于js中的闭包。

什么是闭包

简言之，闭包是一个内部函数（即，是在另一个函数内部的函数）。

例如：

functioin outer() {
	function inner() {} //inner()就是一个闭包函数
}

之所以闭包函数强大，在于它对作用域链/层级的访问。
通常，闭包有3个可访问的作用域：

• 1、在闭包函数，自身之内声明的变量，如：

function outer() {
	function inner() { 
		let a = 5;
		console.log(a); 
	}
	inner();//调用inner函数，输出5。
}

值得注意的是：inner函数在outer函数外部是不可见的！

• 2、对全局变量的访问，如：

let global = 'global';
function outer() {
	function inner() { 
		let a = 5;
		console.log(global); 
	}
	inner();//调用inner函数，输出global。
}

• 3、对外部函数变量的访问（关键），该性质使得闭包函数变得非常强大！
  如：

let global = 'global';
function outer() {
	let outer = "outer";
	function inner() { 
		let a = 5;
		console.log(outer); 
	}
	inner();//调用inner函数，输出outer。
}

由此，我们将外部函数成为包裹闭包函数的函数。

闭包可记住它的上下文

先看一个示例代码：

let fn = (arg) => {
	let outer = "visible";
	let innerFn = () => {
		console.log(outer);
		console.log(arg);
	}
	return innerFn;
}
let closureFn = fn(5);
//1、fn被参数5调用，返回innerFn。当innerFn被返回时，
js执行引擎将innerFn作为一个闭包，并相应地设置它的作用域。
//2、返回函数的引用存储在closureFn中。当closureFn通过作用域链被调用时就记住了arg、outer值！

closureFn();//输出: visible 5

抽象

高阶函数通常用在能够抽象通用的问题。即，高阶函数就是在定义抽象。

抽象：是一种管理计算机系统复杂性的技术。它通过建立一个人与系统进行交互的复杂程序，把更复杂的细节抑制在当前水平之下。程序员应该使用理想的界面，并且可以添加额外级别的功能，否则处理起来将会复杂！

即，抽象让我们专注于预定的目标，而无须关心底层的系统概念。

使用高阶函数实现抽象

例如：

const forEach = (array,fn) => {
	for(let i=0;array.length;i++){
			fn(array[i]) 
	}
}
forEach([1,2,3],(data)=>{
//data作为参数从forEach函数传到当前的函数
});

//检查数组的内容是否为一个数字、自定义对象或其他类型
const every = (arr,fn) => {
	let result = true;
	for(const value of arr)
		result = result && fn(value);
	return result;
}
every([NaN,NaN,3],isNaN);//检查给定的数字中是否有NaN类型的内容

//some函数:如果数组中的一个元素通过传入的函数返回true，some函数就返回true
const some = (arr,fn) => {
	let result = false;
	for(const value of arr) 
		result = result || fn(value);
	return result;
}
some([NaN,NaN,3],isNaN);//true

//unary
const unary = (fn) => {
	fn.length === 1 ? fn : (arg) => fn(arg)
}
let res = ['1','2','3'].map(unary(parseInt)) 
console.log(res); //输出 [1,2,3]

//once
const once = (fn) => {
	let done = false;
	return function() {
		return done ? undefined: ((dine=true),fn.apply(this,arguments))
	}
}
//声明一个名为done的变量，初始值为false。返回的函数会形成一个覆盖它的闭包作用域。因此，返回的函数会访问并检查done是否为true，如果是，则返回undefined，否则将done设为true，并用必要的参数调用函数fn。

• 注：apply函数允许我们设置函数的上下文，并为给定的函数传递参数。

//memoized：使函数记住其计算结果
const memoized = (fn) => {
	const lookupTable = {};
	//返回函数将接受一个参数并检查它是否在lookupTable中，如果在，返回对应的值，否则使用新的输入作为key，fn的结果作为value，更新lookupTable对象
	return (arg) => lookupTable[arg] || (lookupTable[arg] = fn(arg));
}
let fastFactorial = memoized((n)=>{
	if(n===0){return 1;}
	return n* fastFactorial(n-1);
})

对数组有用的高阶函数

在js中，常需要对数组进行遍历。同时我们也使用数组进行存储、操作和查找以及转换数据格式等操作。

那么，在函数式编程中有哪些对数组有用的高阶函数呢？

map

forEach函数隐藏了遍历的通用问题，但是我们不能在所有的情况下都是用forEach。例如：假设把所有的数组内容都平方并在一个新的数组中返回。通过forEach要如何实现？forEach只能执行传入的函数，不能用来返回数据。
所以，这里我们想到map。

const map = (array,fn) => {
	let results = []
	for(const value of array)
		results.push(fn(value));
	return results;
}
map([1,2,3],(x)=>x*x); //[1,4,9]

filter

//筛选数组
const filter = (array,fn) => {
	let results = []
	for(const value of array)
		(fn(value)) ? results.push(value) : undefined;
	return results;
}
filter([{"rating":[4.5]},{"rating":[4.6]},{"rating":[3.5]}],(item)=>item.rating[0]>4.5); //[{"rating":[4.6]}]

concatAll

//把所有嵌套数组连接到一个数组中
const concatAll = (array,fn) => {
	let results = []
	for(const value of array)
		results.push.apply(results,value);
	return results;
}

reduce

• 归约操作：对所有数组重复某个过程

//1、当initivalValue未定义时，我们从第二个元素开始循环数组，将它作为累加器的初始值。
//2、如果initivalValue由调用者传入，就需要遍历整个数组。
const reduce = (array,fn,initivalValue) => {
	let accumlator ;
	if(initivalValue !=undefined)
		accumlator = initivalValue;
	else 
		accumlator = array[0];
	if(initivalValue === undefined)
		for(let i=1;i<array.length;i++)
			accumlator = fn(accumlator,array[i])
	else
		for(const value of array) 
			accumlator = fn(accumlator,value)
	return [accumlator]
}
reduce([1,2,3],(acc,val)=>acc+val) //[6]
reduce([1,2,4],(acc,val)=>acc*val,1) //[8]

zip

• 合并两个给定的数组

const zip = (leftArr,rightArr,fn) => {
	let index,results = [];
	for(index=0;index<Math.min(leftArr.length,rightArr.length);index++)
		results.push(fn(leftArr[index],rightArr[index]));
	return results;
}
zip([1,2,3],[4,5,6],(x,y)=>x+y); //[5,6,7]