Типы данных используемые в js. Типы данных Javascript

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

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

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

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

• null
• undefined

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

• function - функции
• array - массивы
• object - объекты

Разница между простыми и составными типами

Разница между простыми и составными типами проявляется при копировании значений.

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

Var num1 = 10; var num2 = num1; // Копируем значение alert("num1: " + num1 + // 10 "\nnum2: " + num2); // 10 num1 = 15; // Изменяем значение alert("num1: " + num1 + // 15 "\nnum2: " + num2); // 10

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

Var o1 = {x:10}; var o2 = o1; // Копируем ссылку на объект alert("o1.x: " + o1.x + // 10 "\no2.x: " + o2.x); // 10 o2.x = 15; // Изменяем значение alert("o1.x: " + o1.x + // 15 "\no2.x: " + o2.x); // 15

null и undefined

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

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

• При обращении к переменной, которая была объявлена, но не была инициализирована.
• При обращении к несуществующему свойству объекта.
• При обращении к несуществующему элементу массива.
• При обращении к параметрам функции, которые не были инициализированы аргументами при вызове функции.
• Возвращается функциями, которые не имеют возвращаемого значения.
• Возвращается оператором typeof, если операндом является несуществующая переменная.

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

Объекты обёртки

Каждый раз, когда в программе предпринимается попытка обратиться к свойству или методу значения примитивного типа, интерпретатор временно преобразует примитивное значение в объект соответствующего типа. Временные объекты, в которые преобразуются значения примитивного типа, называют объектами обёртками . Эти объекты используются интерпретатором для доступа к нужному свойству или методу. Сразу после обращения к свойству или методу объект обёртка уничтожается. Объекты обёртки создаются только для значений типа number , string и boolean . Значения null и undefined не имеют объектов оберток: любые попытки обратиться к свойствам этих значений будут вызывать ошибку.

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

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

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

Переменные JavaScript могут хранить данные самых разных типов - числа, строки, объекты и другие:

Var length = 16; // Число var lastName = "Сидоров"; // Строка var x = {firstName:"Иван", lastName:"Иванов"}; // Объект

Концепция типов данных

В программировании типизация данных является очень важной концепцией.

Чтобы можно было оперировать переменными, крайне важно знать об их типах.

Без типов данных компьютер не будет знать как безопасно вычислить, например, такое выражение:

Var x = 16 + "Volvo";

Имеет ли смысл добавлять к строке "Volvo" число 16? Это приведет к ошибке или какому-либо разумному результату?

JavaScript будет интерпретировать приведенный выше пример следующим образом:

Var x = "16" + "Volvo";

Внимание! При сложении числа и строки JavaScript будет воспринимать число как строку.

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

JavaScript: var x = 16 + 4 + "Volvo"; Результат: 20Volvo JavaScript: var x = "Volvo" + 16 + 4; Результат: Volvo164

В первом примере JavaScript воспринимает 16 и 4 как числа, пока не достигнет строки "Volvo".

Во втором примере, так как первый операнд - строка, все последующие операнды также считаются строками.

JavaScript типы являются динамическими

В JavaScript все типы данных являются динамическими. Это означает, что одна и та же переменная может использоваться для хранения данных разных типов:

Var x; // x имеет тип undefined x = 5; // теперь x - число x = "John"; // теперь x - строка

Строки в JavaScript

Строка (или текстовая строка) это последовательность символов, например, "Иван Петров".

Строки должны записываться внутри кавычек. Это могут быть двойные или одинарные кавычки:

Var carName = "Volvo XC60"; // Используются двойные кавычки var carName = "Volvo XC60"; // Используются одинарные кавычки

Внутри строки можно использовать кавычки только в том случае, если они отличаются от кавычек, в которые заключена строка:

Var answer = "It"s alright"; // Одинарные кавычки внутри двойных var answer = "He is called "Johnny""; // Одинарные кавычки внутри двойных var answer = "He is called "Johnny""; // Двойные кавычки внутри одинарных

Числа в JavaScript

В JavaScript существует только один тип числовых данных.

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

Var x1 = 34.00; // С десятичной точкой var x2 = 34; // Без десятичной точки

Очень большие и очень малые числа могут записываться при помощи научной (экспоненциальной) нотации (имеет вид Mep, где M – число, e - означает "умножить на 10 в степени...", p – порядок или степень, в которую возводится 10):

Var y = 123e5; // 12300000 var z = 123e-5; // 0.00123

Логические данные в JavaScript

Есть два логических значения: true (истина) и false (ложь).

Var x = 5; var y = 5; var z = 6; (x == y) // Вернет true (x == z) // Вернет false

Логические значения часто используются в проверках различных условий.

Массивы в JavaScript

Массивы в JavaScript записываются при помощи квадратных скобок.

Элементы массива разделяются запятыми.

В следующем примере декларируется (создается) массив с именем cars, содержащий три элемента:

Var cars = ["Saab", "Volvo", "BMW"];

Индексация элементов массива начинается с нуля. Это означает, что первый элемент имеет индекс , второй и так далее.

Объекты в JavaScript

Объекты в JavaScript записываются при помощи фигурных скобок.

Свойства объектов записываются в виде пар имя:значение , разделенных запятыми.

Var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};

В приведенном выше примере объект с именем person имеет 4 свойства: firstName, lastName, age, eyeColor.

Оператор typeof

Чтобы определить тип данных переменной в JavaScript используется оператор typeof .

Оператор typeof возвращает тип данных переменной или выражения:

Typeof "" // Вернет "string" typeof "John" // Вернет "string" typeof "John Doe" // Вернет "string" typeof 0 // Вернет "number" typeof 314 // Вернет "number" typeof 3.14 // Вернет "number" typeof (3) // Вернет "number" typeof (3 + 4) // Вернет "number"

Тип undefined

В JavaScript переменные без значения на самом деле имеют значение undefined . И оператор typeof также покажет тип undefined .

Var car; // Значение undefined, тип undefined

Любую переменную можно "сбросить", присвоив ей значение undefined . Ее тип также станет undefined .

Car = undefined; // Значение undefined, тип undefined

Пустые значения

Пустое значение не имеет ничего общего со значением undefined .

У пустой строки есть корректные значение и тип.

Var car = ""; // Значение "", тип typeof "string"

Null

В JavaScript значение null означает "ничего". Это что-то чего не существует.

При этом в JavaScript тип null является объектом.

Вы можете обнулить объект присвоив ему значение null :

Var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"}; person = null; // Теперь здесь значение null, но тип по прежнему object

Также, обнулить объект можно при помощи значения undefined :

Var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"}; person = undefined; // Теперь здесь значение и тип undefined

Разница между undefined и null

Undefined и null равны по значению, но различны по типу:

Typeof undefined // undefined typeof null // object null === undefined // false null == undefined // true

Примитивные данные

Примитивными данными являются одиночные простые значения без дополнительных свойств и методов.

В этом случае оператор typeof возвращает один из следующих примитивных типов:

• string
• number
• boolean
• undefined

Сложные (комплексные) данные

В JavaScript существует два сложных или комплексных типа данных:

• function
• object

Оператор typeof возвращает тип "object" для объектов, массивов и значения null.

Для функций оператор typeof возвращает тип не "object", а "function".

Typeof {name:"John", age:34} // Вернет "object" typeof // Вернет "object" (не "array", см. ниже) typeof null // Вернет "object" typeof function myFunc(){} // Вернет "function"

Внимание! Для массивов оператор typeof возвращает тип "object", потому что в JavaScript массивы являются объектами.

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

Динамическая типизация

В процессе работы компьютерные программы манипулируют различными значениями, каждое из которых может быть обработано в языке программирования и относится к определённому типу данных.

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

JavaScript – это слабо типизированный или динамический язык программирования, который позволяет определять типы данных, осуществлять синтаксический анализ и компиляцию как говорится «на лету», на этапе выполнения программы. Это значит, что вам не нужно определять тип переменной заранее. Тип определится автоматически во время выполнения программы.
Таким образом, в различных участках программы одна и та же переменная может принимать значения разных типов:

Типы данных

Стандарт ECMAScript® определяет следующие типы данных:

• Простые (их также называют примитивными) типы:
  • логический (англ. Boolean) - может принимать два возможных значения, иногда называемых истиной (true) и ложью (false);
  • нулевой (англ. Null) – значение null представляет ссылку, которая указывает, обычно намеренно, на несуществующий или некорректный объект или адрес;
  • неопределённый (англ. Undefined) – обозначает предопределенную глобальную переменную, инициализированную неопределенным значением;
  • числовой (англ. Number) – числовой тип данных в формате 64-битного числа двойной точности с плавающей запятой;
  • строковый (англ. String) – представляет собой последовательность символов, используемых для представления текста;
  • символ (англ. Symbol​) - тип данных, экземпляры которого уникальны и неизменяемы. (новый в ECMAScript 6).
• Объектный (англ. Object) – это коллекция именованных значений, которые обычно называют свойствами (properties) объекта.

Разница между примитивными и составными типами

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

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

Разница между примитивными и составными типами данных проявляется при копировании их значений.

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

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

Примитивные типы

Все типы данных в JavaScript, кроме объектов, являются неизменяемыми или иммутабельными (англ. immutable). Это значит, что их значения не могут быть модифицированы, а только перезаписаны новым другим значением. Например, строки нельзя корректировать посимвольно – их можно переписать только полностью. Значения таких типов называются "примитивными".

Простейшие данные, с которыми может оперировать программа, называются литералами. Литералы - это числа или строки, которые используются для представления значений в JavaScript. Предоставляемая информация может быть самой разнообразной, а поэтому значения бывают различных типов. Простейшие типы данных в JavaScript называются основными типами данных: числа, строки и логические значения. Все они относятся к "примитивным".

Булевый (логический) тип «boolean»

Логические, или булевы значения (по фамилии их изобретателя - Буля), могут иметь лишь одно из двух значений: true (истина) или false (ложь). Значения true или false обычно появляются в операциях сравнения или логических операциях.

Приведенная ниже программа создает булеву переменную, а затем тестирует ее значение с использованием инструкции if/else:

В качестве сравнительного выражения можно использовать любое выражение. Любое выражение, которое возвращает значение 0, null, undefined или пустую строку, интерпретируется как false . Выражение, определяющее какое-либо другое значение, интерпретируется как true .

Примечание: При записи булевых значений их не заключают в кавычки: var myVar = true;
В то же время объявление var myVar = "true" создает строковую переменную.

Тип данных Number

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

Для представления чисел в JavaScript используется 64-битный формат, определяемый стандартом IEEE-754 . Этот формат способен представлять числа в диапазоне от ±1,7976931348623157 × 10 308 до ±5 × 10 -324 .

Число, находящееся непосредственно в коде программы, называется числовым литералом. Помимо десятичных целых литералов JavaScript распознает шестнадцатеричные значения.
Числа в шестнадцатиричном формате могут включать любую последовательность цифр от 0 до 9 и буквы от a до f, которая обязательно начинается с последовательности символов «0x».

Var a = 255; var b = 0xFF; // Число 255 в шестнадцатеричной системе исчисления

Кроме того, JavaScript содержит специальные числовые значения:

• NaN (не число или ошибка вычислений). Является результатом некорректной математической операции над недопустимыми данными, такими как строки или неопределенное значение.
• Infinity (положительная бесконечность). Используется, если положительное число слишком велико и не может быть представлено в JavaScript.
• -Infinity (отрицательная бесконечность). Используется, если отрицательное число слишком велико и не может быть представлено в JavaScript.
• ±0 (положительный и отрицательный 0). JavaScript различает положительный и отрицательный ноль.

Тип данных String

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

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

var firstName = "Max"; //синтаксическая ошибка - разные кавычки

Примечание: В JavaScript нет специального типа данных для одного символа, такого как char в C, C++ и Java. Одиночный символ представлен строкой единичной длины.

Тип данных Null

Ключевое слово null невозможно использовать в качестве имени функции или переменной. Значение null является ссылкой на «пустой» объект и имеет специальное назначение – обычно оно используется для инициализации переменной, которой впоследствии будет присвоено значение.

Оператор typeof для значения null возвращает строку «object», что свидетельствует о том, что значение null является специальным «пустым» объектом.

Тип данных Undefined

Неопределенный тип (undefined) образует свой собственный тип, который содержит единственное специальное значение – undefined . Такое значение имеет переменная, объявленная с помощью оператора var , но не инициализированная:

Значение undefined возвращается при обращении к переменной, которой никогда не присваивалось значение, а также к несуществующему свойству объекта или элементу массива.

Следует отметить, что переменная со значением undefined отличается от переменной, которая вообще не определена:

В этом примере метод alert() выводит значение переменной age , то есть undefined . Во втором случае в метод alert() передается необъявленная переменная car , что приводит к ошибке.

Следующй пример может несколько запутать начинающих программистов, т.к. оператор typeof и для неинициализированной, и для необъявленной переменной возвращает значение undefined:

В приведенном примере переменная age объявлена, но в неё ничего не записано, поэтому её значение как раз и есть undefined . Переменная car не объявлена – её, по сути, нет. Тем не менее, typeof возвращает строку undefined в обоих случаях. Некоторый смысл в этом, конечно, есть, потому что с любой из этих переменных невозможно выполнить никаких операций, хотя технически они совершенно разные.

Примечание: Рекомендуется всегда выполнять инициализацию объявленной пременной. В таком случае вы будете знать, что оператор typeof возвращает undefined из-за того, что переменная не была объявлена, а не потому, что она не инициализирована.

Значение undefined является производным от null , так что в ЕСМА-262 оператор эквивалентности == считает их равными:

Несмотря на то, что значения null и undefined связаны, используются они по-разному. Не следует явно присваивать переменной значение undefined , однако к null это требование не относится. В случае, когда необходимый объект недоступен, вместо него следует использовать null . Это указывает на то, что значение null было введено как указатель на пустой объект, и подчеркивает его отличие от undefined .

Чтобы отличать null и undefined в программе можно использовать оператор идентичности === :

Тип данных Символ (Symbol)

Символ (symbol) является нововведением JavaScript начиная с ECMAScript версии 6. Символ – это уникальное, неизменяемое, примитивное значение, которое служит для создания уникальных идентификаторов.

Чтобы создать символ нужно вызвать функцию Symbol:

var mySymbol = Symbol();

Для определения символа можно использовать оператор typeof , в случае если значения является символом будет возвращена строка symbol:

У функции Symbol есть необязательный параметр - строка, которая служит для описания символа:

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

Тип данных Object

В дополнение к рассмотренным выше примитивным типам данных JavaScript поддерживает составной тип данных – объект (object). Объект состоит из многих значений (либо элементарных, таких как числа и строки, либо сложных, например других объектов), которые называются свойствами объекта. Доступ к свойствам осуществляется по имени свойства (иногда говорят «по ключу»).

Имя свойства является строкой, поэтому можно считать, что объекты связывают строки со значе­ниями. Вместе эти фрагменты информации образуют пары «ключ-значение».

В JavaScript объекты можно создавать одним из двух синтаксисов:

1. var obj = {}; // с помощью объектного литерала 2. var obj = new Object(); // с помощью метода, называемого конструктором

Создание объекта с помощью объектного литерала начинается с определения обыч­ной переменной. В правой части этой инструкции записывается литерал объекта – это заключенный в фигурные скобки {} список разделенных запятой пар "имя-значение" , заключенный в фигурные скобки. Имя свойства и значение отделены друг от друга двоеточием:

var cat = { "legs": 4, "name": "Мурзик", "color": "Рыжий" }

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

Урок №3
Типы данных в языке JavaScript

В прошлом уроке мы выяснили, что переменная — это именованная область памяти, которая хранит в себе какие-либо данные (значения).

У каждого значения в JavaScript, имеется свой тип данных . Всего в JavaScript существует 6 типов данных, в этом уроке по JavaScript, мы рассмотрим 4 типа данных:
— числовой тип данных number ,
— строковый тип данных string ,
— логический тип данных boolean ,
— неопределённый тип данных undefined .

Остальные два изучим чуть позже:
— объектный тип данных object
— пустой тип данных null

Оператор typeof

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

Alert(typeof имяПеременной);

После этого скрипт должен выдать какое-либо сообщение: number , string , boolean , undefined , object .

Тип данных: число (number)

Когда переменной, в качестве значения, присваивается какое-либо число (без кавычек) , её тип данных становится number

Var myNumber; myNumber = 5; alert(typeof myNumber);

В первой строке мы создали переменную с именем myNumber , во второй строке, присвоили переменной значение 5 , в третьей с помощью оператора typeof вычислили тип данных у переменной myNumber , а функция alert() показала нам результат этих вычислений.

В итоге, данный скрипт выведет нам сообщение number . Если число обрамить кавычками (одинарными "5" или двойными "5" ) , то оно превратится в строку string .

Тип данных: строка (string)

Когда переменной в качестве значения присваивается какое-либо значение, заключённое в двойные " " или одинарные кавычки " " , то её тип данных становится string .

Var myString; myString = "Привет, я строка JavaScript!"; alert(typeof myString);

В первой строке мы создали переменную с именем myString , во второй строке, присвоили переменной значение "Привет, я строка JavaScript!" , в третьей с помощью оператора typeof вычислили тип данных у переменной myString , а функция alert() показала нам результат этих вычислений. В итоге, данный скрипт должен вывести нам сообщение string .

Тип данных: логический тип данных (boolean)

Когда переменной в качестве значения присваивается true или false , без кавычек , то её тип данных становится boolean .

Тип данных boolean — это логический тип данных, он имеет всего два значения: true (правда) или false (ложь) .

Var myBoolean; myBoolean = true; alert(typeof myBoolean);

В первой строке мы создали переменную с именем myBoolean , во второй строке, присвоили переменной значение true , в третьей с помощью оператора typeof вычислили тип данных у переменной myBoolean , а функция alert() показала нам результат этих вычислений. В итоге, данный скрипт должен вывести нам сообщение boolean .

Логический тип данных, мы изучим более подробно в следующих уроках, посвящённых операциям сравнения, логическим операциям и оператору ветвления if

Тип данных: undefined

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

Var myUndefined; alert(typeof myUndefined);

В первой строке мы создали переменную с именем myUndefined , во второй строке с помощью оператора typeof вычислили тип данных у переменной myUndefined , а функция alert() показала нам результат этих вычислений. В итоге, данный скрипт должен вывести нам сообщение undefined .

Доступ к значению переменной

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

В первой и второй строках кода мы создали переменные myString и myNumber , в третьей и четвёртой строках присвоили переменным значения "Привет, МИР!" и 5 , в пятой и шестой строках с помощью функции alert() вывели результаты Привет, МИР! и 5

Для создания имён переменных в JavaScript установлены правила синтаксиса:

• Для имён переменных используются символы: a-z, A-Z, цифры, символ $, символ знак подчёркивания (_).
• Имя переменной не может начинаться с цифры.
• JavaScript чувствителен к регистру, об этом нужно помнить при программировании. itcounter и itC ounter - это разные переменные.
• В JavaScript нет ограничений на длину имени переменной.

Примеры правильных имён переменных:

• itcounter
• $_itcounter
• it_counter

Ошибочные имена переменных:

• 9room
• it-counter
• #itcounter
• &itcounter

Переменные объявляются командой var .

В переменных можно хранить строки и числа. На самом деле можно хранить и другие типы данных, но о них поговорим позже.

Строковые переменные

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

Var $stroka_1 = "Привет!"; var $stroka_2 = "Осторожно!";

В строку, созданную одинарной кавычкой, можно включить двойную кавычку и наоборот.

Var $stroka_1 = ""Привет!" - это приветствие."; var $stroka_2 = ""Осторожно!" - это предупреждение."; document.write($stroka_1); document.write("

Чтобы вывести кавычку того же типа, её нужно экранировать символом обратного слэша. Всё просто:

"); document.write($stroka_2);

Значения переменных можно присваивать другим переменным:

Var $stroka_1 = "\"Привет!\" - это приветствие."; var $stroka_2 = "\"Осторожно!\" - это предупреждение."; document.write($stroka_1); document.write("
"); document.write($stroka_2); $stroka_2 = $stroka_1; document.write("
"); document.write($stroka_2);

В этом примере мы сначала в переменную $stroka_2 присвоили одно строковое значение, но потом присвоили ей значение переменной $stroka_1.

Объединение строк

Очень часто нужно объединить несколько строк в одну. Например, наш последний пример слишком громоздкий.

Объединение (конкатенация) строк в JavaScript осуществляется с помощью знака + .

Для вывода на экран 2 строковых переменных разделённых тегом
переменных можно использовать одну команду document.write() .

Var $stroka_1 = ""Привет!" - это приветствие."; var $stroka_2 = ""Осторожно!" - это предупреждение."; document.write($stroka_1 + "
" + $stroka_2);

Оператор конкатенации + также можно использовать в переменных:

Var $stroka_1 = ""Привет!" - это приветствие."; var $stroka_2 = ""Осторожно!" - это предупреждение."; var $stroka_3 = $stroka_1 + "
" + $stroka_2; document.write($stroka_3);

Числовые переменные

Чтобы создать числовую переменную нужно просто присвоить ей числовое значение.

Var $count_1 = 23; var $count_2 = 10.34; document.write($count_1 - $count_2);

Теперь другой пример:

Var $count_1 = 23; // Числовая переменная. var $stroka_1 = "57"; // Строковая переменная. document.write($stroka_1 + $count_1);

Видите, значение переменной $stroka_1 взято в кавычки, значит это текстовая переменная. Потом мы складываем текстовую и числовую переменную и получаем строку "5723", так работает JavaScript в таких случаях - превращает число в строку и добавляет к суммируемой строке.

Булевы переменные

Есть такой тип переменных - булевы. Всё просто, тут только два значения: истина и ложь, то есть true (истина) и false (ложь).

Этот тип данных используется в операциях сравнения. Вот простые примеры:

• 9 > 1 - это истина.
• 2 > 5 - это ложь.

Теперь попробуем подставить булевы значения в арифметические действия. Суммируем две операции сравнения:

Var $count = (3 > 2) + (4 > 2); document.write($count);

Эта странная запись, я знаю. Но переменная $count будет равна 2. В математическом контексе значение true = 1, а значение false = 0.

Операции сравнения используются в часто применяемой инструкции if в JavaScript. Слово if по английски значит - если.

Var $count = 100; if ($count == 100) document.write("Переменная $count равна 100.");

В данном примере сообщение будет выведено на экран, так как условие инструкции if ($count == 100) равно истине (true). Если изменить значение переменной $count на 99, то условие ($count == 100) станет равно false (ложь) и на экран ничего не выведется.

Простые типы переменных

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

• string - строковая переменная.
• number - числовая переменная.
• boolean - булева переменная.
• null - специальное значение «ничто».
• undefined - тип «значение не присвоено».

Значение переменной null образует свой отдельный тип null, состоящий из единствено возможного значения null. null - это специальное значение, которое имеет смысл «ничего» или «значение неизвестно».

Var $price = null; // это значит что цена не известна.

В JavaScript можно узнать тип переменных при помощи инструкции typeof .

Var $count; document.write(typeof $count + "
"); var $count = true; document.write(typeof $count + "
"); var $count = "true"; document.write(typeof $count + "
"); var $count = 100; document.write(typeof $count + "
"); var $count = null; document.write(typeof $count + "
");

Синтаксис инструкции typeof может быть таким:

• typeof $count
• typeof($count)

Итак, запустите код из последнего примера и посмотрите на результат. Тип переменной null будет object. Этот ошибка в языке, и она, вероятно, никогда не будет исправлена из-за необходимости сохранения совместимости уже написаных JavaScript сценариев с новыми версиями языка.

Тип object - это уже не примитивный тип, о нём мы будем говорить в других уроках.