当前位置:首页 > >
《JavaScript ES6函数式编程入门经典》电子书封面

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函数式编程入门经典

      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
      网友NO.44405

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

      网友NO.38269
      网友NO.38269

      读了前三章,了解了基础的函数式编程的知识,今年读书的目的是学到想学的知识,没必要全读完也可以标记为“读过”,当然,即使读完,也未必能全消化。以后有机会再多读几章吧

      网友NO.40144
      网友NO.40144

      什么是函数是编程 函数式编程技术主要基于 数学函数和它的思想 数学中的函数有什么特点? 如f(X)=Y: 函数必须总是接收一个参数 函数必须总是返回一个值 函数应该依据接收到的参数,而不是外部环境运行

      码农之家

      码农之家 提供上传

      资源
      19
      粉丝
      9
      喜欢
      233
      评论
      12

      Copyright 2018-2020 www.xz577.com 码农之家

      版权投诉 / 书籍推广 / 赞助:520161757@qq.com