JavaScript has several operators to perform arithmetic calculations. The following table lists them:

Arithmetic Operators

Consider the following line of code:

var myNumber = 2 + 2;

This code creates a variable called myNumber. Its value is the result of a mathematic operation adding 2 and 2 together; thus, the value assigned to the myNumber variable is 4.

Mathematical operations are not limited to using numeric literals; variables containing a numeric value can be used in any mathematical expression. The following code uses the myNumber variable created earlier in another mathematical calculation:

myNumber = myNumber - 4;

Remember that assignment operations always go from right to left. So the expression on the right side of the equals sign (myNumber - 4) is evaluated, and the resulting value is assigned to the variable on the left side of the equals sign. Since myNumber's value is 4, this code is essentially the same as the following:

myNumber = 4 - 4;

Arithmetic operations are not limited to one operation per statement; a statement can contain multiple operations, like the following code:

myNumber = 1 + 2 * 3 – 4 / 2;

Executing this statement results in the myNumber variable's containing a value of 5. JavaScript's arithmetic operators have a precedence order similar to the "My Dear Aunt Sally" order in mathematics. Multiplication and division operations have a higher precedence than addition and subtraction, so they execute first. The previous code could be rewritten to the following code after the multiplication and division operations have been performed:

myNumber = 1 + 6 - 2;

Also as in mathematics, you can use parentheses to give a higher precedence to certain operations. The following code adds some parentheses to the previous code sample:

myNumber = (1 + 2) * 3 - 4 / 2;

By placing parentheses around the 1 + 2 operation, you give it a higher precedence than multiplication or division, so it is executed first, followed by the multiplication and division operations, and finally by the subtraction operation. Because the 1 + 2 operation is executed first, the result value has changed from 5 to 7.

Operator precedence determines the outcome of mathematical operations. So it's important to keep operator precedence in mind when performing them.

The final operator, the modulus (or remainder) operator, is represented by a percent sign (%). It performs a division operation on the two operands and returns the remainder of the quotient. The following code demonstrates this:

var remainder = 3 % 2; // returns 1
var remainder2 = 2 % 2; // returns 0

The modulus operator is very handy when you're testing whether a numeric value is even or odd. If the result of a modulus operation by 2 is 0, the number is even. If it is any other number, the number it's odd. Look at the following code:

var isEven = 4 % 2; // 0 - so even
var isOdd = 1 % 2; // 1 - so odd

There are times when a numeric operation fails, such as one that divides by zero or breaks some other mathematical rule. Instead of registering an error and halting code execution (as many other languages do), JavaScript uses a special numeric value called NaN, meaning Not a Number, to indicate that a mathematical operation failed. The following code results in a value of NaN, since it is illegal to divide by zero:

var nan = 1 / 0;

Any operation involving a NaN value always results in NaN. This has the side effect of possibly ruining mathematical operations that contain multiple steps.

Like the Number data type, strings are immutable. A string value cannot change once it has been created. Modifying a string value involves destroying the original string value and replacing it with a different value.

Say a variable called str1 contains a string value of "This is a string.". The following code demonstrates this:

var str1 = "This is a string.";

The string value assigned to str1 cannot technically be altered; however, a concatenation, or joining, operation can use the original value contained within str1 and join it with another string value to create a new string value.

Concatenating two or more strings requires the use of the concatenation operator: the plus sign (+). The following code concatenates the original string value in str1 with another string value to modify the data contained within str1:

str1 = str1 + " Hello, World!";

The value now contained within str1 is "This is a string. Hello, World!".

Focus on the code that appears to the right of the assignment operator (the equals sign). This expression is a concatenation operation. The first operand retrieves a copy of str1's value (remember that values are not used directly; they are copied). The second operand is a string literal, and the concatenation operation joins the two values into one value — a value that is then assigned to the str1 variable.

Note the space before Hello in the string literal. If the space had been left out, the concatenated string would be "This is a string.Hello World!". JavaScript will not format strings automatically for you; you must do that yourself.

The same principle can be applied to multiple variables. Look at this code:

var firstString = "This is a string.";
var greetingString = "Hello,";
var name = "Jeremy";
var finalString = firstString + " " + greetingString + " " + name + "!";

This code initializes four strings. The first three are simple strings, and the fourth concatenates the first three into a greeting. Notice that this time, the first three string values do not contain spaces to help with formatting. Instead, the concatenation operation in the fourth line of code inserts spaces as needed. So the value assigned to finalString is this: "This is a string. Hello, Jeremy!".

String concatenation may be confusing at first, especially since the + operator sign is typically used for mathematical operations. This operator pulls double duty as an addition operator and a string concatenation operator in many languages. In JavaScript, the confusion comes from the use of the + operator with values of differing types. Look at the following code as an example:

var possiblyConfusing = "This is the number " + 1;

This code declares and initializes a variable called possiblyConfusing. The expression on the right side of the equals sign consists of a string value, a + operator, and a number. JavaScript is smart enough to know that the string "This is the number " cannot be used in a mathematical operation. Therefore, JavaScript converts the number 1 to a string and concatenates the two operands together. The value contained within the variable is "This is the number 1".

When a string is involved in an operation consisting of the + sign, as in the previous line of code, all non-string values to the right of the string are converted to string values. The operand to the left of the operator maintains its original value, but the end result is a string value

Keep that in mind as you look at the following code and determine the result of the operation:

var probablyConfusing = 1 + 2 + "45";

In this code, the expression to the right of the = operator consists of three operands. The first two are number values, and the third is a string. Since the two numbers are to the left of the string, they are treated as numbers, and the + operator performs an addition operation. So this code can be simplified to this:

var probablyConfusing = 3 + "45";

Now JavaScript sees a number value and a string value and treats the + operator as a concatenation operator. The final value that is assigned to the probablyConfusing variable is "345". Even though the string looks like a number, it is still a string. Any operation involving the + operator and a string results in a concatenation operation.

A string can be converted to a number using any other arithmetic operator. Look at the following example:

var probablyConfusing = "1" + 2 - 3;

In this code, the string "1" is concatenated with the numeric value 2. So this code can be simplified like this:

var probablyConfusing = "12" - 3;

The subtraction operation, however, is not a valid string operator. So JavaScript converts the string to a numeric value and performs the operation. The result of this code is 9, since "12" is converted to 12.

There are more ways to convert a string to a number, however. JavaScript provides two functions to convert strings to numbers: the parseInt() and parseFloat() functions. You'll learn much more about functions later, but for now all you need to know is that functions perform work on data.

Calling a function is as simple as using the function's identifier followed by a pair of parentheses, like this:

parseInt();

This executes the parseInt() function. However, it returns a value of NaN because it does not have any data to work with. Some functions, like parseInt(), accept data in the form of arguments, a set of special variables used by the function. For example, the parseInt() function accepts a string value to convert to a number, like this:

var num = parseInt("45");

This code converts the string "45" to the number 45 and stores it in the num variable. The parseInt() function returns an integer (a whole number) value. If a string containing a decimal number is passed to the parseInt() function, it drops the decimal and the numbers after it and returns the whole number. It does not round up. The following code demonstrates this:

num = parseInt("1.8392"); // returns 1

In this code, a string containing a decimal number is passed to the function. The result is the whole number: 1.

It is sometimes desirable to keep the numbers after the decimal. In cases such as these, use the parseFloat() function. An example is shown here:

var floatingNum = parseFloat("1.8392"); // returns 1.8392

In this code, the same string is passed to the parseFloat() function, and the result is the exact number passed to the function.

The parseInt() and parseFloat() functions parse the strings passed to them. They work by starting at the beginning of the string and look at each character in the string. The function determines if the character is a valid number. If it is, the function uses that numeric value to start building the number to return and looks at the next character. If the character isn't a number, JavaScript assumes the number has ended and stops parsing the string. This means that these two functions can parse strings that also contain alphabetical characters. The following code shows this:

var num = parseInt("1234abcd"); // returns 1234
var decNum = parseFloat("1.234abcd"); // returns 1.234
var num2 = parseInt("1234abcd5678"); // returns 1234

This code demonstrates how parseInt() and parseFloat() parse strings that contain alphabetical characters. In all three lines, the parsing functions begin parsing the strings with the first character, and they stop parsing when they encounter a non-numeric character. The third line demonstrates this better, since the string passed to parseInt() contains several numeric characters separated by a group of alphabetical characters.

The parseInt() function accepts an optional second argument called a radix. The radix determines what numeral system the string passed in the first argument is converted to. For example, we humans use a base 10 numeral system, but computers use a base 2 (binary) system. The binary number 100 is actually the base 10 number 4. When calling parseInt(), it's important to specify the radix; otherwise, JavaScript may interpret the string as a number of a different numeral system. So, if you want to convert a string to a number that we humans use, specify the radix of 10, like this:

var parsedNumber = parseInt("1043", 10); // 1043

JavaScript is somewhat unique in that true and false are not the only Boolean values in the language. In fact, all data types have values that are equivalent to true and false. JavaScript developers call these values truthy and falsy.

The Number data type's falsy values are the number zero (0) and NaN, , and all other numbers are considered truthy. The following code offers some examples of truthy and falsy number values:

var truthyVar = −56;
var truthyVar2 = 0.453;
var falseyVar = 0;
var falseyVar2 = 1 / 0;

The String data type follows along the same lines as numbers. An empty string ("") is a falsy value, whereas anything other than an empty string is a truthy value. The following lines of code show some examples:

truthyVar = " ";
truthyVar2 = "This is a string.";
falseyVar = "";

JavaScript has two more primitive data types, and they both serve as falsy values.