JavaScript ES6函数式编程入门经典

发布时间：2019年03月20日 14:27:32
作者：Anto
大小：46.3 MB
类别：JavaScript电子书
格式：PDF
版本：原书扫描版
评分：8.1

JavaScript ES6函数式编程入门经典 PDF 原书扫描版

给大家带来的一篇关于JavaScript相关的电子书资源，介绍了关于JavaScript、ES6、函数式编程方面的内容，本书是由清华大学出版社出版，格式为PDF，资源大小46.3 MB，Anto编写，目前豆瓣、亚马逊、当当、京东等电子书综合评分为：9.4。

内容介绍

JavaScript ES6函数式编程入门经典电子书封面

读者评价

非常不错的一本书，不到200页，言简意赅，可以领略函数式编程，初试函数式编程，强烈推荐。

全书共129页，第四章在60页json对象的java代码实现没有写，测试代码跑不通。

用了一段时间js，看看专业人士是怎么用的。言简意赅，有些代码需要多理解下。

比较基础，看完加练习2天时间足够，对函数式编程入门的同学很友好

内容介绍

《JavaScriptES6函数式编程入门经典》使用JavaScriptES6带你学习函数式编程。你将学习柯里化、偏函数、高阶函数以及Monad等概念。
目前，编程语言已经将焦点从对象转移到函数。JavaScript支持函数式编程，并允许开发者编写精心设计的代码。
主要内容
●掌握函数式编程的概念
●清楚函数在JavaScript中的地位
●理解真实的函数式类库，并创建一个模拟underscore.js的函数式类库
●实践纯错误处理技术，例如函子和Monad
●了解ES6的函数式编程特性，例如扩展运算符和Generator

内容节选

JavaScript ES6常用基础知识总结

ES6 let与const及其相关

块级作用域

ES6新增了块级作用域，总结一句话大致就是：大括号{}包起来的代码块基本山都可以当做块级作用域。

常见的有

直接使用{}包起来：

 {
 var a = 4
 }

函数体大括号，if-else大括号，for循环大括号，switch大括号，try-catch大括号等。需要注意的是，for循环，每一次循环时的{}都是一个独立的块级作用域。

 for(let i=0; a < 5; i++){
  let j = i
 }

上面代码循环了五次，实际上有五个独立的j。

日常开发中，我们就可以利用这个特性，来创建块级作用域了。

块级作用域变量let与const

使用let或const声明的变量只在当前块级作用域生效，出了这个代码块，就无法访问。

 {
  let a = 5
 }
console.log(a) 
// Uncaught ReferenceError: a is not defined

日常开发中，块级作用域中使用的变量，尽量使用let或者const声明。

需要注意的问题:

let和const变量一定要先声明，再使用，避免出错。不要试图利用变量提升的特性。
const声明变量时，一定要初始化，否则会报错。let建议也在声明时初始化。
const声明的变量一旦初始化，以后就不可以在进行赋值操作，但可以对其引用的对象进行更改。

 const noChangeMe; 
 // Uncaught SyntaxError: Missing initializer in const declaration
 const noChangeMe = [1,2,4]
 noChangeMe = [2, 3] 
 // Uncaught TypeError: Assignment to constant variable
 noChangeMe[100] = 100 // everything is OK

let和const声明的变量不能再重复声明。虽然var可以无限次重复声明，但是并不适用于这两个新的声明方式。

 let a = 1
 let a = 2 
 // Identifier 'a' has already been declared

不要用window.xxx去调用let与const声明的变量 ES6规定，let、const、class声明的全局变量，不属于顶层对象的属性。

String

使用反引号”`”
使用``将字符串包起来，可以解决下面的问题:

字符串不能换行，如果换行只能使用+号
字符串中的引号如果和最外层相同，需要进行转义
字符串中插入变量，需要用+号以前这样的写法:

 var name = 'world'
 var str = "小明说:\"hello, " + name + "\""  // 小明说:"hello, world"

现在可以方便的写作：

 var name = 'world'
 str str = `小明说："hello, ${name}"`

总的来说，有三个好处:

不怕字符串中出现的引号；
不怕换行，反引号包起来的字符串可以随便换行；
使用${}将变量或表达式包起来直接放在字符串中，不用写很多+

ES6 遍历字符串

使用for...of代替for循环:

 var string = 'string'
 for(var i of string) {
 console.log(i)
 }

includes(),startsWidth(),endsWidth()
不用使用indexOf()判断字符串中是否包含某个值了，使用includes():

 var string = 'string'
 string.includes('i'， 0)  // true

includes第二个参数表示查找的起始索引。还可以使用startsWidth()和endsWidth()判断字符串是否以某些字符开始或结尾。

ES6 函数

参数的默认值

方便地设置函数参数的默认值

 function print( a = 2 ){
 console.log(a)
 }
 print() //2

ES6 扩展运算符…获取其余参数

可以使用...加上变量名保存其他参数全部数量。当只知道函数的前几个具体参数，不确定之后会有多少个参数传入时，可以使用...把其他传入的参数保存到一个数组中。

 function print(value1, value2, ...values){
 console.log(values.join('--'))
 }
 print(1, 2, '参数3') // 参数3
 print(1, 2, '参数3', '参数4', '参数5') // print(1, 2, '参数3', '参数4', '参数5')

ES6 使用箭头函数

使用箭头函数有两个好处:

代码更加简洁
静态绑定this 箭头函数中，this指向的是定义箭头函数的对象中的this。

 var name = 'outer'
 var obj = {
  name: 'inner',
  func: () => {
  console.log(this.name)
  }
 }
 var obj2 = {
   name: 'inner',
   func: function() {
     console.log(this.name)
   }
 }
 obj.func() // "outer"
 obj2.func() // "inner"

第一个使用了箭头函数，由于箭头函数的this与其所在环境中的this相同，也就是与obj的this相同，而obj处于全局环境的活动对象中，this指向全局对象，这里指window，所以输出outer。注意:obj对象的this与它的属性中的this不一样。第二个使用了寻常函数，作为obj2的一个属性，func方法中的this指向了所在的对象。输出inner。

ES6 数组

使用Array.from()把类数组对象转为数组

一般来说，含有length属性的对象就可以当作类数组对象。平时获取多个DOM对象后，不能使用数组中的很多方法。我们可以使用Array.from方便的转换为数组,。

 var divs = Array.from(document.querySelectorAll('div'))
 divs.forEach((value, index) => {})

使用fill()初始化数组

想要以某个值初始化数组，需要遍历。而使用fill()方法，就方便了很多。

 var arr = new Array(100) // 建立一个100元素的数组
 arr.fill('初始值', 0, arr.length)

第一个参数是要填充的值，后面两个与一般的数组方法一样，起始索引和结束索引(不包括)。

使用includes方法

和字符串的includes方法一样，看数组中是否有给定值。

对象
使用简单的属性表示和方法表示

 var name = 'John'
 var a = {
 name: name,
 sayName: function(){ console.log(this.name) }
 }

改写为:

 var name = 'John'
 var a = {
 name,
 sayName () { console.log(this.name) }
 }

记得Object.is()这个方法
其与===的差别:

 NaN === NaN // false
 Object.is(NaN, NaN) // true

 -0 === +0  //true
 Object.is(+0, -0) // false
 Object.is(+0, 0) / true
 Object.is(-0, 0) / false

可以这样理解,遵循的原则: 是同一个东西就要相等。 NaN与NaN就是一个东西，而-0带了个负号，和0与+0不一样。0和+0相同就像1和+1相同一样。

使用Object.assign()合并多个对象

Object.assign()是用来合并对象的。assign，译作分配,指派。这个方法本意是将某些对象自己的属性拷贝到目标对象上。它不回去复制继承来的属性。比如可以在定义某个配置的时候，定义一个基础配置，在定义两个不同情况下的配置。使用时，进行合并。

 var pathConfig = {
 path: 'style/images'
 }
 var devConfig = {
 baseUrl: 'http://localhost:8080/'
 }
 var buildConfig = {
 baseUrl: 'https://192.128.0.2'
 }
 // 使用时，合并
 var mode = 'dev'
 var config = Object.assign({}, pathConfig, mode === 'dev' ? devConfig : buildConfig)

只是举个例子。

Object.keys()，Object.values()，Object.entries
这三个方法返回对象自身的，可枚举的，属性名为字符串的属性相关的东西，分别为：

Object.keys(): 属性名组成的数组
Object.values()： 属性值组成的数组
Object.entries: ["key", "value"]组成的数组。
 var john = {
 name: 'John',
 age: 12
 }
 Object.keys(john) // ["name", "age"]
 Object.values(john) // ["John", 12]
 Object.entries(john) // [["name", "John"], ["age", 12]]

ES6 ...运算符

前面在函数的剩余参数处理中提到了...扩展运算符。总结了一下，感觉有两个用法:

用来读取数组或者对象的时候，是把数组或对象给扩展开；
用来给对象或者数组赋值的时候，自动给对象或数组添加属性或元素。
用来读取
读取的时候就是把数组或者对象给扩展开来。

 var a = [...[1,2,3], 4] // 把数组的每一项都展出来
 a // [1, 2, 3, 4]
 var obj = {
 name: 'John',
 age: 12
 }
 var newObj = {...obj, job: 'teacher' } // 把某个属性展出来
 newObj // {name: "John", age: 12, job: "teacher"}

所以可以很方便的用来扩展，合并数组或对象。

用作赋值

用作赋值的时候，是用作解构赋值，含义就是把等号右边表达式的剩余属性或数组项都放到...后面的变量里。

var a, restB
 [a, ...restB] = [1, 3, 5]
 a // 1
 restB // [3, 5]

 var c, restD
 { name, ...restD } = {name: 'John', age: 12, job: 'teacher'}
 name // "John" 是一个属性的值
 restD // { c, ...restD } = {name: 'John', age: 12, job: 'teacher'} 是一个对象

对于对象的解构赋值，会把对应不到的属性全部放进...后面的变量对象中。

注意：因为是把剩下没人要的属性或者数组项都收下，所以...应该放在数组或者对象中的最后，且只能有一个。

以上即是ES6常用基础知识总结，希望对大家有所帮助

第1章　函数式编程简介 1
1.1 什么是函数式编程？为何它重要 1
1.2 引用透明性 4
1.3 命令式、声明式与抽象 5
1.4 函数式编程的好处 7
1.5 纯函数 7
1.5.1 纯函数产生可测试的代码 7
1.5.2 合理的代码 9
1.6 并发代码 10
1.7 可缓存 11
1.8 管道与组合 12
1.9 纯函数是数学函数 13
1.10 我们要构建什么 15
1.11 JavaScript是函数式编程语言吗 15
1.12 小结 16
第2章 JavaScript函数基础 17
2.1 ECMAScript历史 18
2.2 创建并执行函数 19
2.2.1 第一个函数 19
2.2.2 严格模式 21
2.2.3 return语句是可选的 22
2.2.4 多语句函数 22
2.2.5 函数参数 24
2.2.6 ES5函数在ES6中是有效的 24
2.3 设置项目 24
2.3.1 初始设置 24
2.3.2 用第一个函数式方法处理循环问题 26
2.3.3 export要点 28
2.3.4 import要点 28
2.3.5 使用babel-node运行代码 29
2.3.6 在npm中创建脚本 30
2.3.7 从git上运行源代码 31
2.4 小结 31
第 3 章高阶函数 33
3.1 理解数据 34
3.1.1 理解JavaScript数据类型 34
3.1.2 存储函数 35
3.1.3 传递函数 35
3.1.4 返回函数 37
3.2 抽象和高阶函数 38
3.2.1 抽象的定义 38
3.2.2 通过高阶函数实现抽象 39
3.3 真实的高阶函数 42
3.3.1 every函数 42
3.3.2 some函数 44
3.3.3 sort函数 44
3.4 小结 48
第 4 章闭包与高阶函数 49
4.1 理解闭包 50
4.1.1 什么是闭包 50
4.1.2 记住闭包生成的位置 52
4.1.3 回顾sortBy函数 53
4.2 真实的高阶函数（续） 54
4.2.1 tap函数 54
4.2.2 unary函数 56
4.2.3 once函数 57
4.2.4 memoized函数 58
4.3 小结 60
第 5 章数组的函数式编程 61
5.1 数组的函数式方法 62
5.1.1 map 62
5.1.2 filter 65
5.2 连接操作 67
5.3 reduce函数 71
5.4 zip数组 77
5.5 小结 81
第 6 章柯里化与偏应用 83
6.1 一些术语 84
6.1.1 一元函数 84
6.1.2 二元函数 84
6.1.3 变参函数 84
6.2 柯里化 86
6.2.1 柯里化用例 87
6.2.2 日志函数——应用柯里化 89
6.2.3 回顾curry 90
6.2.4 回顾日志函数 93
6.3 柯里化实战 94
6.3.1 在数组内容中查找数字 94
6.3.2 求数组的平方 95
6.4 数据流 96
6.4.1 偏应用 96
6.4.2 实现偏函数 97
6.4.3 柯里化与偏应用 99
6.5 小结 100
第7章组合与管道 101
7.1 组合的概念 102
7.2 函数式组合 104
7.2.1 回顾map与filter 104
7.2.2 compose函数 106
7.3 应用compose函数 106
7.3.1 引入curry与partial 108
7.3.2 组合多个函数 111
7.4 管道/序列 113
7.5 组合的优势 114
7.5.1 组合满足结合律 114
7.5.2 使用tap函数调试 115
7.6 小结 116
第8章函子 117
8.1 什么是函子 118
8.1.1 函子是容器 118
8.1.2 函子实现了map方法 120
8.2 MayBe函子 121
8.2.1 实现MayBe函子 122
8.2.2 简单用例 123
8.2.3 真实用例 125
8.3 Either函子 129
8.3.1 实现Either函子 130
8.3.2 reddit例子的Either版本 131
8.4 Pointed函子 134
8.5 小结 134
第9章深入理解Monad 135
9.1 根据搜索词条获取Reddit评论 136
9.2 问题描述 136
9.2.1 实现第一步 138
9.2.2 合并Reddit调用 141
9.2.3 多个map的问题 144
9.3 通过join解决问题 146
9.3.1 实现join 146
9.3.2 实现chain 148
9.4 小结 151
第10章使用Generator 153
10.1 异步代码及其问题 154
10.2 Generator基础 156
10.2.1 创建Generator 156
10.2.2 Generator的注意事项 157
10.2.3 yield关键字 158
10.2.4 done属性 160
10.2.5 向Generator传递数据 162
10.3 使用Generator处理异步调用 164
10.3.1 一个简单的案例 164
10.3.2 一个真实的案例 169
10.4 小结 172
附录 173

以上就是本次介绍的JavaScript电子书的全部相关内容，希望我们整理的资源能够帮助到大家，感谢大家对码农之家的支持。

上一篇：C++ Primer Plus

下一篇：大数据基础编程、实验和案例教程

展开 +

收起 -

下载地址：百度网盘下载

JavaScript相关电子书

读者留言

网友NO.44405 2019-03-20

在JS中，函数是一等公民。这该怎么理解？为什么说它是“一等”的呢？其实这体现在函数可以去任何值可以去的地方，很少有限制。函数可以存储为变量函数可以存储为数组元素函数可以成为对象的成员变量函数可以在使用时直接创建出来函数可以传递给另一个函数函数可以被另一个函数返回最后两点其实就是高阶函数的定义，一个高阶函数可以执行以下至少一项操作：以一个函数作为参数、返回一个函数作为结果。