JS基础 - 函数

2019-11-01

frontEnd

函数的 5 种声明

具名函数

function f(x,y){
  return x+y
}
f.name // 'f'

匿名函数

var f
f = function(x, y){
	return x+y
}
f.name //'f'

具名函数赋值

var f
f = function f2(x,y){ return x+y }
f.name // 'f2'
console.log(f2) // undefined

Window.Function

1
2
3

window.Function
var f = new Function('x','y','return x+y')
f.name // "anonymous"

箭头函数

var f = (x,y) => {
  return x+y
}

var sum = (x,y) => x+y

var n2 = n => n*n

如何调用函数

1	f.call(asThis, input1,input2)

其中 asThis 会被当做 this，[input1,input2] 会被当做 arguments

禁止使用 f(input1, input2)

this 和 arguments

function f(){
    'use strict'
    console.log(this)
    console.log(arguments)
    return undefined
}
f.call(1,2,3) // this 为 1，arguments 为 [2,3]

什么是 call stack

· 普通调用

· 嵌套调用

· 递归调用

作用域

按照语法树，就近原则。

我们只能确定变量是哪个变量，但是不能确定变量的值

面试题1

var a = 1

function f1(){
  alert(a) // 是多少
  var a = 2
}

f1.call()

面试题2

var a = 1

function f1(){
  var a = 2
  f2.call()

}

function f2(){
  console.log(a) // 是多少
}
f1.call()

面试题3

var liTags = document.querySelectorAll('li')

for(var i = 0; i<liTags.length; i++){
  liTags[i].onclick = function(){
    console.log(i) // 点击第3个 li 时，打印 2 还是打印 6？
  }
}

闭包

什么是「闭包」。
「闭包」的作用是什么。

什么是闭包

var local = '变量'

function foo() {
	console.log(local)
}

上面三行代码在一个立即执行函数中。

三行代码中，有一个局部变量 local，有一个函数 foo，foo 里面可以访问到 local 变量。

好了这就是一个闭包：

「函数」和「函数内部能访问到的变量」（也叫环境）的总和，就是一个闭包。

「我听说闭包是需要函数套函数，然后 return 一个函数的呀！」

比如这样：

function foo(){
  var local = 1
  function bar(){
    local++
    return local
  }
  return bar
}

var func = foo()
func()

这里面确实有闭包，local 变量和 bar 函数就组成了一个闭包（Closure）。

为什么要函数套函数呢？

是因为需要局部变量，所以才把 local 放在一个函数里，如果不把 local 放在一个函数里，local 就是一个全局变量了，达不到使用闭包的目的——隐藏变量（等会会讲）。

这也是为什么我上面要说「运行在一个立即执行函数中」。

有些人看到「闭包」这个名字，就一定觉得要用什么包起来才行。其实这是翻译问题，闭包的原文是 Closure，跟「包」没有任何关系。

所以函数套函数只是为了造出一个局部变量，跟闭包无关。

为什么要 return bar 呢？

因为如果不 return，你就无法使用这个闭包。把 return bar 改成 window.bar = bar 也是一样的，只要让外面可以访问到这个 bar 函数就行了。

所以 return bar 只是为了 bar 能被使用，也跟闭包无关。

闭包的作用

闭包常常用来「间接访问一个变量」。换句话说，「隐藏一个变量」。

假设我们在做一个游戏，在写其中关于「还剩几条命」的代码。

如果不用闭包，你可以直接用一个全局变量：

1	window.lives = 30 // 还有三十条命

这样看起来很不妥。万一不小心把这个值改成 -1 了怎么办。所以我们不能让别人「直接访问」这个变量。怎么办呢？

用局部变量。

但是用局部变量别人又访问不到，怎么办呢？

暴露一个访问器（函数），让别人可以「间接访问」。

代码如下：

!function(){

  var lives = 50

  window.奖励一条命 = function(){
    lives += 1
  }

  window.死一条命 = function(){
    lives -= 1
  }

}()

简明起见，我用了中文 :)

那么在其他的 JS 文件，就可以使用 window.奖励一条命() 来涨命，使用 window.死一条命() 来让角色掉一条命。

所谓闭包的作用

如果我们在写代码时，根本就不知道闭包，只是按照自己的意图写，最后，发现满足了闭包的定义。

那么请问，这算是闭包的作用吗？

这个问题，留给你思考。

闭包谣言

闭包会造成内存泄露？

错。

说这话的人根本不知道什么是内存泄露。内存泄露是指你用不到（访问不到）的变量，依然占居着内存空间，不能被再次利用起来。

闭包里面的变量明明就是我们需要的变量（lives），凭什么说是内存泄露？

这个谣言是如何来的？

因为 IE。IE 有 bug，IE 在我们使用完闭包之后，依然回收不了闭包里面引用的变量。

这是 IE 的问题，不是闭包的问题。参见司徒正美的这篇文章。

编辑

目录