Muutke küpsiste eelistusi

Beginning Functional JavaScript: Uncover the Concepts of Functional Programming with EcmaScript 8 Second Edition [Pehme köide]

4.17/5 (6 hinnangut Goodreads-ist)
,
  • Formaat: Paperback / softback, 307 pages, kõrgus x laius: 235x155 mm, kaal: 504 g, 26 Illustrations, black and white; XVII, 307 p. 26 illus., 1 Paperback / softback
  • Ilmumisaeg: 06-Dec-2018
  • Kirjastus: APress
  • ISBN-10: 1484240863
  • ISBN-13: 9781484240861
Teised raamatud teemal:
  • Pehme köide
  • Hind: 62,59 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Tavahind: 73,64 €
  • Säästad 15%
  • Raamatu kohalejõudmiseks kirjastusest kulub orienteeruvalt 2-4 nädalat
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Tellimisaeg 2-4 nädalat
  • Lisa soovinimekirja
Beginning Functional JavaScript: Uncover the Concepts of Functional Programming with EcmaScript 8 Second EditionSuurem pilt
  • Formaat: Paperback / softback, 307 pages, kõrgus x laius: 235x155 mm, kaal: 504 g, 26 Illustrations, black and white; XVII, 307 p. 26 illus., 1 Paperback / softback
  • Ilmumisaeg: 06-Dec-2018
  • Kirjastus: APress
  • ISBN-10: 1484240863
  • ISBN-13: 9781484240861
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9781484240861.html
Märksõnad:
Understand functional programming concepts and the functional nature of the JavaScript language. Starting with an introduction to functional programming concepts, you will learn the key differences between imperative and functional programming. Diving straight into JavaScript functions, you will learn to write them with ES8. Followed by this you will move to higher order functions and learn how 'Function as Data' opens up a world of possibilities. 

You will then build higher order functions with closures. Arrays will then be introduced, followed by a set of APIs you can use with them. You will learn how to transform one function to another using currying and partial application. The compose function will be discussed in detail, followed by functors and monads. After having an in-depth look at applicative functors, you will learn the new features offered in ES8. 

The concluding chapters of Beginning Functional JavaScript will show you how to use a functional toolkit to build a small library that allows you to develop web applications, followed by tips on testing your functional code.

What You Will Learn   









Discover functional programming concepts such as string padding and async functions

Identify how functions are treated in JavaScript

Create a functional library that mimics Underscore.JS

Deep dive into ES8 functional features such as spread operators and generators

Create a library that works like the react-redux pattern by following the functional paradigm







Who This Book Is For

Novice JavaScript developers.
About the Authors xi
About the Technical Reviewer xiii
Acknowledgments xv
Introduction xvii
Chapter 1 Functional Programming in Simple Terms
1(20)
What Is Functional Programming? Why Does It Matter?
2(3)
Referential Transparency
5(2)
Imperative, Declarative, Abstraction
7(1)
Functional Programming Benefits
8(1)
Pure Functions
8(9)
Pure Functions Lead to Testable Code
9(2)
Reasonable Code
11(1)
Parallel Code
12(2)
Cachable
14(2)
Pipelines and Composable
16(1)
A Pure Function Is a Mathematical Function
17(1)
What We Are Going to Build
18(1)
Is JavaScript a Functional Programming Language?
19(1)
Summary
20(1)
Chapter 2 Fundamentals of JavaScript Functions
21(20)
ECMAScript: A Bit of History
22(1)
Creating and Executing Functions
23(7)
First Function
24(2)
Strict Mode
26(2)
Return Statement Is Optional
28(1)
Multiple Statement Functions
28(2)
Function Arguments
30(1)
ES5 Functions Are Valid in ES6 and Above
30(1)
Setting Up Our Project
30(10)
Initial Setup
31(2)
Our First Functional Approach to the Loop Problem
33(3)
Gist on Exports
36(1)
Gist on Imports
36(1)
Running the Code Using Babel-Node
37(1)
Creating Script in Npm
38(1)
Running the Source Code from Git
39(1)
Summary
40(1)
Chapter 3 Higher Order Functions
41(22)
Understanding Data
42(5)
Understanding JavaScript Data Types
42(1)
Storing a Function
43(1)
Passing a Function
44(1)
Returning a Function
45(2)
Abstraction and Higher Order Functions
47(6)
Abstraction Definitions
48(1)
Abstraction via Higher Order Functions
48(5)
Higher Order Functions in the Real World
53(8)
Every Function
53(2)
Some Function
55(1)
Sort Function
56(5)
Summary
61(2)
Chapter 4 Closures and Higher Order Functions
63(18)
Understanding Closures
64(6)
What Are Closures?
64(3)
Remembering Where It Is Born
67(2)
Revisiting sortBy Function
69(1)
Higher Order Functions in the Real World (Continued)
70(10)
Tap Function
70(2)
Unary Function
72(2)
Once Function
74(1)
Memoize Function
75(3)
Assign function
78(2)
Summary
80(1)
Chapter 5 Being Functional on Arrays
81(28)
Working Functionally on Arrays
82(6)
Map
82(5)
Filter
87(1)
Chaining Operations
88(7)
ConcatAII
90(5)
Reducing Function
95(7)
Reduce Function
95(7)
Zipping Arrays
102(6)
Zip Function
105(3)
Summary
108(1)
Chapter 6 Currying and Partial Application
109(24)
A Few Notes on Terminology
110(2)
Unary Function
110(1)
Binary Function
110(1)
Variadic Functions
110(2)
Currying
112(11)
Currying Use Cases
114(2)
A logger Function: Using Currying
116(1)
Revisit Curry
117(5)
Back to logger Function
122(1)
Currying in Action
123(2)
Finding a Number in Array Contents
124(1)
Squaring an Array
124(1)
Data Flow
125(5)
Partial Application
125(2)
Implementing partial Function
127(3)
Currying vs. Partial Application
130(1)
Summary
130(3)
Chapter 7 Composition and Pipelines
133(24)
Composition in General Terms
134(3)
Unix Philosophy
134(3)
Functional Composition
137(3)
Revisiting map.filter
137(2)
Compose Function
139(1)
Playing with the compose Function
140(8)
Curry and partial to the Rescue
142(4)
Compose Many Functions
146(2)
Pipelines and Sequence
148(7)
Implementing pipe
149(1)
Odds on Composition
150(1)
The Pipeline Operator
151(3)
Debugging Using the tap Function
154(1)
Summary
155(2)
Chapter 8 Fun with Functors
157(24)
What Is a Functor?
158(5)
Functor Is a Container
158(3)
Implementing map
161(2)
MayBe
163(10)
Implementing MayBe
163(2)
Simple Use Cases
165(3)
Real-World Use Cases
168(5)
Either Functor
173(6)
Implementing Either
174(2)
Reddit Example Either Version
176(3)
Word of Caution: Pointed Functor
179(1)
Summary
180(1)
Chapter 9 Monads in Depth
181(24)
Getting Reddit Comments for Our Search Query
182(1)
The Problem
183(13)
Implementation of the First Step
185(4)
Merging Reddit Calls
189(5)
Problem of Nested/Many maps
194(2)
Solving the Problem via join
196(7)
Join Implementation
196(4)
Chain Implementation
200(3)
Summary
203(2)
Chapter 10 Pause, Resume, and Async with Generators
205(36)
Async Code and Its Problem
206(3)
Callback Hell
206(3)
Generators 101
209(10)
Creating Generators
209(1)
Caveats of Generators
210(1)
Yield Keyword
211(3)
Done Property of Generator
214(2)
Passing Data to Generators
216(3)
Using Generators to Handle Async Calls
219(11)
Generators for Async: A Simple Case
219(7)
Generators for Async: A Real-World Case
226(4)
Async Functions in ECMAScript 2017
230(9)
Promise
230(1)
Await
231(1)
Async
231(2)
Chaining Callbacks
233(3)
Error Handling in Async Calls
236(1)
Async Functions Transpiled to Generators
237(2)
Summary
239(2)
Chapter 11 Building a React-Like Library
241(28)
Immutability
242(3)
Building a Simple Redux Library
245(6)
Building a Framework Like HyperApp
251(17)
Virtual DOM
252(2)
JSX
254(1)
JS Fiddle
255(6)
CreateActions
261(1)
Render
262(1)
Patch
263(1)
Update
264(1)
Merge
265(1)
Remove
266(2)
Summary
268(1)
Chapter 12 Testing and Closing Thoughts
269(30)
Introduction
270(2)
Types of Testing
272(1)
BDD and TDD
273(1)
JavaScript Test Frameworks
274(16)
Testing Using Mocha
275(8)
Mocking Using Sinon
283(4)
Testing with Jasmine
287(3)
Code Coverage
290(1)
Linting
291(3)
Unit Testing Library Code
294(2)
Closing Thoughts
296(1)
Summary
297(2)
Index 299
Anto Aravinth has been in the software industry for more than four years. He has developed many systems that are written in JavaScript and JavaWorld. Anto has knowledge of the fundamentals of JavaScript and how it works and has trained many people. Anto is an open source contributor to the React, Groovy, and Selenium frameworks and is co-author of React version 15. 



Srikanth Machiraju has over 10 years of experience as a developer, architect, technical trainer and community speaker. He is currently working as Senior Consultant with Microsoft Hyderabad and leading a team of 100 developers and quality analysts together developing an advanced cloud-based platform for a tech giant in oil industry. With an aim to be an enterprise architect who can design hyper-scale modern applications with intelligence he constantly learns and shares modern application development tactics using cutting-edge platforms and technologies. Prior to Microsoft he was worked with BrainScale as Corporate trainer & Senior Technical Analyst on application design, development, migrations using Azure. He is a tech savvy developer and passionate about embracing new technologies and sharing his learning via blog or community engagements. He has also authored Learned Windows Server Containers, Developing Bots with Microsoft Bot framework, blogs run his own YouTube channel called Tech Talk with Sriks and active on LinkedIn.