精通Functional JavaScript：探索ES6特性与函数式编程

需积分: 14 150 浏览量更新于2024-07-20 1 收藏 3.16MB PDF 举报

" Beginning Functional JavaScript: 本书通过使用 EcmaScript 6 来教授函数式编程的概念，由 Anto Aravinth 撰写。书中涵盖了诸如柯里化、部分应用函数、高阶函数和monads等核心概念。本书旨在帮助JavaScript开发者（或初学者）理解和掌握函数式编程思想及语言的函数特性。" 在JavaScript开发领域，随着语言的发展，从面向过程到面向对象，现在越来越注重函数式编程。JavaScript作为一款支持函数式编程的动态类型语言，允许开发者编写出更整洁、更具可维护性的代码。《Beginning Functional JavaScript》一书详细介绍了以下几个关键知识点： 1. **函数式编程基础**：了解函数是如何在JavaScript中被处理的，学习如何将代码转化为无副作用、可组合的函数，这是函数式编程的核心。 2. **柯里化(Currying)**：这是一种将接受多个参数的函数转化为接受单一参数并返回新函数的技术，有助于实现更灵活的代码结构。 3. **部分应用函数(Partial Application)**：预先设置一部分函数参数，从而创建一个新的函数，这个新函数在调用时只需要提供剩余的参数。 4. **高阶函数(Higher-Order Functions)**：函数可以接收函数作为参数，或者返回一个函数。这是函数式编程中极其重要的工具，用于处理数组、映射、过滤等功能。 5. **Monad**：Monad是一种抽象概念，它定义了一种操作数据的方式，使得在纯函数式环境中处理复杂计算成为可能。在JavaScript中，理解Monad可以帮助编写更优雅的错误处理和状态管理代码。 6. **真实世界的函数式库**：了解并分析实际的函数式库，如underscore.js，学习它们的设计原则，并尝试创建自己的函数式库。 7. **ES6的函数式特性**：深入理解ES6引入的新特性，如扩展运算符(Spread Operators)用于合并数组和对象，以及生成器(Generators)，它们在异步编程和迭代中发挥重要作用。 8. **错误处理**：探讨如何使用纯函数式方法，如Functors和Monads，来优雅地处理错误，保持代码的纯净性。 9. **目标读者**：本书面向想要提升对JavaScript中函数式编程理解的开发者，无论你是有经验的JavaScript开发者还是初学者，都可以从中受益。通过学习这本书，读者不仅可以深入理解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页未读，继续阅读

DWcsdnNET

粉丝: 415
资源: 651

精通Functional JavaScript：探索ES6特性与函数式编程

Beginning Functional JavaScript 无水印pdf

Functional Programming in JavaScript

JavaScript视频教程

--------- beginning of system 和 --------- beginning of main 区别

--------- beginning of system --------- beginning of main这两条是什么意思？

C:\Users\DELL>adb logcat -s goc --------- beginning of main --------- beginning of system --------- beginning of crash

--------- beginning of system --------- beginning of main

beginning ios 14 programming with swift

"invalid character '[' looking for beginning of object key string"

beginning rust:from novice to professional

最新资源