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.