函数的环境
什么是函数？
最开始程序员写的程序大部分是汇编，后来有C语言C++等，这个阶段没有函数的概念，但有一个子程序的概念，（几行代码完成一个功能，给这几行代码起个名字，那时候不叫函数，叫子程序）
数学中的函数
数学中的函数有三个要素：定义域(A)，值域(B)，法则(f)
假设函数为f,假设输入A集合中的某个值，那么必定有一个输出B集合中的某个值
f(A[3])=B[3] //一旦规则确定，不管你输入多少次A[3],输出都是B[3]
f() //在数学中是不合法的，因为没有输入
如果你的函数符合数学函数的定义，就是函数式的
函数中的返回值是由什么确定的
调用时输入的参数params
定义时的环境env
闭包
闭包能让一个函数维持住一个变量，但并不能维持这个变量的值
对象也可以维持住一个变量，如果一门语言不支持闭包，你可以用对象
let obj = {
i: 0,
fn() {
this.i += 1
console.log(`我是obj的闭包i:${this.i}`)
}
}
const handle = function () {
let i = 0
return function () {
i++
console.log(`我是实例化的闭包i：${i}`)
}
}
obj.fn()
obj.fn()
let fn2 = handle()
fn2()
fn2()
this的值
如果你不知道什么是this
请参考阮一峰老师的文章
箭头函数this是环境,非箭头函数的this是一个隐式参数
const fn = function (p1, p2) {
console.log(this, p1, p2)
}
fn(1, 2)//隐式传参，不写会自动传undefined
fn.call(undefined, 1, 2)//显示传参，如果为undefined,浏览器会帮我们将this指向全局window
学会call，bind,apply等调用方法指定this，用来加深this的理解
你得知道函数是怎么调用的，你才能确定this的值
递归与记忆化
递归的特点就是自己调用自己，并且有一个结束条件，不然就是无限递归，永远无法拿到结果
所有的递归都可以用循环实现，我们可以认为尾递归是另一种for循环的写法
js中不管我们是否进行了尾递归优化，它都会帮我们压栈，我们可以使用memorize进行函数缓存
memorize实现
const memo = (fn) => {
function memoed(key) {
memoed.cache[key] = memoed.cache[key] || fn.apply(this, arguments)
return memoed.cache[key]
}
memoed.cache = {}
return memoed
}
const x = memo((x) => {
console.log('执行了')
return x * 2
})
console.log(x(1))//第一次进来打印执行了
console.log(x(1))//不会打印，说明没有再次执行传进去的函数，而是直接拿上次缓存的结果
console.log(x(1))//不会打印
console.log(x(1))//不会打印
console.log(x(2))//发现没有缓存，调用函数，缓存函数结果
柯里化
让所有的函数只接受一个参数
单一参数有什么意义？
？
怎么支持两个参数
使用闭包
const add = function (a){
return function(b){
return a+b
}
}
add(1)(2)//输出3
柯里化一个函数
const curring = (fn, params = []) => {
return (arg) => {
const newParams = params.concat(arg)
if (fn.length === newParams.length) {
return fn(...newParams)
} else {
return curring(fn, newParams)
}
}
}
const addTow = (a, b) => a + b
const addThree = (a, b, c) => a + b + c
const newAddTow = curring(addTow)
const newAddThree = curring(addThree)
console.log(newAddTow(1)(2))
console.log(newAddThree(1)(2)(3))
高阶函数
把函数作为参数或返回值的函数就是高阶函数
js内置的高阶函数
Function.prototype.bind
Function.prototype.apply
Function.prototype.call
Function.prototype.sort
Function.prototype.map
Function.prototype.filter
Function.prototype.reduce
function fn (){
console.log(this)
console.log(arguments)
}
bind.call(fn,{name:'tj'},2,3,4)
apply.call(fn,{name:'tj'},[2,3,4])
call.call(fn,{name:'tj'},2,3,4)
