What happens if we try to multiply a number by a string? JavaScript will return the NaN (not a number) value we've seen before. This happens whenever incompatible values are used together. In this case, a number and a string:
3 * 'Dracarys'; // NaN
In high-level programming languages, data are categorized by type. A string refers to the String type, while numbers refer to Number and BigInt (very large numbers). What are these data types for? They help to protect your program from hard-to-find errors. Types determine two things:
- Possible values. For example, numbers in JavaScript are divided into two types: Number and BigInt. All numbers below a certain threshold (you can check it) belong to the Numbers data type, and all numbers above it belong to the Biglnt type. They're divided this way due to the hardware's technical features
- A set of operations applied to this data type. For example, you can multiply integers, but not strings. Multiplying the word "mother" by the word "notepad" makes no sense
Javascript may act in one of two possible ways when it sees a violation. In some situations, it'll terminate the program with an error. In others, the program will continue to work, though an invalid operation will return something like NaN as in the example above.
How does JavaScript detect the data type? It's quite simple. Any value is initialized somewhere and, based on an initialization method, it understands what type of data it is. Numbers, for instance, are just numbers without any extra characters, apart from the point (.) for rational numbers. Strings, on the other hand, always require enclosing with special characters (there are three ways to write strings in JavaScript). For example, '234' is a string, even though there are numbers in quotes.
You can find out a data type using typeof operator:
typeof 3; // 'number'
typeof 'Game'; // 'string'
The Number, BigInt, and String data types are primitive types. But there is more. JavaScript has a built-in composite type Object (as well as arrays, dates and others based on it). It serves to combine data of different types into a single value, e.g. we can create a user combining his name and age.
// This notation you'll learn later on Hexlet courses
const user = { name: 'Toto', age: 33 };
undefined
It's possible to declare variable without giving it a specific value. What will be printed in this case?
let name;
console.log(name); // ?
undefined is a special value of its own type that denotes an absence of value. Undefined is used by JavaScript in many different cases, for example when calling a non-existent string character:
const name = 'Arya';
console.log(name[8]);
The meaning (semantics) of undefined is an absence of value. However, nothing stops you from writing the following code:
let key = undefined;
Although the interpreter allows this, it violates the semantics of undefined, because this code performs an assignment and therefore substitutes a value.
JavaScript is one of the few languages that explicitly includes undefined. Other languages use null instead of undefined, and JavaScript uses null too.
Self-check. Why can't we declare a constant without specifying a value?
Floating-point numbers
In mathematics there are different kinds of numbers, for example, natural numbers are integers from one and up, or rational numbers are numbers with a point, such as 0.5. There is a vacuum between both types of numbers from the perspective of computers. Try this basic calculation: what is the sum of 0.2 + 0.1? Let's have a look at what JavaScript has to say about this:
0.2 + 0.1 // 0.30000000000000004
Adding two rational numbers has suddenly led to an imprecise result. Other programming languages deliver the same result. This happens due to the limits of computing power. The amount of memory, unlike the amount of numbers, is finite (an infinite amount of numbers requires an infinite amount of memory to store).
Rational numbers are not lined up in a continuous chain like integers, there's an infinite amount of numbers between 0.1 and 0.2. So now we have a big problem: how can we store rational numbers? Excellent question. There is a myriad of articles in the internet about memory organization in these cases. Moreover, there is even a standard describing how to do it correctly, and an overwhelming number of languages are based on this set of recommendations.
As developers, it's important to understand that operations with floating numbers are not precise (though precision can be adjusted using special tricks).
