Типы данных помогают построить классификацию данных в языках программирования. Например, число и строка символов представляют собой разные типы данных, которые JavaScript будет обрабатывать по-разному.
Это важно, потому что каждый тип данных может принимать определенные значения и выполнять определенные действия. Чтобы иметь возможность выполнять операции с переменными в JavaScript, важно понимать тип данных каждой заданной переменной.
Данный мануал ознакомит вас с типами данных JavaScript.
Примечание : Информация в руководстве не является исчерпывающей, но здесь вы сможете ознакомиться с основными опциями JavaScript.
Динамическая типизацияJavaScript является динамическим языком. Это значит, что проверка типа данных осуществляется во время запуска, а не компиляции.
В динамических языках одноименные переменные можно использовать для хранения разных типов данных.
Например, переменная t, определяемая ключевым словом var, может хранить разные типы данных; также ее можно инициализировать, но оставить неопределенной:
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
Все переменные t содержат разные типы данных JavaScript. В JavaScript не нужно явно указывать тип данных переменной до ее использования.
ЧислаJavaScript имеет единый числовой тип данных, не разделяя целые числа и числа с плавающей запятой. Потому числа в JavaScript можно писать с десятичными знаками или без них:
var num1 = 93;
var num2 = 93.00;
В вышеприведенном примере обе переменные содержат числа, вне зависимости от того, есть в нем запятая или нет.
Экспоненциальная нотация в JavaScript позволяет сокращать очень большие или маленькие числа:
var num3 = 987e8; // 98700000000
var num4 = 987e-8; // 0.00000987
В JavaScript числа считаются точными до 15 цифр. Это означает, что после достижения 16-й цифры числа будут округлены:
var num5 = 999999999999999; // remains as 999999999999999
var num6 = 9999999999999999; // rounded up to 10000000000000000
Также числа в JavaScript имеют три символических значения:
Infinity — числовое значение, которое представляет собой положительное число, приближающееся к бесконечности.
Infinity — числовое значение, которое представляет собой отрицательное число, приближающееся к бесконечности.
NaN – Not-а-Number, особое состояние числа с плавающей запятой.
Infinity и -Infinity возвращаются при подсчете числа за пределами максимально возможного числа, доступного в JavaScript. Они также появляются при подсчете неопределенных значений, например, при делении на ноль:
var num7 = 5 / 0; // Infinity
var num8 = -5 / 0; // -Infinity
Технически Infinity возвращается, если число превышает 1.797693134862315E+308, это верхний предел в JavaScript.
Аналогично, -Infinity будет отображаться, когда число выходит за нижний предел, -1.797693134862316E+308.
Число Infinity также можно использовать в циклах:
while (num9 != Infinity) {
// Code here will execute through num9 = Infinity
}
Для неопределенных чисел выводится NaN. Если вы попытаетесь выполнить математическую операцию над числом и нечисловым значением, вы получите NaN. Например:
var x = 20 / "Shark"; // x will be NaN
Поскольку 20 нельзя разделить на строку Shark, значение переменной х будет NaN.
Однако если строку можно оценить как числовое значение, JavaScript выполнит математическое выражение:
var y = 20 / "5"; // y will be 4
Поскольку JavaScript может рассмотреть 5 как числовое значение, 5 будет работать с математическим оператором деления.
Если одной переменной в выражении присвоено значение NaN, в результате будет NaN, даже если второй операнд является числом.
var a = NaN;
var b = 37;
var c = a + b; // c will be NaN
Итак, в JavaScript существует только один числовой тип данных. В JavaScript не нужно разделять числа на целые и числа с плавающей запятой, поскольку JavaScript является динамическим языком.
СтрокиСтрока – это последовательность из одного или нескольких символов (букв, цифр и других символов). Строки представляют собой текстовые данные.
В JavaScript строки бывают как в одиночных, так и в двойных кавычках. Чтобы создать строку, нужно заключить последовательность символов в кавычки:
var singleQuotes = "This is a string in single quotes.";
var doubleQuotes = "This is a string in double quotes.";
Вы можете использовать одинарные или двойные кавычки, но в коде одной программы нужно последовательно использовать один вид кавычек.
Программа «Hello, World!» демонстрирует, как используются строки в компьютерном программировании. По сути, в данном примере строка – это последовательность символов, которая составляет фразу «Hello, World!» в alert().
function helloFunction() {
alert("Hello, World!");
}
Click me
Запустив код и нажав кнопку Click me, вы увидите всплывающее окно с текстом:
Как и другие типы данных, строки можно хранить в переменных.
var hw = "Hello, World!";
Затем можно отобразить строку, вызвав переменную:
...
var hw = "Hello, World!";
function helloFunction() {
alert(hw);
}
...
Hello, World!
Строки позволяют передавать информацию пользователю и обратно в программу.
Логический тип данныхЛогический (или Булевый) тип данных состоит из двух значений – true и false.
Этот тип используется для представления значений истинности, связанных с логикой и алгоритмах в информатике.
Примечание : Этот тип данных назван в честь математика Джорджа Буля.
Многие операции в математике дают результаты, которые можно оценить как истинные или ложные:
Больше чем:
Меньше чем:
Как и другие типы, логический тип данных можно хранить в переменных.
var myBool = 5 > 8; // false
Поскольку 5 не больше 8, переменная myBool будет иметь значение false.
Разрабатывая код в JavaScript, вы познакомитесь с тем, как работают логические данные и как различные функции и операции, оценивающие истинность, могут изменить ход программы.
МассивыМассив может содержать несколько значений в пределах одной переменной. Это означает, что вы можете сохранить список значений внутри массива и итерировать их.
Каждое значение внутри массива называется элементом. Вы можете обратиться к элементам массива с помощью индекса.
Массивы определяются квадратными скобками .
Массив строк выглядит так:
var fish = ["shark", "cuttlefish", "clownfish", "eel"];
Вызывая переменную fish, вы получите результат:
["shark", "cuttlefish", "clownfish", "eel"]
Массивы – очень гибкий тип данных, поскольку они изменяемы: вы можете добавлять, удалять и изменять значения элементов.
ОбъектыОбъект в JavaScript состоит из пар «ключ: значение».
Синтаксис объекта состоит из пар «ключ: значение». Объект выделяется фигурными скобками с обеих сторон ({}).
Пары в объекте разделяются пробелами:
var sammy = {firstName:"Wally", lastName:"Shark", color:"blue", location:"ocean"};
Также объект можно записать в несколько строк (особенно это применимо к большим объектам).
var wally = {
firstName: "Wally",
lastName: "Shark",
color: "blue",
location: "Ocean"
};
Каждая создаваемая вами программа наверняка будет содержать несколько типов данных, однако операции обычно выполняются для одного типа данных. математические вычисления применяются к числам, а нарезка – к строкам.
Используя операторы, которые работают со всеми типами данных (например, оператор + может складывать числа или выполнять конкатенацию строк), вы можете получить неожиданный результат.
Если вы создадите переменную для конкатенации, JavaScript интерпретирует каждый элемент как строку.
var o = "Ocean" + 5 + 3;
Вызвав переменную о, вы получите такой результат:
Однако если в строке сначала будут идти числа, а затем строка, оператор + выполнит сложение, а затем конкатенацию:
var p = 5 + 3 + "Ocean";
8Ocean
Из-за непредсказуемости результатов выполнять операции и методы удобнее в одном типе данных. Однако JavaScript не возвращает ошибок при смешивании типов данных, как это делают некоторые другие языки программирования.
ЗаключениеТеперь вы знакомы с типами данных JavaScript. Каждый из перечисленных здесь типов важен при написании программ на языке JavaScript.
Tags:Почти в любом языке программировании существуют различные типы переменных и JavaScript тут сюрпризов не преподносит. Как правило, это стандартный набор типов: целый (integer ), вещественный (double ), строковый (string ), булевский (boolean ) и массив (array ). Давайте разберём каждый тип переменной в JavaScript подробнее.
Во-первых, сразу заметим, что переменная любого типа начинается с ключевого слова "var ", и лишь значение переменной определяет тип переменной. Более того, тип переменной в JavaScript может быть изменён в любой точке программы.
Начнём с самого простого - целого типа, знакомого нам по предыдущей статье. Целый тип - это обычные целое число, например, -100, -34, 0, 15, 259 и так далее. Соответственно, целый тип создаётся с помощью присвоения переменной целого значения, например, так:
Var number = -323;
Следующий тип переменной - это вещественный тип, или, как принято его называть, double . Тип double - это вещественные числа, то есть абсолютно любые числа, кроме мнимых (если не знаете, что такое мнимые числа, то не обращайте на это внимание). Например, -3.4, -1.032, 35.599212, 0.0001. Так же как и с другими типами, для создания вещественной переменной необходимо инициализировать переменную одним из подобных значений. Вот пример:
Var number = 32.3291;
Обратите внимание, что целая часть от дробной отделяется не "запятой " (как принято у нас), а "точкой ".
Следующий тип переменной - это строковый. Строковый тип в JavaScript используется очень часто, не реже, чем другие, если не больше. Строковый тип - это какая-либо строка. Для примера такая: "string", "732", "My name"s Michael". Обратите внимание, что строка задаётся в кавычках. В частности, строка "732" отличается от числа 732. Создаётся строка аналогично другим типам в JavaScript :
Var str = "some string";
Ещё один тип переменной - это булевский. Тип этой переменной может содержать одно из двух значений: true (истина) или false (ложь). Переменная используется в условных операторах, о которых мы поговорим позднее. А пока пример создания булевской переменной:
Var bool = true;
И последний тип - это массив. Самый сложный тип из всех, однако, очень важный и присутствующий почти во всех языках программирования. Это тип, который содержит в себе несколько различных переменных, причём, возможно, что даже разных типов. Создаётся массив в JavaScript таким образом:
Var array = new Array(3, 7, 12, true, 4.5, "some string", true);
В примере создаётся массив из 7-ми значений, которые могут быть считаны или перезаписаны. Встаёт вопрос: как обратиться к элементу массива. Очень просто! Синтаксис обращения к элементу массива следующий: название_ массива[номер_элемента]. Обратите внимание, что нумерация в массиве начинается с "0 ". Поэтому элемент со значением "3 " - это элемент под номером "0 ". Для примера покажу, как можно вывести элемент массива в окно браузера и перезаписать его.
Document.write(array);
array = array + 1;
document.write(array);
Советую Вам выполнить этот скрипт, чтобы окончательно разобраться в массивах, ведь без этого типа переменной немыслимо программирование, даже на JavaScript .
Это все типы переменных в JavaScript .
JavaScript был создан программистом Brendan Eich из Netscape и представлен в декабре 1995 года под названием LiveScript. Довольно быстро он был переименован в JavaScript, хотя официальным названием JavaScript является ECMAScript. ECMAScript разрабатывается и поддерживается Международной организацией ECMA (Европейская ассоциация производителей компьютеров).
Что такое JavaScript?
1) JavaScript — язык сценариев, или скриптов. Скрипт представляет собой программный код — набор инструкций, который не требует предварительной обработки (например, компиляции) перед запуском. Код JavaScript интерпретируется движком браузера во время загрузки веб-страницы. Интерпретатор браузера выполняет построчный анализ, обработку и выполнение исходной программы или запроса.
2) JavaScript — объектно-ориентированный язык с прототипным наследованием. Он поддерживает несколько встроенных объектов, а также позволяет создавать или удалять свои собственные (пользовательские) объекты. Объекты могут наследовать свойства непосредственно друг от друга, образуя цепочку объект-прототип.
JavaScript на веб-страницах 1. Подключение сценариев к html-документуСценарии JavaScript бывают встроенные , т.е. их содержимое является частью документа, и внешние , хранящиеся в отдельном файле с расширением.js . Сценарии можно внедрить в html-документ следующими способами:
или тело страницы.
Этот способ обычно применяется для сценариев большого размера или сценариев, многократно используемых на разных веб-страницах.
В виде обработчика события
.
Каждый html-элемент имеет JavaScript-события, которые срабатывают в определенный момент. Нужно добавить необходимое событие в html-элемент как атрибут, а в качестве значения этого атрибута указать требуемую функцию. Функция, вызываемая в ответ на срабатывание события, является обработчиком события
. В результате срабатывания события исполнится связанный с ним код. Этот способ применяется в основном для коротких сценариев, например, можно установить смену цвета фона при нажатии на кнопку:
var colorArray = ["#5A9C6E", "#A8BF5A", "#FAC46E", "#FAD5BB", "#F2FEFF"]; // создаем массив с цветами фона var i = 0; function changeColor(){ document.body.style.background = colorArray[i]; i++; if(i > colorArray.length - 1){ i = 0; } } Change background
Внутрь элемента
.
Элемент может вставляться в любое место документа. Внутри тега располагается код, который выполняется сразу после прочтения браузером, или содержит описание функции, которая выполняется в момент ее вызова. Описание функции можно располагать в любом месте, главное, чтобы к моменту ее вызова код функции уже был загружен.
Обычно код JavaScript размещается в заголовке документа (элемент ) или после открывающего тега . Если скрипт используется после загрузки страницы, например, код счетчика, то его лучше разместить в конце документа:
document.write("Введите свое имя");
2. Типы данных и переменные в JavaScriptКомпьютеры обрабатывают информацию — данные. Данные могут быть представлены в различных формах или типах. Большая часть функциональности JavaScript реализуется за счет простого набора объектов и типов данных. Функциональные возможности, связанные со строками, числами и логикой, базируются на строковых, числовых и логических типах данных. Другая функциональная возможность, включающая регулярные выражения, даты и математические операции, осуществляется с помощью объектов RegExp, Date и Math.
Литералы в JavaScript представляют собой особый класс типа данных, фиксированные значения одного из трех типов данных — строкового, числового или логического:
"это строка" 3.14 true alert("Hellow"); // "Hellow" - это литерал var myVariable = 15; // 15 - это литерал
Примитивный тип данных является экземпляром определенного типа данных, таких как строковый, числовой, логический, null и undefined .
2.1. Переменные в JavaScriptДанные, обрабатываемые сценарием JavaScript, являются переменными . Переменные представляют собой именованные контейнеры, хранящие данные (значения) в памяти компьютера, которые могут изменяться в процессе выполнения программы. Переменные имеют имя , тип и значение .
Имя переменной, или идентификатор , может включать только буквы a-z , A-Z , цифры 0-9 (цифра не может быть первой в имени переменной), символ $ (может быть только первым символом в имени переменной или функции) и символ подчеркивания _ , наличие пробелов не допускается. Длина имени переменной не ограничена. Можно, но не рекомендуется записывать имена переменных буквами русского алфавита, для этого они должны быть записаны в Unicode.
В качестве имени переменной нельзя использовать ключевые слова JavaScript. Имена переменных в JavaScript чувствительные к регистру, что означает, что переменная var message; и var Message; — разные переменные.
Переменная создается (объявляется) с помощью ключевого слова var , за которым следует имя переменной, например, var message; . Объявлять переменную необходимо перед ее использованием.
Переменная инициализируется значением с помощью операции присваивания = , например, var message="Hellow"; , т.е. создается переменная message и в ней сохраняется ее первоначальное значение "Hellow" . Переменную можно объявлять без значения, в этом случае ей присваивается значение по умолчанию undefined . Значение переменной может изменяться во время исполнения скрипта. Разные переменные можно объявлять в одной строке, разделив их запятой:
Var message="Hellow", number_msg = 6, time_msg = 50;
2.2. Типы данных переменныхJavaScript является нетипизированным языком, тип данных для конкретной переменной при ее объявлении указывать не нужно. Тип данных переменной зависит от значений, которые она принимает. Тип переменной может изменяться в процессе совершения операций с данными (динамическое приведение типов ). Преобразование типов выполняется автоматически в зависимости от того, в каком контексте они используются. Например, в выражениях, включающих числовые и строковые значения с оператором + , JavaScript преобразует числовые значения в строковые:
Var message = 10 + " дней до отпуска"; // вернет "10 дней до отпуска"
Получить тип данных, который имеет переменная, можно с помощью оператора typeof . Этот оператор возвращает строку, которая идентифицирует соответствующий тип.
Typeof 35; // вернет "number" typeof "text"; // вернет "string" typeof true; // вернет "boolean" typeof ; // вернет "object" typeof undefined; // вернет "undefined" typeof null; // вернет "object"
Все типы данных в JavaScript делятся на две группы — простые типы данных (primitive data types) и составные типы данных (composite data types) .
К простым типам данных относят строковый, числовой, логический, null и underfined .
2.2.1. Строковый тип (string)Используется для хранения строки символов, заключенных в двойные или одинарные кавычки. Пустой набор символов, заключенный в одинарные или двойные кавычки, является пустой строкой. Число, заключенное в кавычки, также является строкой.
Var money = ""; // пустая строка, ноль символов var work = "test"; var day = "Sunday"; var x = "150";
В строку в двойных кавычках можно включить одиночную кавычку и наоборот. Кавычка того же типа отключается с помощью символа обратного слэша \ (так называемая escape-последовательность ):
Document.writeln("\"Доброе утро, Иван Иваныч!\"\n"); // выведет на экран "Доброе утро, Иван Иваныч!"
Строки можно сравнивать, а также объединять с помощью операции конкатенации + . Благодаря автоматическому приведению типов можно объединять числа и строки. Строки являются постоянными, после того, как строка создана, она не может быть изменена, но может быть создана новая строка путем объединения других строк.
2.2.2. Числовой тип (number)Используется для числовых значений. Числа в языке JavaScript бывают двух типов: целые числа (integer) и числа с плавающей точкой (floating-point number) . Целочисленные величины могут быть положительными, например 1 , 2 , и отрицательными, например –1 , –2 , или равными нулю. 1 и 1.0 — одно и то же значение. Большинство чисел в JavaScript записываются в десятичной системе счисления, также может использоваться восьмеричная и шестнадцатеричная системы.
В десятичной системе значения числовых переменных задаются с использованием арабских цифр 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 .
В восьмеричном формате числа представляет собой последовательность, содержащая цифры от 0 до 7 и начинающаяся с префикса 0 .
Для шестнадцатеричного формата добавляется префикс 0x (0X), за которым следует последовательность из цифр от 0 до 9 или букв от a (A) до f (F), соответствующие значениям от 10 до 15 .
Var a = 120; // целое десятичное числовое значение var b = 012; // восьмеричный формат var c = 0xfff; // шестнадцатеричный формат var d = 0xACFE12; // шестнадцатеричный формат
Числа с плавающей точкой представляют собой числа с дробной десятичной частью, либо это числа, выраженные в экспоненциальном виде. Экспоненциальная запись чисел предполагает следующий вид: число с дробной десятичной частью, за ним следует буква e , которая может быть указана как в верхнем, так и в нижнем регистре, далее — необязательный знак + или - и целая экспонента.
Var a = 6.24; // вещественное число var b = 1.234E+2; // вещественное число, эквивалентно 1.234 Х 10² var c = 6.1e-2; // вещественное число, эквивалентно 6.1 Х 10‾²
2.2.3. Логический тип (boolean)Данный тип имеет два значения, true (истина), false (ложь). Используется для сравнения и проверки условий.
Var answer = confirm("Вам понравилась эта статья?\n Нажмите ОК. Если нет, то нажмите Cancel."); if (answer == true) { alert("Спасибо!"); }
Также существуют специальные типы простых значений:
нулевой тип
— данный тип имеет одно значение null , которое используется для представления несуществующих объектов.
неопределенный тип — тип переменной underfined означает отсутствие первоначального значения переменной, а также несуществующее свойство объекта.
Составные типы данных состоят из более чем одного значения. К ним относятся объекты и особые типы объектов — массивы и функции. Объекты содержат свойства и методы, массивы представляют собой индексированный набор элементов, а функции состоят из коллекции инструкций.
2.3. Глобальные и локальные переменныеПеременные по области видимости делятся на глобальные и локальные . Область видимости представляет собой часть сценария, в пределах которой имя переменной связано с этой переменной и возвращает ее значение. Переменные, объявленные внутри тела функции, называются локальными , их можно использовать только в этой функции. Локальные переменные создаются и уничтожаются вместе с соответствующей функцией.
Переменные, объявленные внутри элемента , или внутри функции, но без использования ключевого слова var , называются глобальными . Доступ к ним может осуществляться на протяжении всего времени, пока страница загружена в браузере. Такие переменные могут использоваться всеми функциями, позволяя им обмениваться данными.
Глобальные переменные попадают в глобальное пространство имен , которое является местом взаимодействия отдельных компонентов программы. Не рекомендуется объявлять переменные таким способом, так как аналогичные имена переменных уже могут использоваться любым другим кодом, вызывая сбой в работе скрипта.
Глобальное пространство в JavaScript представляется глобальным объектом window . Добавление или изменение глобальных переменных автоматически обновляет глобальный объект. В свою очередь, обновление глобального объекта автоматически приводит к обновлению глобального пространства имен.
Если глобальная и локальная переменная имеют одинаковые имена, то локальная переменная будет иметь преимущество перед глобальной.
Локальные переменные, объявленные внутри функции в разных блоках кода, имеют одинаковые области видимости. Тем не менее, рекомендуется помещать объявления всех переменных в начале функции.
Переменная – это именованный участок памяти, в который можно как сохранить некоторую информацию, так и получить её из неё.
Объявление (создание) переменных осуществляется с помощью ключевого слова var .
// message - имя переменной var message;
При создании переменной ей сразу же можно присвоить значение.
Присвоение переменной значения осуществляется с помощью оператора «=».
// например, создадим переменную email и присвоим ей строку "[email protected]" var email = "[email protected]"; // установим переменной email новое значение email = "[email protected]";
Для того чтобы получить значение переменной достаточно просто обратиться к ней по имени.
// например, выведем в консоль браузера значение переменной email: console.log(email);
Для того чтобы объявить не одну, а несколько переменных с помощью одного ключевого слова var , необходимо использовать запятую.
Var price = 78.55, quantity = 10, message;
JavaScript является языком с динамической или слабой типизацией. Это означает, что при объявлении переменной ей не нужно указывать тип данных, который она может принимать. Следовательно, в переменную можно поместить сначала значение, имеющее один тип данных, а потом другой.
Var output = "успех"; // переменная имеет строковый тип данных output = 28; // эта же переменная, но уже имеющая тип данных «число» output = true; // эта же переменная, но уже хранящая булевское значение
Значение переменной можно изменять неограниченное количество раз.
// создана переменная age var age; // переменной age присвоено значения 67 age = 67; // переменной age установлено значение «Пенсионный возраст» age = "Пенсионный возраст"; // переменной age установлено число 55 age = 55;
Хорошей практикой при разработке клиентских считается использование в определённой переменной только одного типа данных, т.е. не записывать в переменную значения, имеющие различные типы данных. Чтобы понять какой тип данных стоит ожидать в переменной рекомендуется при создании переменной её сразу инициализировать определённым значением.
Имя переменной можно составлять из букв, цифр и символов $ и _. При этом первый символ переменной не должен быть цифрой. Кроме этого в качестве имени переменной нельзя использовать зарезервированные слова.
// создание двух переменных, первая переменная имеет имя phone, вторая - meassage; var phone, message;
Регистр букв в имени переменной имеет значение. Т.е., например, переменная phone и Phone - это две разные переменные.
Если строгий режим не используется, то создать переменную с первоначальным значением можно и без ключевого слова var.
Price = 250.00; // создали переменную и инициализировали её числом 250.00 percent = "20%"; // создали переменную и инициализировали её строкой «20%»
Но создавать, таким образом, переменные не рекомендуется.
Типы данныхВ JavaScript типы данных можно разделить на примитивные и объектные.
Переменные, содержащие примитивные типы данных хранят значение явно.
В JavaScript выделяют 5 примитивных типов данных:
Если одной переменной присвоить значение другой, которая содержит примитивный тип данных, то она получит собственную копию этого значения.
Var x = 77, y = x; x = 55; y; // 77
Переменные, содержащие объект, на самом деле хранят не сам объект, а ссылку на него.
Если одной переменной присвоить значение другой, которая содержит объект (ссылку на него), то она тоже получит ссылку на него. В результате этой операции две эти переменные будут содержать ссылку на один и тот же объект.
// пример 1 (с типом данных «объект») var coord1 = {x: 77, y: 100}, coord2 = coord1; coord1.x = 55; // установим свойству x объекта новое значение coord2.x; // 55, т.к. coord1 и coord2 содержат ссылку на один и тот же объект // пример 2 (с типом данных «массив») var coord1 = , coord2 = coord1; coord1 = 55; // установим элементу с 0 индексом новое значение coord2; // 55, т.к. coord1 и coord2 содержат ссылку на один и тот же объект // пример 3 (с типом данных «дата») var date1 = new Date(2018,00,01), date2 = date1; date2 = date2.setDate(date2.getDate()+7); // увеличим дату на 7 дней date1; // 07.01.2018, т.к. date1 и date2 содержат ссылку на один и тот же объект
Число (number)Числовой тип в JavaScript данных является универсальным . Он используется для представления, как целых , так и дробных чисел.
Var int = 5; // целое число var float = 5.98; // дробное число
Формат представления чисел в JavaScript осуществляется в соответствии со стандартом IEEE 754-2008.
Целые числа в JavaScript можно задавать не только в десятичной системе счисления, но и в восьмеричной (0) или шестнадцатеричной системе счисления (0x) с использованием префиксов, указанных в круглых скобках:
Var int = 010; // 8 int = 055; // 45 int = 0xFF; //255 int = 0xB8; // 184
Записывать числа возможно в экспоненциальной форме :
Var num = 2e3; // экспоненциальная запись числа 2*10^3 (2000) num = 2e-3; // экспоненциальная запись числа 2*10^-3 (0,002) num = 3.2e3; // 3200 num = 1.5e-2; // 0.015
Числовой тип данных кроме чисел содержит ещё специальные числовые значения :
Специальное значения Infinity означает очень большое положительное число, т.е. число, которое не может быть представлено в JavaScript по причине того, что оно слишком велико.
Специальные значения -Infinity означает наоборот очень большое отрицательное число, т.е. число, которое не может быть представлено JavaScript по причине того, что оно тоже слишком велико.
Пример выражений в результате вычисления которых будет возвращены специальные числовые значения :
5/0; // Infinity -5/0; // -Infinity Math.pow(10,399); // Infinity (10 в степене 399) Math.pow(10,399); // -Infinity (-10 в степене 399)
Значение NaN возвращается в результате выполнения математических операций, которые JavaScript не может вычислить.
5 - "Hi"; // NaN (от числа 5 отнять строку) 1000 / "20px"; // NaN (число поделить на строку) true * "1rem"; // NaN (логическое значение true умножить на строку)
При этом очень интересным является то, что значение NaN в JavaScript не равно ничему включая себя.
NaN == NaN; // false NaN === NaN; //false
Логический тип данных (Boolean)Boolean – примитивный тип данных, который имеет всего два значения: true (истина) и false (ложь).
Var a = true; var b = false;
Строка (String)Строка (String) – это тип данных, который используется в JavaScript для представления текста.
Строка JavaScript может состоять из 0 или большего количества символов.
В качестве формата строки в JavaScript всегда использутся кодировка Unicode.
Создание строки (литерала строки) выполняется посредством заключения текста в одинарные или двойные кавычки .
"JavaScript"; "ECMAScript";
В JavaScript нет разницы между одинарными и двойными кавычками.
Но, в некоторых случаях есть смысл использовать именно одинарные кавычки, а не двойные и наоборот.
Например, когда строка содержит двойные кавычки, её более удобно заключить в одинарные. Это избавит от необходимости экранирования в ней двойных кавычек.
""ECMAScript""; // без экранирования (с использованием одинарных кавычек) "\"ECMAScript\""; // с экранированием
Строка в JavaScript может содержать специальные символы. Например, \n (перевод строки), \t (табуляция), \r (возврат каретки) и др.
"Это предложение.\nА это тоже предложение, но оно будет начинаться с новой линии.";
Со строками можно произовдить операцию сложения (объединения) или другими словами конкатенацию. Для этого используется оператор "+". Сымысл данной операции заключается в присоединении второй строки к концу первой.
"Я люблю " + "JavaScript"; // Я люблю JavaScript
Значение "undefined"undefined - специальный примитивный тип данных, который имеет одно значение, равное undefined .
Этот тип данных имеет объявленная переменная, которой ещё не присвоено значение.
Var num; // undefined
Значение undefined также будет возвращено при обращении к несуществующему свойству объекта.
Var obj = {}; // пустой объект obj.prop; // undefined
Значение "null"null - специальный примитивный тип данных, который имеет одно значение, равное null .
null - это просто специальное значение, которое имеет смысл «ничего» или «неизвестное значение», т.е. оно явно ничего не означает.
Объект (Object)Объект – это структура данных, состоящая из пар имя-значение.
Создание объекта с помощью нотации литерала объекта осуществляется следующим образом:
{ имя_1: значение_1, имя_2: значение_2, имя_3: значение_3, ... }
Как видно, имя от значения отделяется с помощью двоеточия, а пары между собой с помощью запятой.
При этом если в качестве значения пары выступает функция, то она называется методом этого объекта. Все остальные пары, т.е. пары в которых в качестве значения не используется функция, называются свойствами объекта.
Другими словами, объект - это структура данных, состоящая из свойств и методов.
Var person = { name: "Виталий", age: 27, getAge: function () { return "Возраст: " + this.age; } }
Обращение к свойствам объекта выполняется через точку или посредством скобочной записи.
// выведем значение свойства age в консоль браузера // 1 способ (через точку) console.log(person.age); // 2 способ (с помощью скобок) console.log(person["age"]); // вызовем метод getAge; значение, которое он вернет, выведем в консоль console.log(person.getAge());
Оператор typeofОператор typeof используется для получения информации о типе данных выражения в виде строки.
Синтаксис оператора typeof (вариант без круглых скобок):
Typeof выражение
Синтаксис оператора typeof (с использованием круглых скобок):
Typeof(выражение)
Var name, age = 37, email = "[email protected]", isLicense = true, interest: null, lastExperience: { period: "June 2011 - June 2018", place: "ISACA, Moscow", position: "Web designer" }, getExperience: function() { return lastExperience.period + " ("+ lastExperience.position + " - " + lastExperience.place + ")"; }; typeof name; // "undefined" typeof age; // "number" typeof isLicense; // "boolean" typeof interest; // "object" (1) typeof lastExperience; // "object" typeof getExperience; // "function" (2) /* (1) - это ошибка, которая присутствует в языке, начиная с его первой реализации; она не была исправлена в целях сохранения совместимости и это необходимо учитывать, при написании сценариев; null - это примитивный тип данных, он не является объектом */ /* (2) - это очень удобно, что оператор typeof выделяет функции отдельно; но функция в JavaScipt - это тоже объект; в этом легко убедиться если выполнить следующую конструкцию: */ typeof getExperience.__proto__.__proto__ // "object" (прототипом функции является объект)
КонстантыС выходом ECMAScript 6 появилось возможность создавать константы. Осуществляется это с помощью ключевого слова const.
Const COLOR_RED = "#ff0000";
Константа – это переменная, значение которой защищено от изменения. Т.е. при попытке поменять значение будет брошена ошибка.
Const COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Uncaught TypeError: Assignment to constant variable.
Если, например, константа содержит объект, то он не может быть изменен, а точнее ссылка на него. Но свойства этого объекта могут быть изменены.
Const COLORS = { red: "#ff0000", green: "#00ff00", blue: "#00ff00" } COLORS = ["#ff0000","#00ff00","#00ff00"]; // Uncaught TypeError: Assignment to constant variable. COLORS.green = "#4caf50";
Programming languages all have built-in data structures, but these often differ from one language to another. This article attempts to list the built-in data structures available in JavaScript and what properties they have; these can be used to build other data structures. Wherever possible, comparisons with other languages are drawn.
Dynamic typingJavaScript is a loosely typed or a dynamic language. Variables in JavaScript are not directly associated with any particular value type, and any variable can be assigned (and re-assigned) values of all types:
Let foo = 42; // foo is now a number foo = "bar"; // foo is now a string foo = true; // foo is now a boolean
Data typesThe latest ECMAScript standard defines eight data types:
All types except objects define immutable values (values, which are incapable of being changed). For example and unlike to C, Strings are immutable. We refer to values of these types as "primitive values".
Boolean typeBoolean represents a logical entity and can have two values: true , and false . See Boolean and Boolean for more details.
Null type PropertiesIn JavaScript, objects can be seen as a collection of properties. With the object literal syntax , a limited set of properties are initialized; then properties can be added and removed. Property values can be values of any type, including other objects, which enables building complex data structures. Properties are identified using key values. A key value is either a String or a Symbol value.
There are two types of object properties which have certain attributes: The data property and the accessor property.
Data propertyAssociates a key with a value and has the following attributes:
| [] | Any JavaScript type | The value retrieved by a get access of the property. | undefined |
| [] | Boolean | If false , the property"s [] can"t be changed. | false |
| [] | Boolean | for...in loops. See also Enumerability and ownership of properties | false |
| [] | Boolean | If false , the property can"t be deleted, can"t be changed to an accessor property and attributes other than [] and [] can"t be changed. | false |
| Read-only | Boolean | Reversed state of the ES5 [] attribute. |
| DontEnum | Boolean | Reversed state of the ES5 [] attribute. |
| DontDelete | Boolean | Reversed state of the ES5 [] attribute. |
Associates a key with one or two accessor functions (get and set) to retrieve or store a value and has the following attributes:
| [] | Function object or undefined | The function is called with an empty argument list and retrieves the property value whenever a get access to the value is performed. See also get . | undefined |
| [] | Function object or undefined | The function is called with an argument that contains the assigned value and is executed whenever a specified property is attempted to be changed. See also set . | undefined |
| [] | Boolean | If true , the property will be enumerated in for...in loops. | false |
| [] | Boolean | If false , the property can"t be deleted and can"t be changed to a data property. | false |
Note: Attribute is usually used by JavaScript engine, so you can"t directly access it (see more about Object.defineProperty()). That"s why the attribute is put in double square brackets instead of single.
"Normal" objects, and functionsA JavaScript object is a mapping between keys and values. Keys are strings (or Symbol s) and values can be anything. This makes objects a natural fit for hashmaps .
Functions are regular objects with the additional capability of being callable.
DatesWhen representing dates, the best choice is to use the built-in Date utility in JavaScript.
Indexed collections: Arrays and typed ArraysArrays are regular objects for which there is a particular relationship between integer-key-ed properties and the "length" property. Additionally, arrays inherit from Array.prototype which provides to them a handful of convenient methods to manipulate arrays. For example, indexOf (searching a value in the array) or push (adding an element to the array), etc. This makes Arrays a perfect candidate to represent lists or sets.
Typed Arrays are new to JavaScript with ECMAScript 2015 and present an array-like view of an underlying binary data buffer. The following table helps you to find the equivalent C data types:
TypedArray objects| Type | Value Range | Size in bytes | Description | Web IDL type | Equivalent C type |
| Int8Array | -128 to 127 | 1 | 8-bit two"s complement signed integer | byte | int8_t |
| Uint8Array | 0 to 255 | 1 | 8-bit unsigned integer | octet | uint8_t |
| Uint8ClampedArray | 0 to 255 | 1 | 8-bit unsigned integer (clamped) | octet | uint8_t |
| Int16Array | -32768 to 32767 | 2 | 16-bit two"s complement signed integer | short | int16_t |
| Uint16Array | 0 to 65535 | 2 | 16-bit unsigned integer | unsigned short | uint16_t |
| Int32Array | -2147483648 to 2147483647 | 4 | 32-bit two"s complement signed integer | long | int32_t |
| Uint32Array | 0 to 4294967295 | 4 | 32-bit unsigned integer | unsigned long | uint32_t |
| Float32Array | 1.2x10 -38 to 3.4x10 38 | 4 | 32-bit IEEE floating point number (7 significant digits e.g. 1.1234567) | unrestricted float | float |
| Float64Array | 5.0x10 -324 to 1.8x10 308 | 8 | 64-bit IEEE floating point number (16 significant digits e.g. 1.123...15) | unrestricted double | double |
| BigInt64Array | -2 63 to 2 63 -1 | 8 | 64-bit two"s complement signed integer | bigint | int64_t (signed long long) |
| BigUint64Array | 0 to 2 64 -1 | 8 | 64-bit unsigned integer | bigint | uint64_t (unsigned long long) |
These data structures take object references as keys and are introduced in ECMAScript Edition 6. Set and WeakSet represent a set of objects, while Map and WeakMap associate a value to an object. The difference between Maps and WeakMaps is that in the former, object keys can be enumerated over. This allows garbage collection optimizations in the latter case.
One could implement Maps and Sets in pure ECMAScript 5. However, since objects cannot be compared (in the sense of "less than" for instance), look-up performance would necessarily be linear. Native implementations of them (including WeakMaps) can have look-up performance that is approximately logarithmic to constant time.
Usually, to bind data to a DOM node, one could set properties directly on the object or use data-* attributes. This has the downside that the data is available to any script running in the same context. Maps and WeakMaps make it easy to privately bind data to an object.
Structured data: JSONJSON (JavaScript Object Notation) is a lightweight data-interchange format, derived from JavaScript but used by many programming languages. JSON builds universal data structures. See JSON and JSON for more details.
More objects in the standard libraryJavaScript has a standard library of built-in objects. Please have a look at the reference to find out about more objects.
Determining types using the typeof operatorThe typeof operator can help you to find the type of your variable. Please read the for more details and edge cases.
Specifications| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of "Types" in that specification. |
Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) |
Standard | Added Symbol. |
| ECMAScript Latest Draft (ECMA-262) The definition of "ECMAScript Data Types and Values" in that specification. |
Draft |
