最新のJavaScriptで関数型プログラミングを使用する方法と理由

この記事では、関数型プログラミングとその利点について深く理解します。

関数型プログラミング入門

関数型プログラミング(FP)は、コンピューターサイエンスのパラダイムまたはパターンの一種です。すべてはFPの関数の助けを借りて行われ、基本的な構成要素は関数のみです。

純粋に関数型プログラミングをサポートするプログラミング言語は—

  1. Haskell
  2. 閉鎖
  3. Scala
  4. SQL

関数型プログラミングや他のプログラミングパラダイムをサポートするプログラミング言語のいくつかは—

  1. Python
  2. Javascript
  3. C ++
  4. ルビー

名前が機能的であると言うので、ほとんどのプログラマーは数学関数について考えます。FPの場合はそうではありません。現実世界の複雑な問題を簡単かつ効果的な方法で解決することは、単なる抽象概念です。

オブジェクト指向プログラミングの時代以前は、ソフトウェア業界は関数型プログラミングに完全に依存していました。このパラダイムは、ソフトウェア業界を数十年にわたって揺るがしました。関数型プログラミングにはいくつかの問題があり、それがオブジェクト指向パラダイムに移行した理由です。FPの問題については、この記事の後半で説明します。

関数型プログラミングの概要は以上です。さて、まず、関数とは何かを学ぶ必要があります。

関数

実際の定義を明らかにする前に、実際にFPを使用する場所を知るための状況を説明したいと思います。アプリケーションを構築するためのコードを書いているとしましょう。開発の過程で、数行(100)のコードをさまざまな場所で再利用したいとします。アプリケーションには、関数が役立ちます。1つの場所で関数を記述でき、プログラムのどこからでもそれらの関数にアクセスできます。関数型プログラミングには次の機能があります—

  1. コードの冗長性を減らします。
  2. モジュール性を向上させます。
  3. 複雑な問題の解決に役立ちます。
  4. 保守性が向上します。

関数の実際の定義を見てみましょう。

関数は、プログラム内の特定のタスクを実行するために使用される指定されたコードのブロックです。

最も人気のあるタイプの関数は—

  1. 一般的な機能
  2. 矢印関数
  3. 匿名関数

一般的な機能

一般的な関数は、特定のタスクを実行するためにプログラマーが頻繁に使用する関数に他なりません。Javascriptで一般的な関数を宣言するための構文は次のとおりです。

function functionName(parameters) { // code to be executed}

function —関数を宣言するために必要なキーワードです。

functionName —関数workに基づいて名前を付けることができます。

パラメータ—関数に任意の数のパラメータを渡すことができます。

宣言された関数はすぐには実行されません。それらは「後で使用するために保存」され、後で呼び出された(呼び出された)ときに実行されます。

関数内で返されるコードを実行する場合は、関数を呼び出す必要があります。

一般的な機能は次のように分類されます—

引数なしの関数

関数に引数を渡す必要はありません。

// Function Declaration
function sayHello(){ alert('Hello...!');}
// Calling the functionsayHello()

関数sayHello()を呼び出すと、Helloとしてアラートメッセージが生成されます。

引数関数

このタイプの関数では、それらに引数を渡します。

// Declaring a Function
function add(num1, num2){ return num1 + num2;}
// Function Call
var result = add(7, 11);
console.log(result);

関数ie(num1、num2)の宣言中に渡される引数は、仮パラメーターと呼ばれます。

関数の呼び出し中に渡される引数、つまり(7、11)は、実際のパラメーターと呼ばれます。

関数は通常、何らかの値を返します。その値を返すには、returnキーワードを使用する必要があります。関数が何らかの値を返す場合、それは出力を出力しないことを意味し、最終出力を返すだけです。その結果を印刷するのは私たちの責任です。上記のプログラムでは、関数が値を返し、その値を変数名 'result'に渡します。これで、関数は結果を 'result'変数に渡します。

Javascript関数の専門

宣言された数よりも多くの引数を渡した場合、エラーは発生しません。しかし、Python、C、C ++、Javaなどの他のプログラミング言語では、エラーが発生します。Javascriptは、要件に基づいて検討します。

// Calling the function with more number of arguments than the declared number
var result1 = add(2, 4, 6);console.log(result1);
var result2 = add(2);console.log(result2);

出力

宣言された数よりも少ない引数を渡した場合も、エラーは発生しません。ただし、関数の機能に基づいて出力が生成されるため、プログラムの出力を予測することはできません。

可変引数関数

Javascript関数の最大の利点は、関数に任意の数の引数を渡すことができることです。この機能は、開発者が一貫した方法でより効果的に作業するのに役立ちます。

// Creating a function to calculate sum of all argument numbers
function sumAll(){
let sum = 0;
for(let i=0;i
return sum;
}
// Calling the sumAll function
sumAll();
sumAll(1,2,3,12,134,3234,4233,12,3243);

Output

Original text


This is all about general functions that are used to perform our complex task in a simple manner. Now let’s discuss some advanced functions introduced in ES6 called Arrow Functions.

Arrow Functions

An arrow function expression is a syntactically compact alternative to a regular function expression. It doesn’t have its own bindings to the this, super, arguments or new.target keywords. Arrow function expressions are ill-suited as methods. They cannot be used as constructors.

One of the most loved features in Es6 are Arrow functions. This arrow function helps developers time and simplify function scope.

The syntax for the arrow function is:

const functionName = (parameters) => { // code to be executed}
 (OR)
var functionName = (parameters) => { // code to be executed}
 (OR)
let functionName = (parameters) => { // code to be executed}

Examples for Arrow Functions

Eg 1

Creating an Arrow function to say a welcome message to the users.

// Creating a Welcome function
let sayHello = () => { return 'Welcome to Javascript World...!';}
// Calling the function
console.log(sayHello())

Output

Eg 2

In this example, we are creating an Arrow function to generate the greatest of all numbers that are passed as an argument.

let maxNumber = (a,b,c,d) => {
 if(a > b && a > c && a > d) return a; else if(b > a && b > c && b>d) return b; else if(c > a && c > b && c > d) return c; else return d;}
// Calling the function
console.log(maxNumber(1,2,4,3));

Output:

Combination of Variable Arguments with Arrow Functions

Since we are working with an arrow function, it doesn’t support the arguments array by default like general function. It is our responsibility to declare explicitly that it supports the variable number of arguments

Eg 3

let varArgSum = (...args) => { let sum = 0;
 for(let i=0;i
return sum;
}
// Calling the Function
console.log(varArgSum());
console.log(varArgSum(1,2,3,4,5,6,7,8,9,10));

Output

This is how we can combine a variable number of arguments with arrow functions. Now let’s discuss Anonymous functions in JavaScript.

Anonymous Functions

An anonymous function is simply a function with no name. The purpose of using anonymous function is to perform a certain task and that task is no longer required to program. Generally, anonymous functions are declared dynamically at run time.

Anonymous functions are called only once in a program.

Example:

// Working with an Anonymous function
var a = 10; // Global Scope Variable.
// creating a function(function() {
 console.log("welcome to the world of Anonymous function");
 var b = 20; // b is a local scope variable.
 var c = a+b; // c is a local scope variable //a can be used because it is in the global scope
 console.log("Addition of two numbers value is: "+c);})();

Output

This is the concept of anonymous functions. I think I explained it in a simple and easy way.

Higher Order Functions

A higher-order function is a function that takes functions as an argument or that returns another function as a result.

The best example of higher-order functions in Javascript is that of Array.map(), Array.reduce(), Array.filter().

Example 1: Array.map()

// working with Array.map()
let myNumberArray = [4,9,16,25,36,49];
let mySquareRootArray = myNumberArray.map(Math.sqrt);
console.log(mySquareRootArray);

Output

Example 2: Array.reduce()

// working with Array.reduce()
let someRandomNumbers = [24,1,23,78,93,47,86];
function getSum(total, num){ return total + num;}
let newReducedResult = someRandomNumbers.reduce(getSum);
console.log(newReducedResult);

Output

Example 3: Array.filter()

// Working with array filter
let ages = [12,24,43,57,18,90,43,36,92,11,3,4,8,9,9,15,16,14];
function rightToVote(age){ return age >= 18;}
let votersArray = ages.filter(rightToVote);
console.log(votersArray);

Output

Recursion

This is one of the key topics in functional programming. The process in which a function calls directly or indirectly is called a recursive function. This concept of recursion is quite useful in solving algorithmic problems like the Towers of Hanoi, Pre-Order, Post-Order, In-Order, and some graph traversal problems.

Example

Let’s discuss a famous example: finding the factorial of a number using recursion. This can be done by calling the function directly from the program repeatedly. The logic for the program is

factorial(n) = factorial(n) * factorial(n - 1) * factorial(n - 2) * factorial(n - 3) * ….. * factorial(n - n);
// Finding the factorial of a number using Recursion
function factorial(num){ if(num == 0) return 1; else return num * factorial(num - 1);
}
// calling the function
console.log(factorial(3));
console.log(factorial(7));
console.log(factorial(0));

Output

Characteristics Of Functional Programming

The objective of any FP language is to mimic the use of mathematical concepts. However, the basic process of computation is different in functional programming. The major characteristics of functional programming are:

Data is immutable: The data which is present inside the functions are immutable. In Functional programming, we can easily create a new Data structure but we can’t modify the existing one.

Maintainability: Functional programming produces great maintainability for developers and programmers. We don’t need to worry about changes that are accidentally done outside the given function.

Modularity: This is one of the most important characteristics of functional programming. This helps us to break down a large project into simpler modules. These modules can be tested separately which helps you to reduce the time spent on unit testing and debugging.

Advantages Of Functional Programming

  1. It helps us to solve problems effectively in a simpler way.
  2. It improves modularity.
  3. It allows us to implement lambda calculus in our program to solve complex problems.
  4. Some programming languages support nested functions which improve maintainability of the code.
  5. It reduces complex problems into simple pieces.
  6. It improves the productivity of the developer.
  7. It helps us to debug the code quickly.

Disadvantages Of Functional Programming

  1. For beginners, it is difficult to understand. So it is not a beginner friendly paradigm approach for new programmers.
  2. Maintainance is difficult during the coding phase when the project size is large.
  3. Reusability in Functional programming is a tricky task for developers.

Conclusion

For some, it might be a completely new programming paradigm. I hope you will give it a chance in your programming journey. I think you’ll find your programs easier to read and debug.

This Functional programming concept might be tricky and tough for you. Even if you are a beginner, it will eventually become easier. Then you can enjoy the features of functional programming.

If you liked this article please share with your friends.

Hello busy people, I hope you had fun reading this post, and I hope you learned a lot here! This was my attempt to share what I’m learning.

I hope you saw something useful for you here. And see you next time!

Have fun! Keep learning new things and coding to solve problems.

Check out My Twitter, Github, and Facebook.