Functional Programming

Functional programming is a programming paradigm that emphasizes the use of functions and immutable data structures. It is a declarative programming style, which means that the programmer specifies what the program should do, rather than how it should do it.

Functional programming has several key principles:

Immutability:

In functional programming, data is immutable, meaning it cannot be changed once it is created. This eliminates side-effects and makes it easier to reason about the code.

let x=1;
x=x+1; // xi is now 2

Instead of using variables with the above example in functional programming we use the following:

let x = 1;
let y = x + 1; // y is now 2, x is still 1

Pure functions:

A pure function is a function that, given the same input, will always return the same output, and has no side effects. This makes it easy to test and reason about the code.

function add(a, b) {
  return a + b;
}

In the above example, regardless of the time or context, if we call add(1,2) it will always return 3

Higher-order functions:

These are functions that take other functions as arguments or return them as output. This allows for a more powerful and flexible programming style.

function map(fn, array) {
  let newArray = [];
  for (let i = 0; i < array.length; i++) {
    newArray.push(fn(array[i]));
  }
  return newArray;
}

Here the function map takes two arguments (fn, array) and it applies the function fn to each element in the array and return the new array.

Recursion:

In functional programming, recursion is commonly used to replace loops. Recursion is a technique in which a function calls itself until it reaches a base case.

function factorial(n) {
  if (n === 0) {
    return 1;
  }
  return n * factorial(n - 1);
}

The above example is a recursive function which calculates the factorial of a number, it calls itself until it reaches the base case, which is n=0.

Functional programming is a powerful and expressive programming paradigm that can help to create more maintainable and testable code. It is widely used in languages such as Haskell, Lisp, and Scheme, and is also used in many popular languages such as JavaScript, Python, and C#.