> For the complete documentation index, see [llms.txt](https://andersenlab.gitbook.io/javascript/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://andersenlab.gitbook.io/javascript/js-basics/grammar-and-types/types.md).

# Types

Когда вы указываете значения в программе, вы выбираете разные представления для этих значений в зависимости от того, что вы планируете делать с ними. Разнообразные представления для значений в терминологии программирования называются *типы* . В JavaScript есть встроенные типы для каждого из этих *примитивных* значений:

* когда вам нужно работать с математикой, вам нужно `число`.
* когда вам нужно вывести значение на экран, вам нужна `строка`(один или несколько символов, слов, предложений).
* когда вам нужно принять решение в своей программе, вам нужно `логическое значение`(`true`(`истина`) или `false`(`ложь`)).

Значения, непосредственно включаемые в исходный код, называются *литералы*. `строковые` литералы заключаются в двойные кавычки`"..."`или одинарные (`'...'`) — единственная разница в них — это ваши стилистические предпочтения. Литералы `числа` и `логического значения` пишутся как есть (т.е.,`42`, `true` и т.д.).

```javascript
"Я - строка";
'Я - тоже строка';

42;

true;
false;
```

Кроме типов значений `строка/число/логическое значение` для языков программирования привычно предоставлять такие типы, как *массивы*, *объекты*, *функции* и многие другие.

## Значения и типы

В JavaScript есть типизированные значения, а не типизированные переменные. Доступны следующие встроенные типы:

* `string`(строка)
* `number`(число)
* `boolean`(логическое значение)
* `null`(пустое значение)
* `undefined` (значение не объявлено)
* `object`(объект)
* `symbol`(символ, новое в ES6)

JavaScript предоставляет операцию `typeof`, которая умеет оценивать значение и сообщать вам, какого оно типа:

```javascript
var a;
typeof a;                // "undefined"

a = "hello world";
typeof a;                // "string"

a = 42;
typeof a;                // "number"

a = true;
typeof a;                // "boolean"

a = null;
typeof a;                // "object" — ошибка!!!

a = undefined;
typeof a;                // "undefined"

a = { b: "c" };
typeof a;                // "object"

a = Symbol();
typeof a;                               // "symbol"
```

Значение, возвращаемое операцией`typeof`, всегда одно из шести (семи в ES6! - тип "symbol") строковых значений. Это значит, что `typeof "abc"`вернет`"string"`, а не`string.`

Обратите внимание, как в этом коде переменная `a` хранит каждый из различных типов значений, и, несмотря на видимость, `typeof a` спрашивает не "тип `a`", а "тип текущего значения в `a`." Только у значений есть типы в JavaScript, переменные являются всего лишь контейнерами для этих значений.

`typeof null`— это интересный случай, так как он ошибочно возвращает`"object"`, тогда как вы ожидали, что он вернет`"null".`Это давнишняя ошибка в JS, но она, похоже, никогда не будет исправлена. Слишком много кода в интернет полагается на нее, и ее исправление, соответственно, повлечет за собой намного больше ошибок!

Обратите внимание на `a = undefined`. Мы явно установили `a` в значение `undefined`, но оно по поведению не отличается от переменной, у которой еще не установлено значение, например, как тут: `var a;`, в строке в начале блока кода. Переменная может получать состояние значения "undefined" разными путями, включая функции, которые не возвращают значения и использование операции `void`.

### Числа <a href="#chisla" id="chisla"></a>

Вы можете хранить числа в переменных (целые числа, такие, как 30, или десятичные числа, такие, как 2.456, также называемые числами с плавающей точкой или с плавающей запятой).

```javascript
var myAge = 17;
```

### Строки <a href="#stroki" id="stroki"></a>

Строки - это фрагменты текста. Когда вы даете переменной значение строки, вам нужно обернуть ее в одиночные или двойные кавычки, в противном случае JavaScript попытается проиндексировать ее как другое имя переменной.

```javascript
var dolphinGoodbye = 'So long and thanks for all the fish';
```

### Логические <a href="#logicheskie" id="logicheskie"></a>

Booleans - это истинные / ложные значения - они могут иметь два значения: true или false. Они обычно используются для проверки состояния, после чего код запускается соответствующим образом. Так, например, простой случай:

```javascript
var iAmAlive = true;
```

В действительности вы чаще будете использовать этот тип переменных так:

```javascript
var test = 6 < 3;
```

Здесь используется оператор «меньше» (<), чтобы проверить, является ли 6 меньше 3. Как и следовало ожидать, он вернет false, потому что 6 не меньше 3!

### Массивы <a href="#massivy" id="massivy"></a>

Массив - это один объект, который содержит несколько значений, заключенных в квадратные скобки и разделенных запятыми. Попробуйте ввести следующие строки в консоль:

```javascript
var myNameArray = ['Chris', 'Bob', 'Jim'];
var myNumberArray = [10,15,40];
```

Как только эти массивы определены, вы можете получить доступ к каждому значению по их местоположению в массиве. Попробуйте следующие строки:

```javascript
myNameArray[0]; // should return 'Chris'
myNumberArray[2]; // should return 40
```

Квадратные скобки указывают на значение индекса, соответствующее позиции возвращаемого значения. Возможно, вы заметили, что массивы в JavaScript индексируются с нулевой отметкой: первый элемент имеет индекс 0.

### Объекты <a href="#obekty" id="obekty"></a>

В программировании объект представляет собой структуру кода, которая моделирует объект реальной жизни. У вас может быть простой объект, представляющий автостоянку, содержащий информацию о ширине и длине, или вы можете иметь объект, который представляет человека и содержит данные об имени, высоте, весе, на каком языке он говорит, как сказать привет и многое другое.

Попробуйте ввести следующую строку в консоль

```javascript
var dog = { name : 'Spot', breed : 'Dalmatian' };
```

Чтобы получить информацию, хранящуюся в объекте, вы можете использовать следующий синтаксис:

```javascript
dog.name
```

### Преобразование между типами

Если у вас есть `число`, но вам нужно вывести его на экран и преобразовать его значение в `строку`. В JavaScript такая конвертация называется «приведение (coercion)». Если кто-то вводит серию цифр в форму на веб-странице - это `строка`, но если нужно потом использовать это значение для выполнения математических операций, то вам понадобится *приведение* его к `числу`.

JavaScript предоставляет несколько различных возможностей принудительного приведения между *типами*. Например:

```javascript
var a = "42";
var b = Number( a );

console.log( a );    // "42"
console.log( b );    // 42
```

Использование `Number(..)`(встроенная функция), как было показано выше, - это *явное* приведение из любого другого типа в тип `число`. Это выглядит достаточно очевидно.

Что произойдет, когда вы попытаетесь сравнить два значения разных типов, которые могут потребовать *неявного* приведения. При сравнении строки`"99.99"` с числом `99.99` многие согласятся, что они равны. Это одно и тоже значение в двух разных представлениях, двух разных *типах*. Чтобы помочь вам в таких стандартных ситуациях, JavaScript иногда вмешивается и *неявно* приводит значения к подходящим типам.

Поэтому, если вы используете операцию нестрогого равенства`==`для сравнения`"99.99" == 99.99`, JavaScript преобразует с левой стороны`"99.99"`в его `числовой` эквивалент `99.99`. После этого сравнение превращается в`99.99 == 99.99`, которое, конечно, является `истинным`.