Every program we write follows an approach or style of writing also referred to as a paradigm. Functional programming is a declarative programming paradigm (programming paradigm where we write code in such a way that it describes the result and not the approach).
To understand functional programming let’s take an example of usual mathematics functions:
y = f(x)
this function does not modify the input passed in. Hence it is a pure function
y'=g(f(x))
here we have two functions ‘g’ and ‘f’, we take the result of the function ‘f’ and use it in the function ‘g’, this concept is called functional composition. It encourages code reusability and maintainability.
Similarly, in a functional code, the output depends only on the arguments that are passed to the function.
Example:
Javascript
const a = [6, 1, 9]; function push(a, element) { return [...a, element]; } console.log("Original array: ", a); console.log("Updated array: ", push(a, 10)); |
Output:
Original array: [6,1,9] Updated array: [6,1,9,10]
Here, we have created a function to push elements in an array, the push function is a pure function as it does not change the global array and only gives the result based on the input arguments.
Core principles of functional programming:
- Immutable data: an immutable variable is one that cannot be modified after initialization or we can say that a variable can be assigned a value only once. The benefits of avoiding data mutation are that it makes the code easier to read and easier to test and debug.
- Pure functions: as discussed above, a function that always returns the same value for the same arguments is called a pure function. A good example for dealing with impurity in functions would be Redux, it handles all of the side effects affecting the main store and the logic composed of pure functions. Benefits of pure functions are:
- easy to test
- easy to debug
- leads to smaller single-responsibility functions
- Declarative Style ( using functional composition ): it focuses on the result and not on the approach of the function. Composed functions make the code much more scalable as we have a clear separation of concerns
