Start learning free

LESSON 25 OF 410 · CALCULATIONS WITH NUMBERS

Modulo operator in JavaScript

Lesson Read the full explanation

TL ; DR:

The modulo operator (%) calculates the remainder of dividing two values:

console.log(10 % 2); // Output: 0
console.log(15 % 4); // Output: 3
console.log(20 % 3); // Output: 2

It can also be used with variables:

let a = 2;
let b = 4;

console.log(b % a); // Output: 0
console.log(11 % b); // Output: 3

Full lesson:

Remember how we first learn about the division of two integer numbers in primary school?

The quotient is the number of times a division is completed fully, while the remainder is the amount left that doesn't entirely go into the divisor.

Here are some examples:

10 / 2 = quotient 5, remainder 0
15 / 4 = quotient 3, remainder 3
20 / 3 = quotient 6, remainder 2

The modulo operator:

The modulo operator (%) calculates the remainder of dividing two values:

console.log(10 % 2); // Output: 0
console.log(15 % 4); // Output: 3

It can also be used with variables:

let a = 2;
let b = 4;

console.log(b % a); // Output: 0

console.log(11 % b); // Output: 3

Math.floor() function

The Math.floor() function returns the largest integer less than or equal to a given number:

console.log(Math.floor(3.9)); // Output: 3
console.log(Math.floor(5.2)); // Output: 5
console.log(Math.floor(7)); // Output: 7

We can use this function if we want to compute the integral part of some division (quotient):

// Declare 2 variables and initialize them:
let a = 2;
let b = 3;

let c = Math.floor(b / a);
console.log(c); // Output: 1

Quotient and remainder

In programming, we combine both these concepts to get the quotient and remainder of some divison:

// Let's divide 26 by 3:
let quotient = Math.floor(26 / 3);
let remainder = 26 % 3;

console.log(quotient); // Output: 8
console.log(remainder); // Output: 2

Assignment
Follow the Coding Tutorial and let's practice with quotient and remainder!

Hint
Look at the examples above if you get stuck.

STEP 1 OF 1

Guided

Ctrl + Enter to check

JAVASCRIPT · CALCULATIONS WITH NUMBERS

Modulo Operator in JavaScript, explained

Introduction

The modulo operator (%) is a fundamental concept in programming that calculates the remainder of a division operation. It is widely used in various scenarios, such as determining if a number is even or odd, cycling through array indices, and implementing algorithms that require periodicity.

Understanding the Basics

Before diving into more complex applications, it's essential to understand the basic functionality of the modulo operator. The modulo operation returns the remainder after dividing one number by another. For example:

console.log(10 % 2); // Output: 0
console.log(15 % 4); // Output: 3
console.log(20 % 3); // Output: 2

In these examples, the modulo operator calculates the remainder of the division of the first number by the second number.

Main Concepts

The key concept behind the modulo operator is its ability to determine the remainder of a division operation. This can be particularly useful in various programming scenarios:

Even or Odd: You can use the modulo operator to check if a number is even or odd. If number % 2 equals 0, the number is even; otherwise, it is odd.
Cycling Through Indices: When working with arrays, the modulo operator can help cycle through indices, ensuring they stay within bounds.
Periodic Tasks: The modulo operator can be used to execute tasks periodically, such as running a function every nth iteration.

Examples and Use Cases

Let's explore some examples to see how the modulo operator can be applied in different contexts:

// Check if a number is even or odd
let number = 7;
if (number % 2 === 0) {
  console.log(number + ' is even');
} else {
  console.log(number + ' is odd');
}

// Cycle through array indices
let array = ['a', 'b', 'c', 'd'];
for (let i = 0; i < 10; i++) {
  console.log(array[i % array.length]);
}

// Execute a task every 3 iterations
for (let i = 1; i <= 10; i++) {
  if (i % 3 === 0) {
    console.log('Task executed at iteration ' + i);
  }
}

Common Pitfalls and Best Practices

When using the modulo operator, it's important to be aware of common pitfalls and follow best practices:

Negative Numbers: The behavior of the modulo operator with negative numbers can vary between programming languages. In JavaScript, the result of a % b will have the same sign as a.
Zero Divisor: Avoid using zero as the divisor in a modulo operation, as this will result in a runtime error.
Code Readability: Use clear and descriptive variable names to make your code more readable and maintainable.

Advanced Techniques

Once you are comfortable with the basics, you can explore advanced techniques involving the modulo operator:

Hash Functions: The modulo operator is often used in hash functions to ensure that hash values fall within a specific range.
Cryptography: Modular arithmetic is a fundamental concept in many cryptographic algorithms.
Algorithm Optimization: The modulo operator can be used to optimize algorithms that require periodicity or cyclic behavior.

Code Implementation

Here are some well-commented code snippets demonstrating the correct use of the modulo operator:

// Check if a number is even or odd
let number = 7;
if (number % 2 === 0) {
  console.log(number + ' is even');
} else {
  console.log(number + ' is odd');
}

// Cycle through array indices
let array = ['a', 'b', 'c', 'd'];
for (let i = 0; i < 10; i++) {
  console.log(array[i % array.length]);
}

// Execute a task every 3 iterations
for (let i = 1; i <= 10; i++) {
  if (i % 3 === 0) {
    console.log('Task executed at iteration ' + i);
  }
}

Debugging and Testing

When debugging code that uses the modulo operator, consider the following tips:

Print Statements: Use print statements to check the values of variables involved in the modulo operation.
Edge Cases: Test edge cases, such as negative numbers and zero, to ensure your code handles them correctly.
Unit Tests: Write unit tests to verify the correctness of functions that use the modulo operator.

Example of a simple test case:

function isEven(number) {
  return number % 2 === 0;
}

// Test cases
console.log(isEven(4)); // true
console.log(isEven(7)); // false
console.log(isEven(-2)); // true
console.log(isEven(0)); // true

Thinking and Problem-Solving Tips

When approaching problems that involve the modulo operator, consider the following strategies:

Break Down the Problem: Divide the problem into smaller, manageable parts and solve each part step-by-step.
Visualize the Operation: Draw diagrams or use visual aids to understand how the modulo operation works in different scenarios.
Practice: Solve coding exercises and projects that involve the modulo operator to reinforce your understanding.

Conclusion

The modulo operator is a powerful tool in JavaScript that allows you to calculate remainders, check for even or odd numbers, cycle through array indices, and more. By mastering this operator, you can write more efficient and effective code. Remember to practice and explore further applications to deepen your understanding.

Additional Resources

For further reading and practice problems, consider the following resources:

Keep going with JavaScriptAbout 340 step-by-step lessons, from your first line of code to coding interviews. Free to start.

Start learning free