-> Different programming paradigms: Imperative, Declarative, Object-Oriented and Functional.
What is functional Programming?
- It is a programming paradigm.
- Functional programming boils down to one thing, that is pure functions.
Pure Functions
- It does not have side effects.
- The only thing it does is to return its output values.
- A pure function is deterministic that is it’s output is totally determined by its input.
//Pure function
//Example 1
function writeJsonString(object) {
return JSON.stringify(object, null, 2);
}
//Example 2
function exclusiveOr(A, B) {
return (A || B) && !(A && B);
}
Why functional programming?
- When functions are deterministic, you get code that are much more predictable and safer.
- It is easier to test or debug
When a function is considered as not pure?
-
A function is not pure if its output depends on anything except its inputs (including the state of the world), or if calling the function at different times with the same inputs can give different outputs (e.g. if called on different days).
-
A function is not pure if it does anything besides return its output. Any other effect it has on the program or world is a side effect (in this case, changing the properties of an HTML element on the page).
// Not pure
function setColor(R, G, B) {
const hex = rgbToHex(R, G, B);
const colorMe = document.getElementById('color-me');
colorMe.setAttribute('style', 'color: ' + hex);
}
Staying out of the loop with recursion
Recursion:
- Functional
- Self Referential
- Stateless
// An iterartive approach
function sum(numbers) {
let total = 0;
for (let i = 0; i < numbers.length; i++) {
total += numbers[i];
}
return total;
}
let numbers = [1, 2, 3, 4, 5];
let res = sum(numbers);
console.log(res);
The same can be done using recursive approach
function sum(numbers) {
let n = numbers.length;
//base case
if (n === 1) return numbers[0];
else {
return numbers[0] + sum(numbers.slice(1));
}
}
let numbers = [1, 2, 3, 4, 5];
let res = sum(numbers);
console.log(res);
Higher order functions
-
A language has first class function when the language supports functions being passed around like values. JavaScript has first class functions.
-
A higher order function is a function that takes another function as input/output.
-
Instead of using a loop, you can make use of higher order functions map, reduce and filter. Here, we think filter, map and reduce as functions rather than array methods.
Implementing map,filter and reduce as functions
Map:
const map = (arr, mapFunc) => {
const mapArr = [];
for (let i = 0; i < arr.length; i++) {
const result = mapFunc(arr[i], i, arr);
mapArr.push(result);
}
return mapArr;
};
let arr = [1, 2, 3, 4, 5];
const sqrArr = map(arr, (n) => n ** 2);
console.log(sqrArr);
Filter:
const filter = (arr, filterFunc) => {
const filterArr = [];
for (let i = 0; i < arr.length; i++) {
const result = filterFunc(arr[i], i, arr);
if (result) {
filterArr.push(arr[i]);
}
}
return filterArr;
};
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const evenArr = filter(arr, (n) => n % 2 === 0);
console.log(evenArr);
Reduce:
function reduce(arr, reducer, initialValue) {
let accumulator = initialValue === undefined ? 0 : initialValue;
for (let i = 0; i < arr.length; i++)
accumulator = reducer(accumulator, arr[i], i, arr);
return accumulator;
}
const sumReducer = (accumulator, currentValue) => accumulator + currentValue;
let arr = [1, 2, 3, 4, 5];
const sum = reduce(arr, sumReducer);
console.log(sum);