函数式JavaScript入门：基于EcmaScript6

需积分: 10 64 浏览量更新于2024-07-20 收藏 3.21MB PDF 举报

" Beginning Functional JavaScript - Anto Aravinth" 本书《 Beginning Functional JavaScript》是Anto Aravinth撰写的一本关于使用EcmaScript 6进行函数式编程的指南，旨在帮助读者理解和掌握JavaScript中的函数式编程概念。作者Anto Aravinth来自印度泰米尔纳德邦的金奈，该书于2017年出版，由出版社持有版权，并遵循严格的版权法规。函数式编程是一种编程范式，它强调通过使用不可变数据和纯函数来构建程序。在JavaScript中，随着 EcmaScript 6（也称为ES6或ES2015）的引入，函数式编程的概念变得更加容易实现。这本书将帮助读者理解如何利用ES6的新特性，如箭头函数、let和const、解构赋值、默认参数、剩余参数、生成器等，来实现更简洁、可维护的代码。本书可能涵盖以下关键知识点： 1. **函数式编程基础**：介绍函数式编程的核心理念，包括纯函数、高阶函数、函数组合、柯里化、闭包等概念。 2. **ES6新特性**：深入解析ES6中的箭头函数，这种语法糖使得函数定义更加简洁。同时，let和const关键字提供了块级作用域，避免了变量提升（hoisting）带来的问题，而解构赋值则简化了对象和数组的值提取。 3. **不可变数据**：探讨如何通过使用不可变数据（例如使用`Object.freeze()`）来保持数据的不变性，以及如何使用Immutable.js库来实现更高效的不可变操作。 4. **函数组合**：解释如何通过组合多个小型、单一职责的函数来创建复杂的逻辑，提高代码的可读性和复用性。 5. **映射、过滤和减少**：介绍这些函数式编程的常用方法，它们在处理数组时非常有用，可以避免使用循环和副作用。 6. **柯里化**：讲解如何将接受多个参数的函数转换为接受单个参数并返回新函数的技巧，这有助于延迟计算和创建更灵活的API。 7. **高阶函数**：讨论如`map()`, `filter()`, `reduce()`等接受函数作为参数的函数，它们是函数式编程中的重要工具。 8. **函数式数据结构**：介绍如链表、树、队列等数据结构在函数式编程中的应用，以及如何使用它们来优化算法。 9. **函数式编程与React**：如果书中涉及，可能会讲解如何在React框架中应用函数式编程思想，如无状态组件、函数组件和使用`useReducer`或`useCallback`等React Hooks。 10. **错误处理和异常**：在函数式编程中，错误处理通常通过返回特殊值（如`null`或`undefined`）或使用try-catch块的函数版本来实现。 11. **测试与调试**：介绍如何编写针对函数式代码的测试，以及如何利用函数式编程的特性来简化调试过程。通过阅读这本书，读者不仅可以学习到函数式编程的基本原理，还能了解到如何在实际项目中有效地运用这些概念，提升JavaScript编程能力。此外，书中的实例和练习将有助于巩固理论知识，并让读者能够将所学应用于实际开发中。

CHAPTER 1 ■ FUNCTIONAL PROGRAMMING IN SIMPLE TERMS

Listing 1-2. Calculate Tax Function Rewritten

var calculateTax = (value, percentValue) => { return value/100 * (100 +

percentValue) }

Now our function calculateTax can be called as a real function. But what have

we gained? We have just made the elimination of global variable access inside our

calculateTax function. Removing global variable access inside a function makes it easy for

testing. (We will talk about the functional programming benefits in this chapter later on)

Now we have made our relationship with the Math function to our JavaScript

function. With this simple exercise, we can define functional programming in simple

technical terms. Functional programming is a paradigm in which we will be creating

functions that are going to work out its logic by depending only on its input. This ensures

that a function, when called multiple times, is going to return the same result. The function

also won’t change any data in the outside world, leading to cachable and testable codebase.

FUNCTIONS VS. METHODS IN JAVASCRIPT

We have talked about the word “function” a lot in this text. Before we move on, I

want to make sure you understand the difference between Functions and Methods

in JavaScript.

Simply put, a Function is a piece of code that can be called by its name. It can be

pass arguments and return values.

However, Methods is a piece of code that must be called by its name along with its

associated object name.

We will look at a quick example of function and method in Listing 1-3:

Function

Listing 1-3. A Simple Function

var simple = (a) => {return a} // A simple function

simple(5) //called by its name

Method

Listing 1-4. A Simple Method

var obj = {simple : (a) => {return a} }

obj.simple(5) //called by its name along with its associated object

There are two more important characteristics of Functional programing that are

missing in the definition. We are going to discuss them in detail in the upcoming sections

before we dive into the benefits of functional programming.

CHAPTER 1 ■ FUNCTIONAL PROGRAMMING IN SIMPLE TERMS

Referential Transparency

With our above definition of function, we have made a statement that all the functions are

going to return the same value for the same input. And this property of a function is called

a Referential transparency. We will take a simple example as shown in Listing 1-5:

Listing 1-5. Referential Transparency Example

var identity = (i) => { return i }

In the above code snippet we have defined a simple function called identity. This

function is going to return whatever you‘re passing as its input; that is, if you’re passing 5,

it’s going to return back the value 5 (i.e., the function is just acts as a mirror or identity).

Note that our function does operate only on the incoming argument ‘i’, and there is no

global reference inside our function (remember in Listing 1-2, we removed ‘percentValue’

from global access and made it an incoming argument). This function satisfies the

conditions ofReferential Transparency. Now imagine this function is used between other

function calls like this:

sum(4,5) + identity(1)

With our Referential Transparency definition we can convert the above statement

into this:

sum(4,5) + 1

Now this process is called a Substitution model as you can directly substitute the

result of the function as is (mainly because the function doesn’t depend on other global

variables for its logic) with its value. This leads to parallel code and caching. Imagine

that with this model, you can easily run the above function with multiple threads without

even the need of synchronizing! Why? The reason for synchronizing comes from the fact

that threads shouldn’t act upon global data when running parallel. Functions that obey

Referential Transparency are going to depend only on inputs from its argument; hence

threads are free to run without any locking mechanism!

And since the function is going to return the same value for the given input, we can,

in fact cache it! For example, imagine there is a function called ‘factorial’, which calculates

the factorial of the given number. ‘Factorial’ takes the input as its argument for which

the factorial needs to be calculated. We all know the ‘factorial’ of ‘5’ going to be ‘120’.

What if the user calls the ‘factorial’ of ‘5’ a second time? If the ‘factorial’ function obeys

Referential transparency, we know that the result is going to be ‘120’ as before (and it

only depends on the input argument). With this characteristic in mind, we can cache the

values of our ‘factorial’ function. Thus if a ‘factorial’ is called for the second time with the

input as ‘5’, we can return the cached value instead of calculating once again

Here you can see how a simple idea helps in parallel code and cachable code. We will

be writing a function in our library for caching the function results, later in the chapter.

CHAPTER 1 ■ FUNCTIONAL PROGRAMMING IN SIMPLE TERMS

REFERENTIAL TRANSPARENCY IS A PHILOSHOPY

Referential transparency is a word that came from Analytic Philosophy (https://

en.wikipedia.org/wiki/Analytical_philosophy

). This branch of philosophy

deals with Natural language semantics and its meanings. Here the word

“Referential” or “Referent” means to the thing that the expression refers to. A

context in a sentence is “referentially transparent” if replacing a term in that context

by another term that refers to the same entity doesn’t alter the meaning.

And that’s exactly how we have been defining Referential transparency in our

section. We have replaced the value of the function, without affecting the context.

Wow, functional programming is a philosophy!

Imperative, Declarative, Abstraction

Functional programming is also about being declarative and writing abstracted code. We

need to understand these two terms before we proceed further. We all know and have

worked on N imperative paradigm. We’ll take a problem and see how to solve it in an

imperative and declarative fashion.

Suppose you have a list or array and want to iterate through the array and print it to

the console. The code for might look like this:

Listing 1-6. Iterating over the Array Imperative Approach

var array = [1,2,3]

for(i=0;i<array.length;i++)

console.log(array[i]) //prints 1, 2, 3

It works fine. But in the above approach to solve our problem, we are telling

exactly “how” we need to do it. For example, we have written an implicit for loop with

an index calculation of the array length and printing the items. We will stop here. What

was the task here? “Print the array elements,” right? But it looks like we are telling the

compiler what to do. In this case, we are telling “Get Array Length, Loop our array, Get

each Element of array using index etc.” We call it an “imperative” solution. Imperative

programming is all about telling the compiler “how” to do the things.

We will now switch to the other side of the coin, Declarative programming. In

Declarative programming, we are going to tell “what” the compiler needs to do rather

than the “how” parts. The “how” parts are being abstracted into common functions (these

functions are called as Higher-Order functions, which we will cover in the upcoming

chapters). Now we can use the in-built forEach function to iterate the array and print it.

CHAPTER 1 ■ FUNCTIONAL PROGRAMMING IN SIMPLE TERMS

Listing 1-7. Iterating over the Array Declarative Approach

var array = [1,2,3]

array.forEach((element) => console.log(element)) //prints 1, 2, 3

The above code snippet does print exactly the same output in the previous Listing 1-5.

But here we have removed the “how” parts like “Get Array Length, Loop our array, Get each

Element of array using index, etc.” We have used an abstracted function, which takes care

of “how” part, leaving us the developers to worry about our problem in hand (“what” part).

That’s great! We will be creating these in-built functions throughout the textbook!

Functional programming is about creating functions in an abstracted way, which

can be reused by other parts of the code. Now we have a solid understanding of what

a functional programming is; with this in mind, we can go and explore the benefits of

functional programming.

Functional Programming Benefits

We have seen the definition of functional programming and a very simple example of

a function in the JavaScript language. But we have to answer a simple question: “What

are the benefits of Functional programming?” This section will help you see through the

lenses and see the huge benefits that functional programming is opting to offer us! Most

of the benefits of Functional programming come from writing Pure Functions. So before

we see the benefits of Functional programming, we will see what a pure function is.

Pure Functions

With our definition in place, we can define what is meant by Pure functions. Pure

functions are the functions that return the same output for the given input. Take an

example as given in Listing 1-8:

Listing 1-8. A Simple Pure Function

var double = (value) => value * 2;

The above function ‘double’ is a pure function just because given an input, it is going

to always return the same output. You can try yourself. Calling the double function with

input 5 always gives back the result as 10! Pure functions obey Referential transparency.

Thus we can replace double(5) with 10, without any hesitations.

So what’s the big deal about Pure Functions? It has many benefits to give to us. We’ll

discuss one after the other in the following text.

Pure Functions Lead to Testable Code

Functions that are not pure have side effects. Take our previous tax calculation example

(Listing 1-1):

CHAPTER 1 ■ FUNCTIONAL PROGRAMMING IN SIMPLE TERMS

var percentValue = 5;

var calculateTax = (value) => { return value/100 * (100 + percentValue) } //

depends on external environment percentValue variable

The function calculateTax is not a pure function, mainly because for calculating

its logic it depends on the external environment. However, the function works but the

function is very tough to test! Let’s see the reason for this.

Imagine we are planning to run a test for our calculateTax function three times for

three different tax calculations. We set up the environment like this:

calculateTax(5) === 5.25

calculateTax(6) === 6.3

calculateTax(7) === 7.3500000000000005

The entire test passes! But hold on, since our original calculateTax function depends on

the external environment variable percentValue, things can go wrong. Imagine the external

environment is changing the variable percentValue while you are running the same test cases:

calculateTax(5) === 5.25

// percentValue is changed by other function to 2

calculateTax(6) === 6.3 //will the test pass?

// percentValue is changed by other function to 0

calculateTax(7) === 7.3500000000000005 //will the test pass or throw

exception?

As you can see here the function is very hard to test. However we can easily fix the

issue, by removing the external environment dependency from our function, leading the

code to this:

var calculateTax = (value, percentValue) => { return value/100 * (100 +

percentValue) }

Now you can test the above function without any pain! Before we close this section,

we need to mention an important property about Pure function, which is “Pure Function

also shouldn’t mutate any external environment variables.”

In other words, the pure function shouldn’t depend on any external variables (like

shown in the example) and also change any external variables. We’ll not take a quick look

what we meant by changing any external variables. For example, consider the following

code in Listing 1-9:

Listing 1-9. BadFunction Example

var global = "globalValue"

var badFunction = (value) => { global = "changed"; return value * 2 }

剩余171页未读，继续阅读

爱琴忆海

粉丝: 250
资源: 403

函数式JavaScript入门：基于EcmaScript6

Functional JavaScript.pdf

Beginning Functional JavaScript 无水印pdf

Beginning Functional JavaScript, 2nd Edition (True PDF)

for {set ii 1} {$ii<=25} {incr ii} { puts "The $ii th Time history analysis is Beginning..............." if {[file exists outputBWPZ[expr $ii]]==0} { file mkdir outputBWPZ[expr $ii];请帮我解释并优化这段代码

JavaScript视频教程

[2] reddy k s p. beginning sa hotel 3: applications framework[m]. 2017: 65-6

dart apprentice: beginning programming with dart pdf

swt gridlayoutdata方法参数

最新资源