### Introduction

**Data types** are used to classify one particular type of data in programming languages. For instance, a number and a string of characters are different types of data that will be treated differently by JavaScript.

This is important because the specific data type you use will determine what values you can assign to it and what you can do to it. This is to say, to be able to do operations with variables in JavaScript, it is important to understand the data type of any given variable.

In this tutorial, we will go over how data types work in JavaScript as well as the important data types native to the language. This is not an exhaustive investigation of data types, but will help you become familiar with the options available to you in JavaScript.

## Dynamic Typing

JavaScript has dynamic data types, meaning that type checking is done at runtime rather than compile time. Python’s data types are also dynamically typed.

With dynamically typed languages, a variable of the same name can be used to hold different data types.

For example, the variable `t`

, defined as a variable by the `var`

keyword, can be assigned to hold different data types, or can be initialized but left undefined:

```
var t = 16; // t is a number
var t = "Teresa"; // t is a string
var t = true; // t is a Boolean
var t; // t is undefined
```

Each of the variables `t`

above can be set to any data type available in JavaScript; they do not need to be explicitly declared with a data type before they are used.

## Numbers

JavaScript has only one number type, there is no separate designation for integers and floating-point numbers. Because of this, numbers can be written in JavaScript with or without decimals:

```
var num1 = 93;
var num2 = 93.00;
```

In both cases above, the data type is a number and is the same regardless of whether or not the number has decimal points.

Scientific exponential notation can be used in JavaScript to abbreviate very large or small numbers, as in the following examples:

```
var num3 = 987e8; // 98700000000
var num4 = 987e-8; // 0.00000987
```

Numbers in JavaScript are considered to be accurate up to 15 digits. That means that numbers will be rounded after the 16th digit is reached:

```
var num5 = 999999999999999; // remains as 999999999999999
var num6 = 9999999999999999; // rounded up to 10000000000000000
```

In addition to representing numbers, the JavaScript number type also has three symbolic values available:

`Infinity`

— a numeric value that represents a**positive**number that approaches infinity`-Infinity`

— a numeric value that represents a**negative**number that approaches infinity`NaN`

— a numeric value that represents a non-number, standing for**n**ot**a****n**umber

`Infinity`

or `-Infinity`

will be returned if you calculate a number outside of the largest possible number available in JavaScript. These will also occur for values that are undefined, as when dividing by zero:

```
var num7 = 5 / 0; // will return Infinity
var num8 = -5 / 0; // will return -Infinity
```

In technical terms, `Infinity`

will be displayed when a number exceeds the number `1.797693134862315E+308`

, which represents the upper limit in JavaScript.

Similarly, `-Infinity`

will be displayed when a number goes beyond the lower limit of `-1.797693134862316E+308`

.

The number `Infinity`

can also be used in loops:

```
while (num9 != Infinity) {
// Code here will execute through num9 = Infinity
}
```

For numbers that are not legal numbers, `NaN`

will be displayed. If you attempt to perform a mathematical operation on a number and a non-numeric value, `NaN`

will be returned. This is the case in the following example:

```
var x = 20 / "Shark"; // x will be NaN
```

Since the number `20`

cannot be divided by the string `"Shark"`

because it cannot be evaluated as a number, the returned value for the `x`

variable is `NaN`

.

However, if a string can be evaluated as a numeric value, the mathematical expression can be performed in JavaScript:

```
var y = 20 / "5"; // y will be 4
```

In the above example, since the string `"5"`

can be evaluated as a numeric value in JavaScript, it is treated as such and will work with the mathematical operator for division, `/`

.

When assigning the value `NaN`

to a variable used in an operation, it will result in the value of `NaN`

, even when the other operand is a legal number:

```
var a = NaN;
var b = 37;
var c = a + b; // c will be NaN
```

There is only one number data type in JavaScript. When working with numbers, any number you enter will be interpreted as the data type for numbers; you are not required to declare what kind of data type you are entering because JavaScript is dynamically typed.

## Strings

A **string** is a sequence of one or more characters (letters, numbers, symbols). Strings are useful in that they represent textual data.

In JavaScript, strings exist within either single quotes `'`

or double quotes `"`

, so to create a string, enclose a sequence of characters in quotes:

```
var singleQuotes = 'This is a string in single quotes.';
```

```
var doubleQuotes = "This is a string in double quotes.";
```

You can choose to use either single quotes or double quotes, but whichever you decide on you should remain consistent within a program.

The program “Hello, World!” demonstrates how a string can be used in computer programming, as the characters that make up the phrase `Hello, World!`

in the `alert()`

below are a string.

```
<!DOCTYPE HTML>
<html>
<head>
<script>
function helloFunction() {
alert("Hello, World!");
}
</script>
</head>
<body>
<p><button onclick="helloFunction()">Click me</button></p>
</body>
</html>
```

When we run the code and click on the `Click me`

button, we’ll receive a pop-up with the following output:

```
Hello, World!
```

As with other data types, we can store strings in variables:

```
var hw = "Hello, World!";
```

And display the string in the `alert()`

by calling the variable:

```
...
<script>
var hw = "Hello, World!";
function helloFunction() {
alert(hw);
}
</script>
...
```

```
Hello, World!
```

There are many operations that we can perform on strings within our programs in order to manipulate them to achieve the results we are seeking. Strings are important for communicating information to the user, and for the user to communicate information back to the program.

## Booleans

The **Boolean** data type can be one of two values, either **true** or **false**. Booleans are used to represent the truth values that are associated with the logic branch of mathematics, which informs algorithms in computer science.

Whenever you see the data type Boolean, it will start with a capitalized **B** because it is named for the mathematician George Boole.

Many operations in math give us answers that evaluate to either true or false:

**greater than**- 500 > 100
`true`

- 1 > 5
`false`

- 500 > 100
**less than**- 200 < 400
`true`

- 4 < 2
`false`

- 200 < 400
**equal**- 5 = 5
`true`

- 500 = 400
`false`

- 5 = 5

Like with other data types, we can store a Boolean value in a variable:

```
var myBool = 5 > 8; // false
```

Since 5 is not greater than 8, the variable `myBool`

has the value of `false`

.

As you write more programs in JavaScript, you will become more familiar with how Booleans work and how different functions and operations evaluating to either true or false can change the course of the program.