《深刻理解ES6》笔记——函数（3）

做为前端切图仔，愈加以为本身离不开函数了。

说到JavaScript函数，脑子里都是匿名函数、普通函数、闭包函数、构造函数......而后还能说出一大堆函数的概念。若是你达到这个水平，那么函数对你来讲没有难度，是一个前端老鸟了。

当我闭上眼睛，不看键盘，手指在键盘上敲击出一个排序函数的时候，我在想，仍是回顾一下函数的基本知识才有意思。

函数的默认参数

在ES5中，咱们给函数传参数，而后在函数体内设置默认值，以下面这种方式。

function a(num, callback) {
  num = num || 6
  callback = callback || function (data) {console.log('ES5: ', data)}
  callback(num * num)
}
a() //ES5: 36，不传参输出默认值

//你还能够这样使用callback
a(10, function(data) {
  console.log(data * 10) // 1000， 传参输出新数值
})

而在ES6中，咱们使用新的默认值写法。

function a(num = 6, callback = function (data) {console.log('ES6: ', data)}) {
  callback(num * num)
}

a() //ES6: 36， 不传参输出默认值

a(10, function(data) {
  console.log(data * 10) // 1000，传参输出新数值
})

使用ES6的默认值写法可让函数体内部的代码更加简洁优雅

默认值对arguments对象的影响

咱们先要了解arguments对象是什么？准确一点来讲它是一个类数组对象，它存在函数内部，它将当前函数的全部参数组成了一个类数组对象。

function a(num, b){
  console.log(arguments) // {"0": 6, "1": 10}
  console.log(arguments.length) // 2
}

a(6, 10)

上面的输出结果看起来很正常，那么，若是咱们加上参数默认值会怎样呢？

function a(num = 1, b = 1){
console.log(arguments)
}
a() // {} 默认值不能被arguments识别。
a(6, 10) // {"0":6,"1":10}

下面咱们看一下修改参数默认值对arguments的影响。

一、在ES5的非严格模式下，一开始输入的参数是1，那么能够获取到arguments[0]（表示第一个参数）全等于num，修改num = 2以后，arguments[0]也能更新到2。

function a(num){
  console.log(num === arguments[0]) //true
  num = 2 //修改参数默认值
  console.log(num === arguments[0]) //true
}
a(1)

二、在ES5的非严格模式下，arguments就不能在函数内修改默认值后跟随着跟新了。

"use strict"; //严格模式   
function a(num) {
  console.log(num === arguments[0]); // true
  num = 2;
  console.log(num === arguments[0]); // false
}
a(1);

在ES6环境下，默认值对arguments的影响和ES5严格模式是一样的标准。

默认参数表达式

参数不只能够设置默认值为字符串，数字，数组或者对象，还能够是一个函数。

function add() {
  return 10
}
function a(num = add()){
  console.log(num)
}
a() // 10

默认参数的临时死区

第一章咱们提到了let和const什么变量的临时死区（TDZ），默认参数既然是参数，那么也一样有临时死区，函数的做用域是独立的，a函数不能共享b函数的做用域参数。

//这是个默认参数临时死区的例子，当初始化a时，b尚未声明，因此第一个参数对b来讲就是临时死区。
function add(a = b, b){
  console.log(a + b)
}
add(undefined, 2) // b is not define

无命名参数

上面说的参数都是命名参数，而无命名参数也是函数传参时常常用到的。当传入的参数是一个对象，不是一个具体的参数名，则是无命名参数。

function add(object){
  console.log(object.a + object.b)
}
let obj = {
  a: 1,
  b: 2
}
add(obj) // 3

不定参数的使用：使用...（展开运算符）的参数就是不定参数，它表示一个数组。

function add(...arr){
  console.log(a + b)
}
let a = 1,b = 2
add(a, b) // 3

不定参数的使用限制：必须放在全部参数的末尾，不能用于对象字面量setter中。

//错误的写法1
function add(...arr, c){
  console.log(a + b)
}
let a = 1,b = 2,c = 3
add(a, b, c)

//错误的写法2
let obj = {
  set add(...arr) {
  
  }
}

ES6中的构造函数Function新增了支持默认参数和不定参数。

展开运算符（...）

展开运算符的做用是解构数组，而后将每一个数组元素做为函数参数。

有了展开运算符，咱们操做数组的时候，就能够再也不使用apply来指定上下文环境了。

//ES5的写法
let arr = [10, 20, 50, 40, 30]
let a = Math.max.apply(null, arr)
console.log(a) // 50

//ES6的写法
let arr = [10, 20, 50, 40, 30]
let a = Math.max(...arr)
console.log(a) // 50

块级函数

严格模式下：在ES6中，你能够在块级做用域内声明函数，该函数的做用域只限于当前块，不能在块的外部访问。

"use strict";
if(true) {
  const a = function(){
  
  }
}

非严格模式：即便在ES6中，非严格模式下的块级函数，他的做用域也会被提高到父级函数的顶部。因此你们写代码尽可能使用严格模式，避免这些奇葩状况。

箭头函数（=>）

若是看到你这里，你发现你尚未在项目中使用过箭头函数，不要紧，你并不low，而是学习不够努力。

const arr = [5, 10]
const s = arr.reduce((sum, item) => sum + item)
console.log(s) // 15

箭头函数和普通函数的区别是：

一、箭头函数没有this，函数内部的this来自于父级最近的非箭头函数，而且不能改变this的指向。

二、箭头函数没有super

三、箭头函数没有arguments

四、箭头函数没有new.target绑定。

五、不能使用new

六、没有原型

七、不支持重复的命名参数。

箭头函数的简单理解

一、箭头函数的左边表示输入的参数，右边表示输出的结果。

const s = a => a
console.log(s(2)) // 2

二、箭头函数中，最重要的this报错将再也不成为你天天都担忧的bug。

三、箭头函数还能够输出对象，在react的action中就推荐这种写法。

const action = (type, a) => ({
  type: "TYPE",
  a
})

四、支持当即执行函数表达式写法

const test = ((id) => {
  return {
    getId() {
      console.log(id)
    }
  }
})(18)
test.getId() // 18

五、箭头函数给数组排序

const arr = [10, 50, 30, 40, 20]
const s = arr.sort((a, b) => a - b)
console.log(s) // [10,20,30,40,50]

尾调用优化

尾调用是什么鬼？

尾调用是指在函数return的时候调用一个新的函数，因为尾调用的实现须要存储到内存中，在一个循环体中，若是存在函数的尾调用，你的内存可能爆满或溢出。

ES6中，引擎会帮你作好尾调用的优化工做，你不须要本身优化，但须要知足下面3个要求：

一、函数不是闭包

二、尾调用是函数最后一条语句

三、尾调用结果做为函数返回

一个知足以上要求的函数以下所示：

"use strict";   
function a() {
  return b();
}

下面的都是不知足的写法：

//没有return不优化
"use strict";
function a() {
  b();
}

//不是直接返回函数不优化
"use strict";
function a() {
  return 1 + b();
}

//尾调用是函数不是最后一条语句不优化
"use strict";
function a() {
  const s = b();
  return s
}

//闭包不优化
"use strict";
function a() {
  const num = 1
  function b() {
    return num
  }
  return b
}

尾调用实际用途——递归函数优化

在ES5时代，咱们不推荐使用递归，由于递归会影响性能。

可是有了尾调用优化以后，递归函数的性能有了提高。

//新型尾优化写法
"use strict";  
function a(n, p = 1) {
  if(n <= 1) {
    return 1 * p
  }
  let s = n * p
  return a(n - 1, s)
}
//求 1 x 2 x 3的阶乘
let sum = a(3)
console.log(sum) // 6

总结

函数这一章涉及到的知识点比较多，默认参数，命名参数，不定参数，展开运算符，箭头函数，尾调用优化。

第一次学习这些知识的人能够关注箭头函数和展开运算符的使用，这是最重要也最经常使用的知识，若是你已经在项目中使用过这些知识，那么做为巩固也是有帮助的，俗话说温故知新。

=> 返回文章目录