Skip to main content

Mathematical Operators in JavaScript

JavaScript Fundamentals: Basic Operators, Math

What is an operand in JavaScript?​

View Answer:
Interview Response: In programming, we apply operands to operators. They can be left- or right-hand operands and a single argument or value depending on the case.

Technical Response: Operands are expressions or values on which an operator operates or works (often constants or variables, but sub-expressions are also permitted).

Explain the difference between a Binary and a Unary operand?​

View Answer:
Interview Response: A binary operand has two arguments on the left and right sides of the operator, and a Unary operand has a single operand.

Technical Response: There are two types of mathematical operators: unary and binary. Unary operators act with a single operand, and Binary operators perform actions with two operands. Unary operators are arithmetic operators that act on a single operand.

Example of Unary Operand:

let x = 1;

x = -x;

alert(x); // -1, unary negation was applied

Example of Binary Operands:

let x = 1,
  y = 3;

alert(y - x); // 2, binary minus subtracts values

What basic mathematical operations are allowed in JavaScript?​

View Answer:
Interview Response: The basic mathematical operations include addition, subtraction, multiplication, division, remainder or modulo, and exponentiation.

Technical Response: The basic mathematical operations allowed in JavaScript include Addition +, Subtraction -, Multiplication *, Division /, Remainder or Modulo %, and Exponentiation **.

In JavaScript, what is the remainder/modulo operator?​

View Answer:
Interview Response: The remainder operator is used to find the remainder of two arguments (operands/values).

Code Example:

alert(5 % 2); // 1, a remainder of 5 divided by 2
alert(8 % 3); // 2, a remainder of 8 divided by 3

How does the exponentiation operator function in JavaScript?​

View Answer:
Interview Response: The exponentiation operator multiplies a number by itself a specified number of times.

Technical Response: The exponentiation (**) operator multiplies a number by itself a specified number of times. It is like the caret (^) operator in python.

Code Example:

console.log(2 ** 2); // 4  (2 multiplied by itself 2 times)
console.log(2 ** 3); // 8  (2 * 2 * 2, 3 times)
console.log(2 ** 4); // 16 (2 * 2 * 2 * 2, 4 times)

Can exponentiation be defined for non-integer numbers?​

View Answer:
Interview Response: Mathematically, the exponentiation operator gets defined for non-integer numbers. We should note that the exponent used on fractions requires parentheses to ensure proper programmatic conversion.

Code Example:

alert(4 ** (1 / 2)); // 2 (power of 1/2 is the same as a square root)
alert(8 ** (1 / 3)); // 2 (power of 1/3 is the same as a cubic root)

Is it possible to concatenate strings in JavaScript?​

View Answer:
Interview Response: Yes, We can implement string concatenation using the binary plus operator or the concat method.

Technical Response: Yes, concatenation using the binary (+) operator. We can also use the built-in “concat” method to achieve the same result.

Code Example:

let s = 'my' + 'String';

alert(s); // myString
// Using the Built-in concat() method

let a = 'concat';

alert(a.concat('String')); // concatString
// String Conversion

alert('1' + 2); // "12"
alert(2 + '1'); // "21"
// Order of Operations still applies

alert(2 + 2 + '1'); // returns 2 + 2 = 4 and 4 + '1' = 41

// returns "41" and not "221"

How does unary plus work on single values?​

View Answer:
Interview Response: Unary plus has no effect on numbers, but it does convert non-number strings into numbers.

Technical Response: Unary (+) plus has no conversion effect on numbers, but it converts non-numbers like strings to numbers. JavaScript also has a built-in Number(value) method that you can use to achieve the same output.

Code Example:

// No effect on numbers
let x = 1;

alert(+x); // 1
let y = -2;

alert(+y); // -2

// Converts non-numbers
alert(+true); // 1
alert(+''); // 0
alert(+'7'); // converts string “7” to number 7

If you have two strings and wish to add their values together. What technique would you use to convert both strings to integers to prevent concatenating the values into a single string?​

View Answer:
Interview Response: We can use a unary plus or the number object to convert the strings to numbers and then attempt to sum the two values.

Technical Response: Since both numbers are strings (“4” + “4” = “44”). You can use an implicit or explicit approach to solve the problem. The implicit approach requires the use of unary plus applied to the left and right operand (+“4” + +“4” = 8). The second approach is the explicit use of the built-in Number Object ((Number( “4”) + Number( “4”) = 8).

Code Example:

let apples = '2';

let oranges = '3';

// both values converted to numbers before the binary plus
alert(+apples + +oranges); // 5

// the longer variant
alert(Number(apples) + Number(oranges)); // 5

What is the most prominent characteristic of all operators in JavaScript?​

View Answer:
Interview Response: All JavaScript operators return a value, including the assignment (=) operator.

In what direction do chained assignments evaluate?​

View Answer:
Interview Response: Chained assignments evaluate from right to left.

Code Example:

let a, b, c;

a = b = c = 2 + 2; // <- Chained Assignment right to left

alert(a); // 4
alert(b); // 4
alert(c); // 4

What is the major issue with chained assignments?​

View Answer:
Interview Response: If chained assignments get implemented incorrectly, it can lead to memory leaks.

What is the difference between increment and decrement?​

View Answer:
Interview Response: Increment increases a variable by one, and decrement decreases a variable by one.

Code Example:

let counter = 2;

counter++; // works the same as counter = counter + 1, but is shorter
alert(counter); // 3

////////////////////////////////

let counter = 2;

counter--; // works the same as counter = counter - 1, but is shorter
alert(counter); // 1

Can increment/decrement operators be applied to numbers?​

View Answer:
Interview Response: No, We should only use increment/decrement with variables. Trying to use it on a value like 5++ gives an error.

Are operators ++ and -- placed before or after a variable?​

View Answer:
Interview Response: The operators get placed before or after a variable. Before, the variable is a prefix position, and after the variable is the postfix position.

Technical Response: The operators ++ and -- get placed before or after a variable. When the operator goes after the variable, it is in “postfix position”: counter++. The “prefix position” is when the operator goes before the variable: ++counter.

Code Example:

// Postfix Position Counter
let counter = 1;
let a = ++counter; // (*)

alert(a); // 2

// Prefix Position Counter
let counter = 1;
let a = counter++; // (*) changed ++counter to counter++

alert(a); // 1

Is there any difference between the postfix and prefix increment/decrement positions?​

View Answer:
Interview Response: Prefix increments the counter and returns the new value. Postfix increments counter but return the old value before being incremented.

Technical Response: Yes, the prefix form ++counter increments counter and returns the new value. The postfix form counter++ also increments the counter but returns the old value before being incremented.

Code Example:

// Prefix Position:
let counterOne = 5;
let a = ++counterOne; // (*)

alert(a); // alerts 6

// Postfix Position:
let counterTwo = 5;
let b = counterTwo++; // (*) changed ++counter to counter++

alert(b); // alerts 5

Can the ++/-- operators be used within expressions?​

View Answer:
Interview Response: Technically, yes, but it is not advisable because it reduces the readability of our code.

Technical Response: Though technically okay, such notation should be avoided and usually makes code less readable. We should use a typical style of one-line action in our code.

Proper Implementation:

// We advise a style of “one line – one action”:
let counter = 1;
alert(2 * counter); // 2
counter++;

How do Bitwise operators treat arguments as 16-Bit, 24-Bit, or 32-Bit integer numbers?​

View Answer:
Interview Response: Bitwise operators treat arguments as 32-bit integer numbers and work on the level of their binary representation.

Code Example:

console.log(1100 & 1011); // 1011
console.log(1100 | 1011); // 1111

What is the comma operator used for in JavaScript?​

View Answer:
Interview Response: The comma operator allows us to evaluate several expressions, dividing them with a comma. Each of them gets evaluated, but only the result of the last one gets returned.

Code Example:

let a = (1 + 2, 3 + 4);

alert(a); // 7 (the result of 3 + 4)

Why do we need the comma operator that throws away everything except the last expression?​

View Answer:
Interview Response: Sometimes, people use it in more complex constructs to put several actions in one line, and it is not a standard or recommended approach.

Code Example: Three expressions in one line…

// three operations in one line: Commonly used in frameworks
for (a = 1, b = 3, c = a * b; a < 10; a++) {
 ...
}

Does the comma operator have high or low precedence?​

View Answer:
Interview Response: The comma operator has exceptionally low precedence, lower than the assignment operator.