# JavaScript Data types ES6

A variable in JavaScript can contain any data. A variable can at one moment be a string and at another be a number:

``````// no error
let message = "hello";
message = 123456;``````

Programming languages that allow such things are called “dynamically typed”, meaning that there are data types, but variables are not bound to any of them.

There are seven basic data types in JavaScript. Here, we’ll cover them in general and in the next chapters, we’ll talk about each of them in detail.

## A number

``````let n = 123;
n = 12.345;``````

The number type represents both integer and floating point numbers.

There are many operations for numbers, e.g. multiplication `*`, division `/`, addition `+`, subtraction `-`, and so on.

Besides regular numbers, there are so-called “special numeric values” which also belong to this data type: `Infinity``-Infinity` and `NaN`.

• `Infinity` represents the mathematical Infinity ∞. It is a special value that’s greater than any number.

We can get it as a result of division by zero:

``alert( 1 / 0 ); // Infinity``

Or just reference it directly:

``alert( Infinity ); // Infinity``

• `NaN` represents a computational error. It is a result of an incorrect or an undefined mathematical operation, for instance:

``alert( "not a number" / 2 ); // NaN, such division is erroneous``

`NaN` is sticky. Any further operation on `NaN` returns `NaN`:

``alert( "not a number" / 2 + 5 ); // NaN``

So, if there’s a `NaN` somewhere in a mathematical expression, it propagates to the whole result.

## A string

A string in JavaScript must be surrounded by quotes.

``````let str = "Hello";
let str2 = 'Single quotes are ok too';
let phrase = `can embed \${str}`;``````

In JavaScript, there are 3 types of quotes.

1. Double quotes: `"Hello"`.
2. Single quotes: `'Hello'`.
3. Backticks: ``Hello``.

Double and single quotes are “simple” quotes. There’s no difference between them in JavaScript.

Backticks are “extended functionality” quotes. They allow us to embed variables and expressions into a string by wrapping them in `\${…}`, for example:

``````let name = "John";

// embed a variable
alert( `Hello, \${name}!` ); // Hello, John!

// embed an expression
alert( `the result is \${1 + 2}` ); // the result is 3``````

The expression inside `\${…}` is evaluated and the result becomes a part of the string. We can put anything in there: a variable like `name` or an arithmetical expression like `1 + 2` or something more complex.

Please note that this can only be done in backticks. Other quotes don’t have this embedding functionality!

``````alert( "the result is \${1 + 2}" ); // the result is \${1 + 2} (double quotes do nothing)
``````
`We’ll cover strings more thoroughly in the chapter Strings.`

## A boolean (logical type)

The boolean type has only two values: `true` and `false`.

This type is commonly used to store yes/no values: `true` means “yes, correct”, and `false` means “no, incorrect”.

For instance:

``````let nameFieldChecked = true; // yes, name field is checked
let ageFieldChecked = false; // no, age field is not checked``````

Boolean values also come as a result of comparisons:

``````let isGreater = 4 > 1;

alert( isGreater ); // true (the comparison result is "yes")``````

We’ll cover booleans more deeply in the chapter Logical operators.