JavaScript Arithmetic Operators
Hello there, fellow coder! Today, we’re going to dive into the world of JavaScript arithmetic operators. These little guys are the heart of mathematical operations in your code, and understanding them is key to mastering JavaScript. So, let’s get started!
Table of Contents
Introduction
JavaScript arithmetic operators are the bread and butter of mathematical operations in JavaScript. They allow us to perform calculations and manipulate numerical values. But what exactly are these operators? And why should we care about them? Let’s find out!
Here’s a diagram that visualizes the different JavaScript Arithmetic Operators:
Understanding JavaScript Arithmetic Operators
In JavaScript, we have several arithmetic operators: +
(addition), 
(subtraction), *
(multiplication), /
(division), and %
(modulus). These operators allow us to perform mathematical operations on values, and they’re essential for controlling the flow of our programs.
Addition Operator (+
)
The addition operator (+
) adds two numbers together. Here’s a quick example:
let a = 5;
let b = 10;
console.log(a + b); // Outputs: 15
JavaScriptSubtraction Operator (
)
The subtraction operator (
) subtracts one number from another. Check out this example:
let a = 10;
let b = 5;
console.log(a  b); // Outputs: 5
JavaScriptMultiplication Operator (*
)
The multiplication operator (*
) multiplies two numbers together. Here’s how it works:
let a = 5;
let b = 10;
console.log(a * b); // Outputs: 50
JavaScriptDivision Operator (/
)
The division operator (/
) divides one number by another. Here’s an example:
let a = 10;
let b = 5;
console.log(a / b); // Outputs: 2
JavaScriptModulus Operator (%
)
The modulus operator (%
) returns the remainder of a division operation. Here’s an example:
let a = 10;
let b = 3;
console.log(a % b); // Outputs: 1
JavaScriptJavaScript Arithmetic Operators Precedence
In JavaScript, arithmetic operators have a specific order of precedence, which determines how expressions involving multiple operators are evaluated. The multiplication (*
), division (/
), and modulus (%
) operators have the highest precedence, followed by addition (+
) and subtraction (
).
JavaScript Arithmetic Operators with Strings
In JavaScript, when you use the addition operator (+
) with strings, it concatenates (joins) the strings together. However, when you use the other arithmetic operators with strings, JavaScript tries to convert the strings into numbers. Here’s an example:
let a = "Hello, ";
let b = "World!";
console.log(a + b); // Outputs: "Hello, World!"
JavaScriptJavaScript Assignment Operators
In JavaScript, assignment operators are used to assign values to variables. The most common assignment operator is =
. However, JavaScript also provides compound assignment operators that combine an arithmetic operator with the assignment operator. Here’s an example:
let a = 5;
a += 10; // Same as a = a + 10;
console.log(a); // Outputs: 15
JavaScriptJavaScript Relational Operators
Relational operators in JavaScript are used to compare values. These operators return a boolean value (true
or false
) based on the comparison. Here’s an example:
let a = 5;
let b = 10;
console.log(a < b); // Outputs: true
JavaScriptJavaScript Arithmetic Operators Examples
Let’s look at some complete code examples that use JavaScript arithmetic operators in realworld scenarios.
Code Example 1: A simple program to calculate the area of a rectangle.
let length = 10;
let width = 5;
let area = length * width;
console.log('The area of the rectangle is ' + area); // Outputs: The area of the rectangle is 50
JavaScriptCode Example 2: A program that calculates the average of three numbers.
let num1 = 10;
let num2 = 20;
let num3 = 30;
let average = (num1 + num2 + num3) / 3;
console.log('The average of the three numbers is ' + average); // Outputs: The average of the three numbers is 20
JavaScriptWrapping Up
And that’s a wrap! We’ve covered the main JavaScript arithmetic operators: +
, 
, *
, /
, and %
. We’ve also looked at operator precedence, how arithmetic operators work with strings, and the relationship between arithmetic and assignment operators. Remember, mastering these operators is key to performing calculations in your JavaScript programs, so keep practicing!
Frequently Asked Questions (FAQ)

What are JavaScript arithmetic operators?
JavaScript arithmetic operators allow us to perform mathematical operations on values. The main arithmetic operators are
+
,
,*
,/
, and%
. 
What is the precedence of JavaScript arithmetic operators?
In JavaScript, the multiplication (
*
), division (/
), and modulus (%
) operators have the highest precedence, followed by addition (+
) and subtraction (
). 
How do arithmetic operators work with strings in JavaScript?
When you use the addition operator (
+
) with strings, it concatenates the strings together. 
What are JavaScript assignment operators?
Assignment operators in JavaScript are used to assign values to variables. The most common assignment operator is
=
. However, JavaScript also provides compound assignment operators that combine an arithmetic operator with the assignment operator. 
Can I use arithmetic operators with nonnumeric values?
Yes, you can! When used with nonnumeric values, JavaScript arithmetic operators will try to convert those values to numbers.

What happens when I divide by zero in JavaScript?
In JavaScript, dividing a number by zero does not result in an error. Instead, it returns
Infinity
. 
What is the modulus operator used for in JavaScript?
The modulus operator (
%
) is used to obtain the remainder of a division operation. It’s often used in programming to determine if a number is even or odd. 
How can I increment or decrement a value in JavaScript?
You can use the
++
operator to increment (add 1 to) a value, and the
operator to decrement (subtract 1 from) a value. 
What is the difference between
x++
and++x
in JavaScript?Both
x++
and++x
increment the value ofx
by 1. The difference is thatx++
returns the value ofx
before the increment, while++x
returns the value ofx
after the increment.
 JavaScript Operators
 JavaScript Logical Operators
 JavaScript Comparison Operators
 JavaScript Type Conversion
 JavaScript Control Structures
 JavaScript Loops
 JavaScript Functions
 JavaScript Events