Types

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

• когда вам нужно работать с математикой, вам нужно число.

• когда вам нужно вывести значение на экран, вам нужна строка(один или несколько символов, слов, предложений).

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

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

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

42;

true;
false;

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

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

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

• string(строка)

• number(число)

• boolean(логическое значение)

• null(пустое значение)

• undefined (значение не объявлено)

• object(объект)

• symbol(символ, новое в ES6)

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

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.

Числа

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

var myAge = 17;

Строки

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

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

Логические

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

var iAmAlive = true;

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

var test = 6 < 3;

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

Массивы

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

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

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

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

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

Объекты

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

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

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

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

dog.name

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

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

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, которое, конечно, является истинным.