JavaScript defines multiple data types. The primitive types are string, number, boolean, and symbol, and the special types include undefined and null. In addition to the primitive data types, JavaScript also has the composite data type object for objects.

17.5.1    Number Data Type (Numbers)

let integerValue = 12345;
console.log(typeof integerValue); // Output: number
let floatingPointValue = 123.123;
console.log(typeof floatingPointValue); // Output: number 

If a value doesn’t correspond to a correct numerical value, NaN (NaN = not a number) will be used as the value. If the value range has been exceeded or fallen below, Infinity or ‐Infinity will be used as the value. For this reason, there are two constants: Number.POSITIVE_INFINITY and Number.NEGATIVE_INFINITY. If you want to determine the smallest or largest possible number you can use, the Number.MIN_VALUE and Number.MAX_VALUE constants are useful:

console.log(Number.MIN_VALUE); // Output: 5e-324
console.log(Number.MAX_VALUE); // Output: 1.7976931348623157e+308
console.log(Number.NEGATIVE_INFINITY);  // Output: -Infinity
console.log(Number.POSITIVE_INFINITY);  // Output: Infinity 

Let’s take a look at a simple example:

let aText1 = "String in JavaScript";
console.log(typeof aText1); // Output: string
let aText2 = 'Also a string in JavaScript';
console.log(typeof aText2); // Output: string
let aText3 = "12345";
console.log(typeof aText3); // Output: string 

Whether you use single or double quotation marks is up to you. A good style is to choose one version and then use it consistently. What’s more convenient about using single quotes is that you can use special characters within the string without an escape sequence, which is an advantage especially because double quotes are often used in some countries. For example:

let aText4 = "Quotation marks in \"text\""; // escape sequence needed
console.log(aText4); // Output: Quotation marks in "text"
let aText5 = 'Quotation marks in "text"'; // without escape sequence
console.log(aText5); // Output: Quotation marks in "text" 

Escape sequences are control characters that you can insert into strings as variable values. Such control characters are preceded by the character \ followed by the letter marking the control character. For example, you can insert a line break using the control character \n, or you can insert a tab feed via \t:

let aText6 = "Insert a line break\n"; // line break at the end
let aText7 = "The text will be output in the next line.\n";
let aText8 = "\tThe text will be indented.\n";
console.log(aText6 + aText7 + aText8); 

let text1 = "Last line";
console.log("First line\n" + "Second line\n" + text1);
// First line
// Second line
// Last line 

You can write the same with the template strings as follows:

...
console.log(`First line
Second line
${text1}
`); 

I think this looks much clearer because you can enter the text as you want it to be displayed. To insert JavaScript expressions into the strings, you can use the notation ${expression}. In the example, the value of the variable text1 was used as an expression.

17.5.4    Boolean Data Type

let mname = {
    lname: 'Wolfe',
    fname: 'Jason'
};
console.log(mname); // Output: {lname: "Wolfe", fname: "Jason"}
mname = null;
console.log(mname); // Output: null 

Unlike undefined, null is a JavaScript keyword. The type null was listed as a data type, but a typeof null returns the type object. Variables you’ve initialized with null are thus of the type object. An uninitialized variable, on the other hand, is undefined. Unlike null, undefined isn’t meant to be assigned to a variable. The value undefined simply indicates that a variable hasn’t yet been initialized with a value. null, on the other hand, is an empty object.

let val = 123;
console.log(typeof val); // Output: number
val = "Now a string";
console.log(typeof val); // Output: string 

While such an example isn’t intended to form a precedent, it shows how the variable val is first used as a numerical value, and after it was assigned a string, the data type got converted into a string.

You’ve already seen something similar when you added a string with a numerical value using the + operator, whereupon the number was converted to a string:

let text = 5 + " You should be friends";
console.log(typeof text); // Output: string 

However, this only applies to the + operator in conjunction with strings, which is used to link them together. On the other hand, if you use other operators such as -, *, or /, JavaScript no longer converts the numbers to strings, but tries to convert the strings to numbers. Consider this example:

let text1 = "100" - 44;    // 56
console.log(typeof text1); // Output: number
let text2 = "100" + 44;    // "10044"
console.log(typeof text2); // Output: string
console.log("10" / "2");   // Output: 5 

let notANumber = "100 elements" - 50;
console.log(typeof notANumber);   // Output: number
console.log(notANumber);          // Output: NaN
console.log( isNaN(notANumber) ); // Output: true 

The arithmetic calculation of "100 elements" - 50 doesn’t provide a meaningful value. Although typeof returns number here, the output of the variable notANumber confirms that no valid value was calculated and stored here, which is why the result is NaN. The check using the isNaN() function confirms this too. The isNaN() function is therefore needed because it isn’t possible to check the value for NaN with ==.