Типы данных JavaScript. Числа, строки, null, undefined, булевы значения

Каждое значение в языке программирования относится к определённому типу данных. Тип данных определяет типы значений, которые используются в языке программирования. Типы данных в JavaScript можно разделить на две категории - простые типы и составные..

Типы данных JavaScript

» » Сообщение:

В процессе работы компьютерные программы манипулируют значениями, такими как число 7 или текcт "HelloWorld!".
Каждое значение, которое может быть представлено и обработано в языке программирования относится к определённому типу данных. Тип данных определяет типы значений, которые используются в языке программирования.

Типы данных в JavaScript можно разделить на две категории: простые (их также называют примитивные) типы и составные (объекты).
К категории простых типов относятся:

  • String - текстовые строки (обычно их называют просто - строки)
  • Number - числа
  • Boolean - логические (булевы) значения

Так же к простым типам относятся два специальных значения:

  • null
  • undefined

К составным типам данных относятся:

  • Function - функции
  • Array - массивы
  • Object - объекты

Числа

Значениями типа Number являются целые числа и числа с плавающей точкой.
Для поддержки чисел разных типов предусмотрено несколько разных форматов числовых литералов:

Код: Выделить всё Развернуть
12         // Литерал целого числа
9.3        // Литерал числа с плавающей точкой
.3         // Если целая часть числа с плавающей точкой является нулём, её можно опустить
0xff       // Шестнадцатеричный литерал
023        // Восьмеричный литерал
334e21     // Литерал экспоненциальной записи
6.02e-23   // Литерал экспоненциальной записи

Для представления чисел в JavaScript используется 64-битный формат, определяемый стандартом IEEE-754.
Этот формат способен представлять числа с плавающей точкой в диапазоне от 5e-324 до 1.7976931348623157e+308.
Наименьшее и наибольшее числа, которые могут быть представлены в JavaScript, хранятся в свойствах Number.MIN_VALUE и Number.MAX_VALUE.

Формат представления чисел в JavaScript позволяет точно представлять все целые числа в диапазоне от -9007199254740992 до 9007199254740992 включительно. А значения с плавающей точкой представляются с точностью до 17-го десятичного разряда (не включая сам 17 разряд). Из-за этого например, сложение 0.1 и 0.2 даёт в результате 0.30000000000000004 вместо 0.3.
Такие небольшие ошибки округления затрудняют проверку конкретных значений с плавающей точкой.

Очень большие и очень малые числа с плавающей точкой можно представлять в экспоненциальной записи.
Экспоненциальная запись означает число умноженное на 10 в указанной степени.
Число в экспоненциальной записи состоит из числа (целого или с плавающей точкой) за которым ставится прописная или строчная буква E, после которой можно поставить необязательный знак плюс или минус и далее показатель степени числа 10. Рассмотрим например значение 3.52x105 (352 000). Вместо всего, что находится между числом и экспонентой, нужно поставить букву "e", в результате предыдущую запись можно представить в таком виде:

Код: Выделить всё Развернуть
var bigNumber = 3.52e5;
Код: Выделить всё Развернуть
// Ещё примеры
6.02e23    // 6.02 x 1023
1.473E-32  // 1.473 x 10-32

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

Код: Выделить всё Развернуть
alert(0.0000005); // 5e-7

Любому числовому литералу может предшествовать знак минус (-), делающий число отрицательным.

Код: Выделить всё Развернуть
var temperature = -20;

Из-за того что для хранения чисел с плавающей точкой требуется вдвое больше памяти, чем для целых чисел, JavaScript по возможности преобразует их в целые числа. Если после десятичной точки нет разрядов, число становится целым:

Код: Выделить всё Развернуть
var num1 = 1.;  // Нет дробной части - интерпретируется как целое число 1
var num2 = 9.0  // В дробной части 0 - интерпретируется как целое число 9

Числа можно указывать также в виде шестнадцатеричных или восьмеричных значений. Шестнадцатеричное значение начинается с последовательности символов "0x" или "0X", за которой следует само значение. Буквы шестнадцатеричного числа могут быть и строчными, и прописными:

Код: Выделить всё Развернуть
alert(0Xff);  // Число 255
alert(0xFF);  // Число 255

В восьмеричном литерале первой цифрой является нуль (0), за которым следует последовательность восьмеричных цифр (от 0 до 7). Если в литерале обнаруживается цифра не из этого диапазона, начальный нуль игнорируется и число интерпретируется как десятичное:

Код: Выделить всё Развернуть
alert(070);  // 56
alert(079);  // 79

Специальные числовые значения

В JavaScript имеются предопределённые глобальные переменные Infinity и NaN.
Переменная Infinity хранит специальное значение обозначающее бесконечность - Infinity, переменная NaN также хранит специальное значение NaN (NaN сокращение от англ. Not a Number - не число). Эти переменные доступны только для чтения.

Значение Infinity можно получить:

  • В результате деления числа на 0.
  • Если результат арифметической операции окажется больше самого большого или меньше самого маленького допустимого значения.
Код: Выделить всё Развернуть
alert(123 / 0);     // Infinity
alert(-12345 / 0);  // -Infinity
alert(1e500);       // Infinity
alert(1 - 1e500);   // -Infinity

Если вычисление возвращает одну из бесконечностей, это значение не может использоваться ни в каких дальнейших вычислениях, потому что Infinity не имеет числового представления.

Значение NaN используется для обозначения математической ошибки, она возникает в том случае, если математическая операция не может быть совершена, например:

Код: Выделить всё Развернуть
var a = 10, b = "текст";
 
document.write(a - b);  // математическая операция не с числовым аргументом
document.write(0 / 0);  // деление нуля на нуль

Значение NaN обладает одной особенностью: оно не равно никакому значению, в том числе и другому NaN.
Это значит, что нельзя использовать проверку x == NaN, чтобы определить, является ли значение переменной x значением NaN. Вместо этого следует выполнить проверку x != x.
Эта проверка вернёт true тогда и только тогда, когда x имеет значение NaN.
Аналогичную проверку можно выполнить с помощью функции isNaN(). Она возвращает true, если аргумент имеет значение NaN или если аргумент является нечисловым значением (только таким, которое не может быть преобразовано в число).

Код: Выделить всё Развернуть
var x = NaN;
 
alert(x != x);        // true
alert(isNaN(x));      // true
alert(isNaN("10"));   // false - может быть преобразовано в число 10
alert(isNaN("blue")); // true - не может быть преобразовано в число
alert(isNaN(true));   // false - может быть преобразовано в число 1

Помимо этого, любая арифметическая операция с NaN (например, NaN / 10) всегда возвращает NaN.

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

Код: Выделить всё Развернуть
alert(3 / 0);   // => Infinity
alert(3 / -0);  // => -Infinity

Ошибки округления вещественных чисел

Двоичное представление вещественных чисел неспособно обеспечить точное представление таких простых чисел как 0.1.
Двоичное представление вещественных чисел в JavaScript определяется согласно стандарту IEEE-754, в этом стандарте уделено особое внимание двоичной арифметике чисел с плавающей точкой.

Точность представления вещественных чисел в JavaScript достаточно высока и позволяет обеспечить очень близкое представление вещественного числа. Но тот факт, что вещественное число не может быть представлено точно, может приводить к проблемам. Посмотрим на следующий пример:

Код: Выделить всё Развернуть
var x = 0.3 - 0.2;
var y = 0.2 - 0.1;
 
document.write(x == y);    // false
document.write(x == 0.1);  // false
document.write(y == 0.1);  // true

Из-за ошибок округления разность между числами 0,3 и 0,2 оказалась не равной разности между числами 0,2 и 0,1. Важно понимать, что эта проблема не является чем-то характерным для JavaScript она проявляется во всех языках программирования, где используется двоичное представление вещественных чисел. Стоит обратить внимание, что значения x и y в примере выше очень близки друг к другу и к истинному значению. Точность округления вполне приемлема для большинства применений: проблема возникает лишь при попытках проверить значения на равенство.

Строки

Значениями типа String являются текстовые строки. В JavaScript строка - это неизменяемая, упорядоченная последовательность 16-битных значений, каждое из которых представляет символ Unicode.
Строки могут состоять из нуля и более символов.
Символы включают в себя буквы, цифры, знаки пунктуации, специальные символы и пробелы. Строки должны быть заключены в двойные или одинарные кавычки (апострофы):

Код: Выделить всё Развернуть
var myColor = "red";
var myColor = 'red';

Строки заключённые в двойные кавычки могут содержать символы одиночных кавычек и наоборот.

Код: Выделить всё Развернуть
"одинарные 'кавычки' внутри двойных"
'здесь "наоборот" '

Для того, чтобы в строке, заключённой в двойные кавычки, можно было использовать двойные кавычки, нужно их экранировать с помощью обратного слэша (\), тоже самое касается и строки заключённой в одиночные кавычки:

Код: Выделить всё Развернуть
document.write("внутри используются \"двойные\" кавычки");
document.write('внутри используются \'одиночные\' кавычки');

Большие строковые литералы в коде можно разбивать на несколько строк, заканчивая каждую строку, кроме последней символом обратного слэша.

Код: Выделить всё Развернуть
"это одна \
длинная \
строка"

Для представления символов Unicode в JavaScript используется кодировка UTF-16.
Большинство наиболее часто используемых символов Unicode имеют кодовые пункты, умещающиеся в 16 бит, и могут быть представлены единственным элементом строки.
Символы, кодовые пункты которых не умещаются в 16 бит, кодируются в соответствии с правилами кодировки UTF-16 как последовательности из двух 16-битных значений.
Это означает, что строка, имеющая длину, равную 2 (два 16-битных значения), может представлять единственный символ:

Код: Выделить всё Развернуть
var p = "π";  // состоит из одного 16-битного значения
var e = "e";  // состоит из двух 16-битных значений
 
document.write(p.length);
document.write("<br>" + e.length);

Длина строки - это количество 16-битных значений, содержащихся в ней. Нумерация символов в строках (и элементов в массивах) начинается с нуля, т. е. первое 16-битное значение находится под индексом 0, второе - под индексом 1 и т. д. К отдельным символам строки можно обращаться с помощью индексов, заключённых в квадратные скобки:

Код: Выделить всё Развернуть
var msg = "hello";
document.write(msg[1]);  // => "e"

Для определения длины строки (количества 16-битных значений), используется свойство строки length:

Код: Выделить всё Развернуть
var msg = "hello";
document.write(msg.length);

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

Код: Выделить всё Развернуть
var str = "hello";
   
document.write(str.toUpperCase());
document.write("<br>" + str);

Чтобы изменить строковое значение переменной, придётся заменить явно старое значение на новое:

Код: Выделить всё Развернуть
var str = "Строка";
alert(str);               // "Строка"
str = str.toUpperCase();
alert(str);               // "СТРОКА"

Конкатенация

Конкатенация - это объединение двух или более строк в одну большую. Объединение происходит с помощью оператора + (плюс). При конкатенации каждая последующая строка добавляется в конец предыдущей:

Код: Выделить всё Развернуть
var str1 = "Hello ";
var str2 = "World!";
 
document.write(str1 + str2 + "<br>"); // "Hello World!"
document.write(str1 + "World!");

Значение любого типа, которое объединяется со строкой, будет неявно (автоматически) преобразовано в строку и далее будет произведена конкатенация.

Код: Выделить всё Развернуть
var str1 = "Hello ";
 
alert(str1 + 1);     // "Hello 1"
alert(true + str1);  // "trueHello"
alert(str1 + NaN);   // "Hello NaN"

Логические (булевы) значения

Тип Boolean имеет только два допустимых значения. Эти два значения являются ключевыми словами true (истина) и false (ложь). Логическое значение говорит об истинности или ложности чего-то. Присвоить логические значения переменным можно следующим образом:

Код: Выделить всё Развернуть
var found = true;
var lost = false;

Обычно булевы значения представляют собой результат операций сравнения, выполняемых в сценарии, например:

Код: Выделить всё Развернуть
x == 7

Данное выражение проверяет, равно ли значение переменной x числу 7. Если да, результатом этого сравнения будет булево значение true. Если значение переменной x не равно 7, результатом сравнения будет - false.

Булевы значения обычно используются в управляющих конструкциях. Например, инструкция if/else выполняет одно действие, если булево значение равно true, и другое действие, если false.

Код: Выделить всё Развернуть
var x = 7;
if(x == 7)
  alert("Значение переменной x равно 7");
else
  alert("Значение переменной x не равно 7");

Булевы значения получаются не только в результатах сравнения - любое значение в JavaScript может быть преобразовано в булево значение.
Следующие значения в результате преобразования дают значение false:

  • undefined
  • null
  • 0
  • -0
  • NaN
  • "" - пустая строка

Все остальные значения при преобразовании дают в результате значение true.
Значение false и шесть значений, которые при преобразовании приводятся к этому значению, обычно называют ложными значениями, а все остальные - истинными. В любом контексте, когда интерпретатор JavaScript ожидает получить булево значение, ложные значения интерпретируются как false, а истинные значения - как true:

Код: Выделить всё Развернуть
var x = 7;
if(x)
  alert("Значение переменной x преобразовано в true");
else
  alert("Hello!");
 
var y = 0;
if(y)
  alert("Hello!");
else
  alert("Значение переменной y преобразовано в false");

Null и Undefined

Тип Null имеет всего одно значение - null.
Значение null является специальным пустым объектом. Ключевое слово null в JavaScript имеет специальное назначение - оно используется для обозначения отсутствия ожидаемого значения. Например оно используется для инициализации переменной, которой впоследствии будет присвоен объект.

Код: Выделить всё Развернуть
if (car != null) {
  // Сделать что-нибудь с переменной car
}

Тип Undefined имеет всего одно значение - undefined.
Значение undefined указывает на изначальное отсутствие какого-либо значения.
Получить значение undefined можно следующим образом:

  • При обращении к переменной, которая была объявлена, но не была инициализирована.
  • При обращении к несуществующему свойству объекта.
  • При обращении к несуществующему элементу массива.
  • При обращении к параметрам функции, которым не были переданы аргументы при вызове функции.
  • Возвращается функциями, которые не имеют возвращаемого значения.
  • Возвращается оператором typeof при проверке типа несуществующей переменной.
Код: Выделить всё Развернуть
var bar;
document.write(bar);

Идентификатор undefined является именем предопределённой глобальной переменной (а не ключевым словом, как null), которая инициализирована значением undefined.
Переменная undefined доступна только для чтения.

Ни null, ни undefined не имеют каких-либо свойств или методов.
Попытка использовать . или [], чтобы обратиться к свойству или методу этих значений, вызывает ошибку TypeError, которую можно увидеть в консоли браузера.

При сравнении значений null и undefined, оператор равенства (==) считает их равными, а оператор строгого равенства (===) - разными.

На практике, значение undefined можно рассматривать как признак неожиданного или ошибочного отсутствия какого-либо значения, а null - как признак обычного или вполне ожидаемого отсутствия значения.

Присваивание по значению и по ссылке

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

Код: Выделить всё Развернуть
var color1 = "red";
var color2 = color1;

Здесь переменной color1 присваивается значение "red".
Затем переменной color2 присваивается значение переменной color1.
Несмотря на то, что переменные color1 и color2 имеют одинаковое значение, каждая из них содержит собственную копию значения, поэтому изменение значения одной из них не повлияет на другую.

Код: Выделить всё Развернуть
var color1 = "red";
var color2 = color1;
 
document.write(color1);          // "red"
document.write("<br>" + color2); // "red"
 
color1 = "blue";
 
document.write("<br>" + color1); // "blue"
document.write("<br>" + color2); // "red"

Ссылочные типы присваиваются по ссылке, а не по значению.
Операция присваивания объекта (также массива или функции) фактически присваивает ссылку, т. е. она не создаёт новую копию объекта, а присваивает ссылку на уже существующий объект:

var obj1 = {};
var obj2 = obj1; // Теперь ссылается на тот же объект в памяти, что и obj1

Так как две переменные содержат ссылку на один и тот же объект, изменения объекта сделанные в одной из переменных повлияют на другую.

Если в программе потребуется создать копию объекта, необходимо будет явно скопировать свойства и методы от одного объекта другому.

Также, если потребуется сравнивать два отдельных объекта, необходимо будет сравнивать их свойства и методы.
Объекты обёртки

В JavaScript есть предопределённый набор свойств и методов для работы со строками, числами и логическими значениями, они используются точно также, как свойства и методы в работе с обычными объектами. Это реализовано для того, чтобы с примитивными значениями было также легко работать, как и с обычными объектами, к примеру, если нам нужно преобразовать все символы строки в нижний регистр мы воспользуемся методом toLowerCase():

Код: Выделить всё Развернуть
var str = "СиМвоЛы СтРоКи ЗаПиСаНы с РаЗнЫм РеГиСтРоМ.";
str = str.toLowerCase();
document.write(str);

Однако в JavaScript примитивные значения не являются объектами, так почему же они обладают свойствами и методами?
Всякий раз, когда в программе предпринимается попытка обратиться к свойству или методу примитивного значения, интерпретатор JavaScript на время преобразует примитивное значение в объект.
Этот объект используется интерпретатором для доступа к нужному свойству или методу. После обращения к методу или свойству вновь созданный объект уничтожается. Временные объекты, которые создаются при обращении к свойству или методу строки, числа или логического значения, называются "объекты обёртки".

Объекты обёртки создаются только для значений, которые относятся к типам String, Number и Boolean.
Значения null и undefined не имеют объектов обёрток: любая попытка обратиться к свойствам этих значений будет вызывать ошибку TypeError:

Код: Выделить всё Развернуть
var str = 'машина';
alert(str.charAt(0)); // Вызов метода для получения первого символа строки

Ниже показана примерная реализация того, что делает интерпретатор JavaScript в момент обращения к методу charAt():

Код: Выделить всё Развернуть
temp = new String(str);       // Создаётся временный объект
alert(temp.charAt(0));        // Вызов нужного метода
delete temp;                  // Удаление временного объекта

Как мы видим, интерпретатор JavaScript автоматически создаёт объект типа String, у которого он затем вызывает метод charAt(). Созданный объект используется всего один раз перед тем как будет уничтожен сборщиком мусора.

Если попытаться установить значение свойству, эта попытка будет просто проигнорирована: изменение затронет временный объект только в момент его создания и не будет сохранено, так как сразу после этого временный уничтожается:

Код: Выделить всё Развернуть
var str = "fdsf";
alert(str.len);  // undefined, так как такого свойства нет
 
str.len = 5;     // установить свойство со значением. Сразу после этого объект уничтожается
alert(str.len);  // undefined, так как объект уже был уничтожен и такого свойства нет

Объекты обёртки можно рассматривать просто как особенность реализации в JavaScript и вообще не думать о них.

Изменяемые и неизменяемые типы

Между простыми типами и ссылочными в языке JavaScript имеются фундаментальные отличия.
Простые значения являются неизменяемыми, т. е. простое значение невозможно изменить. Например, все строковые методы, которые, на первый взгляд возвращают изменённую строку, на самом деле возвращают новое строковое значение:

Код: Выделить всё Развернуть
var str = "привет";
str.toUpperCase(); // возвращает "ПРИВЕТ", но значение str не изменилось
document.write(str);

Ссылочные значения (т. е. объекты, массивы и функции) отличаются от простых, они являются изменяемыми значениями, т. е. их можно изменять:

Код: Выделить всё Развернуть
var o = { x: 1 }; // Начальное значение объекта
o.x = 2;          // Изменяем объект, изменив значение свойства
o.y = 3;          // Изменяем объект, добавив новое свойство
javascript, типы, string, number, function, infinity, nan, isnan, typeerror, array, object, литералы, boolean, последовательности, булевы значения, null, undefined, строки



Похожие темыКомментарии ПросмотрыПоследнее сообщение
0648JavaScript. Логические операторы и ...
Сообщение от: Admin
0634Колонки одинаковой высоты - лучшее ...
Сообщение от: Admin
21406Re: Закладки пользователя для сайта...
Сообщение от: Admin
0560Замена прямых кавычек на “ёлочки”. ...
Сообщение от: Admin
0847Javascript Math.random(), аналог PH...
Сообщение от: Admin