Functions and Recursion in JavaScript (Node.js): A Detailed Guide Introduction Functions are one of the fundamental building blocks in JavaScript. In this guide, we will look at how functions work in the Node.js environment, what rec

Here is the translated HTML article in English. ```html

Functions and Recursion in JavaScript

Introduction: Why Do We Need Functions?

Imagine you are building a house. You don't hammer each nail by inventing a new method. You take a hammer and use it over and over. In programming, functions are like these "hammers." They are ready-made blocks of code that can be called (used) many times so you don't have to write the same thing repeatedly.

Functions make code:

• Shorter: no need to repeat the same actions.
• Clearer: the function name tells what it does (e.g., sumIncomes).
• More convenient: if something needs fixing, you only change it inside the function.

Basic Syntax: How to Create and Call a Function

In JavaScript, a function is created like this:

function functionName(parameters) {
  // Function body — what it does
  return result; // (optional)
}

For the function to work, you need to call it:

functionName(arguments);

Parameters are variables the function takes as input (like empty boxes). Arguments are the specific values you put into these boxes when calling.

Example 1: Family Budget (Sum of Two Numbers)

Let's write a function that adds two incomes and returns the total amount.

// Create the function
function sumIncomes(income1, income2) {
  let totalSum = income1 + income2;
  return totalSum; // Return the result
}

// Call the function and output the result
const salary = 50000;
const freelance = 15000;
let budget = sumIncomes(salary, freelance);
console.log("Total family income:", budget); // Output: 65000

How it works: The function sumIncomes takes two numbers, adds them, and returns the sum. We save the result in the variable budget and output it.

Example 2: Temperature Comparison (Return the Maximum Number)

The function takes two temperatures and returns the higher one.

function findMax(temp1, temp2) {
  if (temp1 > temp2) {
    return temp1;
  } else {
    return temp2;
  }
}

let morning = 15;
let afternoon = 22;
let highest = findMax(morning, afternoon);
console.log("Highest temperature:", highest); // Output: 22

Example 3: Checking if a Number is Even

Let's check if the number of boxes is even. The function returns true (yes) or false (no).

function isEven(number) {
  if (number % 2 === 0) {
    return true;
  } else {
    return false;
  }
}

let boxes = 150;
console.log("Is the quantity even?", isEven(boxes)); // Output: true

Recursion: A Function Calling Itself

Recursion is when a function calls itself to solve a big problem by breaking it down into small identical steps. It's like a Russian nesting doll: inside the big doll, there is a smaller one, and so on.

Important rule: Recursion must always have a base case — a condition that stops the function; otherwise, it will call itself infinitely and the program will "freeze."

Example 4: Reversing a String with Recursion

Let's break down the task: we need to reverse a string. For example, "cat" → "tac".

function reverse(str) {
  // Base case: if the string is empty or has one character, return it
  if (str.length <= 1) {
    return str;
  }
  // Recursion: take the last character + reverse the remaining part
  return str[str.length - 1] + reverse(str.slice(0, -1));
}

let message = "hello";
console.log("Reversed string:", reverse(message)); // Output: olleh

How it works:

1. The function takes the last character (o) and calls itself for the string without the last character (hell).
2. The new call takes l and calls itself for hel.
3. This continues until the string becomes empty.
4. All characters are collected in reverse order.

Example 5: Finding the Minimum Element in a List (Recursion)

Let's find the lowest temperature of the day. We have an array of numbers.

function findMin(arr) {
  // Base case: if the array has one element, it is the minimum
  if (arr.length === 1) {
    return arr[0];
  }
  // Find the minimum in the tail of the array (without the first element)
  let minOfRest = findMin(arr.slice(1));
  // Compare the first element with the minimum of the rest
  if (arr[0] < minOfRest) {
    return arr[0];
  } else {
    return minOfRest;
  }
}

let temperatures = [15, 8, 22, 3, 10];
console.log("Minimum temperature:", findMin(temperatures)); // Output: 3

Common Beginner Mistakes

• Forgetting to call the function. If you just write sumIncomes (without parentheses), the program won't execute the code inside. Always use parentheses: sumIncomes(50000, 15000).
• Forgetting return. If you don't write return, the function will return undefined (empty). A function without return does something but doesn't give the result back.
• Infinite recursion. If you don't write a base case, the function will call itself forever until memory runs out. Always check the stopping condition!
• Confusing parameters and arguments. Parameters are the "variables" in the function definition. Arguments are the "values" you pass when calling.

Final Example: Solving a Similar Problem

Task: At a factory, they count boxes. We need to write a function that takes an array of numbers (the number of boxes in each batch) and returns their sum. Use recursion.

function sumBoxes(boxes) {
  // Base case: if the array is empty, the sum is 0
  if (boxes.length === 0) {
    return 0;
  }
  // Recursion: first element + sum of the rest
  return boxes[0] + sumBoxes(boxes.slice(1));
}

let batches = [10, 25, 15, 30];
console.log("Total boxes:", sumBoxes(batches)); // Output: 80

```