Functional Programming with JavaScript

Hello! #

This is the first post in a series focused on NodeJS. Node is a asynchronous event-driven JavaScript runtime for building scalable network applications. Just like JavaScript, NodeJS is not actually a functional programming language but is a good place to use functional programming if you so please.

So what is functional programming? #

Functional programming is a programming pattern. Generally it can be used in many different language but some are specifically geared toward it such as Haskell and Lisp. It's not that you can't do it in other languages but instead it is just a design decision in most cases.

For the purpose of this article I am focusing on some of the basics of functional programming. Functional programming does the following at it's core:

  • Treats computations as the evaluation of mathematical functions.
  • Avoids changing state and mutable data.

Functional Programming Concepts #

There are five main concepts:

  • Side Effects
  • Pure Functions
  • Functions as first class citizens
  • Higher order function
  • Currying

Side Effects #

A function would have a side effect if it modifies state outside its local scope. For functional programming a function should not impact code that is running on multiple processors.

Pure Functions #

When a function always returns the same output for a given input without any side effects then it would be called a pure function.

    // time 
const time = () => new Date().toLocaleTimeString();


Functions as first class citizens #

A function is a considered a first class citizen when a function accepts functions as arguments
or even be assigned as a variable.

    // variable f is assigned the value of the function
const f = a => console.log(a)

Higher order function #

Like a first class citizen a higher order function takes one or more functions as arguments or returns a function as a result.

    // function f 
// takes an input of a
// and logs the value of a
const f = a => console.log(a);

// function f2
// takes an input of a
// a could be a value or function
// and returns a
const f2 = a => a;

f('output 1') // console logs 'output 1'
f2('output 2') // doesn't print anything just returns the value 'output 2'
f2(f('output 3')) // console logs 'output 3'

Currying #

Currying is a composed function. It can be imagined as a function with nested functions that each nested function has access to the outer functions arguments. The final nested function would return the result of the function.

    const curry = f => a => b => f(a, b);

const talk = (a, b) => 'Say: '.concat(a, ' ', b);

let say = curry(talk);

Inspiration and Credits #

About NodeJS

Wikipedia Functional programming

Since you've made it this far, sharing this article on your favorite social media network would be highly appreciated 💖! For feedback, please ping me on Twitter.