-
Notifications
You must be signed in to change notification settings - Fork 1
Fundamentals of Functional Programming in JavaScript
Pritesh Patel edited this page Jun 18, 2019
·
6 revisions
https://app.pluralsight.com/library/courses/javascript-functional-programming-fundamentals/
- Sibling of OOP
- Functional programming part of larger paradigm of declarative paradigm, in contrast to the imperative paradigm
- Mathematical functions (pure functions). Don't depend on data other than what's passed in and don't alter any data than what's returned
- Functional programming values immutable data which is easier to reason about
- Easier to reason
- In imperative programming you need to reason about two dimensions - 'what is it doing?' and 'how does it do it?'. In declarative programming you reduce this to just one - what is it doing?
- Testing is easier as unlike in an imperative paradigm, setting up the application state is easier (it's just the values passed into the function) and asserting correct behaviour is easier (it's just checking the value returned by the function)
- RamdaJS, lodash/fp
- pass functions as arguments, assign functions to variables
- a function that can return other functions
-
currying converts a function that accepts multiple parameters into a series of functions that each only take 1 parameter e.g.
byId(2)(item) - partial application - supplying fewer parameters than needed, with the remaining parameters being provided to the returned function later
- note the difference between currying and partial application. With both concepts you can build up functions that don't yet have all the parameters they need
- see Ramda's
R.curry()that will work with any number of parameters
-
- doesn't depend on any data other than what's passed in
-
- doesn't modify any data other than what's returned
- combining functions to create a new function
- use
R.pipe()andR.compose()to improve readability of function compositions
- 3 parts of functional programming - declarative (what vs. how), power of first-class and pure functions, data doesn't change
- Alters data outside of it's scope
- A program must have side effects; need to be deliberate about when and why they occur
- Side effects can slow debugging
- Immutable structures make programs easier to reason about
- With immutability, each function has it's own copy of the data that cannot be altered unexpectedly by another function
- Immutability is still performant as copying data copies the reference of object properties, not the entire object for object properties that are unchanged when the new copy of the object is being created. Also garbage collection ensures old objects that no longer required are collected and the memory recycled
- No native JavaScript immutable structures, note
const myObject = {};indicates the object is read-only but properties on the object can still be added and deleted - 'seamless-immutable' lib enables immutable data structures and works with plain old JavaScript data structures
- e.g.
let myImmutable = Immutable([3,5,1,2,4]);
myImmutable.sort(); //sort cannot be called on immutable structure
- instead this can be sorted using R.sort() which does not alter
myImmutable - use
.asMutable()to create a new mutable copy of the data structure when required -
Immutable()can be used for arrays and objects -
.set()can be used to set properties on a newly created immutable object -
.setIn()can be used to provide a path to a property to set a value on
- seamless immutable can be introduced into a codebase by limiting it to an area you are working on and exposing mutable data structures outside of that using
asMutable()to avoid forcing other developers to embrace it as well. Adoption can be controlled and managed over time in this way.
- Setup of tests is time-consuming - requiring set up of dependencies required to perform the test
- Testing pure functions is simplified as it only requires checking/asserting the value returned by the pure function
- Simple setup - no mock/stub any other functions
- Declarative nature of functional programming - in particular simplification of loops
- Power of functions - as variables, compose functions of other functions
- Side effects when state is altered outside of the scope of the function
- Performance - with object reuse and garbage collection
- React, Redux and Ramda all use functional programming