Я решил написать цикл статей, под названием «Сложно о простом». Этот цикл будет посвящён языку JavaScript. Почему «сложно о простом»? Потому что всё, что я буду рассказывать я буду рассказывать учитывая особенности работы интерпретатора, начиная с типов данных. Всё это будет делаться для того, что бы потом можно было рассказать просто о сложном, например, о способах наследования в JavaScript и прочих патернах.

JavaScript – это объектно-ориентированный язык программирования, с прототипной организацией.
Что значит «с прототипной организацией», мы поговорим в следующей статье (она обязательно будет), а вот почему он «объектно-ориентированный» и всё ли в JS - объект, мы узнаем сегодня.
Для выполнения своих целей JS`у достаточно всего 9 типов. Причём только 6 из них доступны программе, оставшиеся же 3 доступны лишь на уровне реализации и используется спецификацией. На первый взгляд(и это первое заблуждение) всё в JS является объектами. Так вот пять из шести доступных программе типов являются так называемыми примитивами и не есть объектами(ниже я поясню почему и как их путают с объектами). Эти пять примитивов это:

- String (s=’str’)
- Number (n=10)
- Boolean (b=true)
И как я их называю «философские типы»:
- null (v = null)
- undefined (u=undefined)

Философские по тому, что null означает, что переменной присвоено ничего, а undefined – означает, что в переменную присвоили пустоту. Чем отличается «ничего» от «пустоты» в данном случае – поразмыслите на досуге. Сейчас мы этого делать не станем.

Шестой, доступный программе тип(объектный) – это:
- Object (не путайте с конструктором Object, мы сейчас ведём речь лишь об абстрактных типах!) – единственный тип, представляющий объекты в JavaScript.
Объект - это структура данных(целый их набор), представленный в виде набора пар «ключ-значение». Значением может быть любой из типов данных - тогда это будет свойство объекта, или даже функция - тогда это будет метод объекта.

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

Вот несколько примеров:

Var v1; //undefined (пустая) локальная переменная var v2="2"; //строковая локальная литеральная переменная var v3 = new String(2); //строковая локальная, объявленная через конструктор переменная. Создаст новый объект типа String v4 = String(2); //строковая глобальная переменная вызванная через конструктор. Создаст переменную window.v4 "2".length; // строка не станет переменной но её можно уже использовать как Объект 34..toString(); //число не станет переменной но его уже можно использовать как объект 12. toString(); //число не станет переменной но его уже можно использовать как объект (22).toString();//число не станет переменной но его уже можно использовать как объект

В последних 4-х командах, как раз хорошо видно как примитив путают с объектом – ведь мы же вызываем метод, через точку – прямо как у объекта. Действительно создаётся впечатление, что эти примитивы – объекты.

Заблуждение усугубляется, когда мы проверяем тип переменной, например

Var v = null; typeof v;

И получаем в ответ «object».

А если мы напишем:
var v = null; v instanceof Object;

То в голове вообще возникнет каша, потому, что результат последней строчки будет «false». То есть переменная v имеет тип object, но не унаследована от типа Object. Что за дела?!

Для начала объясню подвох с typeof null. Этот оператор возвращает тип объекта. А дело в том, что оператор typeof возвращает строковое значение, взятое из жёстко закреплённой таблицы, где прописано: «для null – возвращать «object»». Оператор же instanceof – проверяет принадлежит ли что-то к указанному типу данных. Как он это делает, я расскажу в следующей статье, но, уверяю вас, в данном случае он отработал верно, примитив null ни в коем случае не унаследован от типа Object – он сам по себе, примитив – низшая ступень развития.

Ладно, с typeof и instanceof разобрались, но методы то у примитивов вызываются – как у объектов прям! Как, если это не объект?

Тут дело вот в чём. Существует такая вещь как функции-обёртки(конструкторы)(и снова всё прояснится во второй статье). Они есть для всех примитивов (Number(), Boolean(), String()), а так же и другие. Их суть состоит в том, что бы из примитива создать объект, у которого будут вспомогательные методы для работы с данным типом примитива.
Например переменную можно создать так:

Var num = new Number(23.456);

В таком случае из примитива 23.456 мы получим объект.
Для типа number конструктор Number() имеет вспомогательный метод toPrecision() – он определяет для числа количество значимых цифр. Например, если числу 23.456 установить количество значимых цифр 4, то мы получим число 23.45.
И вот когда мы пытаемся обратится к примитиву как к объекту:

(23.456). toPrecision(4);

Интерпретатор временно оборачивает, примитив в объект вызовом new Number(23.456) и потом уже у этого объекта вызывает метод toPrecision(), который у него теперь есть. Таким образом, многие ошибочно считают, что всё в JS есть объектом.

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

Var str = ‘str’; str.test = ‘test’; //ошибки не будет, программа продолжит работать, но console.log(str.test); //undefined

Если бы мы считали, как раньше, что str – это объект, мы бы удивились, почему он не запомнил в себе новое свойство test. Но теперь мы знаем, что при обращении к примитиву как к объекту, он временно оборачивается в объект типа String. Но после выполнения операции эта обёртка исчезает, а вместе с ней и новое свойство test. Вот и всё, никакой магии.

На самом деле, забегая наперёд, во время оборачивания примитива в объект, выстраивается целая цепочка наследования (как это организовано мы поговорим позже), но по сути получается такая вот «матрёшка»:

Object(Number(<примитив>)). Родителем любого объекта в JS, так или иначе, будет Object. При вызове свойства в объекте поиск проходит по всей этой «матрёшке» пока не найдёт в одном из объектов это свойство или вернёт undefined или если искали метод, то выбросит исключение. Таким образом, у примитива также доступны свойства объекта Object. Как работает прототипное наследование и о его тонкостях мы поговорим во второй статье.

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

Var str = "abc"; str+1; // "abc1"

Здесь примитив типа number - 1, будет преобразован в строковый примитив. В объектах эта возможность доступна через вызов метода toString(), в объектах типа number, есть метод valueOf(), который вернёт примитив типа number. Но мы вроде как говорили что методы могут быть только у объектов. Значит в процессе преобразования примитива из одного типа в другой, происходит тоже оборачивание в объект? Уверяю вас что нет. Вызов этого метода происходит не явно, когда функция-конструктор вызывается интерпретатором без оператора new. Что за волшебный оператор new и что происходит когда функция-конструктор вызывается без него, да и что блин в конце то концов за функция-конструктор такая, мы поговорим в следующей статье. Пока поверьте мне на слово - преобразование типов происходит сразу - из примитива в примитив.

Пока, конечно, больше вопросов чем ответов, однако, поверьте, всё станет намного прозрачнее после прочтения второй статьи. Здесь я в основном заинтриговал и поднял ряд вопросов - так сказать взбудоражил умы. Но всё же кое-что можно вынести и из этой статьи:
1. Не смотря на расхожее мнение «всё в JS является объектами» - это не так, мы выяснили, что из 6 доступных программисту типов данных аж 5 является примитивами и лишь один представляет тип объектов.
2. Про объекты мы узнали, что это такая структура данных, которая содержит в себе пары «ключ-значение». При значением может быть любой из типов данных (и это будет свойство объекта) или функция (и это будет метод объекта).
3. А вот примитивы – это не объекты. Хотя с ними и можно работать как с объектом (и это вызывает заблуждение что примитив – это объект), но…
4. Переменные можно объявить как по простому (литерально) (var a = ‘str’), так и через функцию-конструктор (обёртка)(var a = new String(‘str’)). Во втором случае мы получим уже не примитив, а объект созданный функцией-обёрткой String(). (что за магический оператор new и что такое функция-конструктор мы узнаем дальше).
5. Узнали, что именно за счёт создания обёртки над примитивом (new String(‘str’)) c ним можно работать как с объектом. Именно эту обёртку создаёт интерпретатор вокруг примитива, когда мы пытаемся работать с ним как с объектом, но после выполнения операции она разрушается (поэтому примитив никогда не сможет запомнить свойство, которое мы ему присвоим a.test = ‘test’- свойство test исчезнет с обёрткой).
6. Узнали, что у объектов есть метод toString() который возвращает строковое представление объекта (для типа number valueOf() – вернёт числовое значение).
7. Поняли, что при выполнении операций конкатенации или математических операциях примитивы могут переопределить свой тип в нужный. Для этого они используют функции-обёртки своих типов, но без оператора new (str = String(str)).(в чём разница и как это работает, поговорим дальше)
8. И наконец, узнали, что typeof берёт значения из жёстко зафиксированной таблицы (вот откуда ещё одно заблуждение, основанное на typeof null //object).

Последнее обновление: 26.03.2018

Все используемые данные в javascript имеют определенный тип. В JavaScript имеется пять примитивных типов данных:

String : представляет строку

Number : представляет числовое значение

Boolean : представляет логическое значение true или false

undefined : указывает, что значение не установлено

null : указывает на неопределенное значение

Все данные, которые не попадают под вышеперечисленные пять типов, относятся к типу object

Числовые данные

Числа в JavaScript могут иметь две формы:

Целые числа, например, 35. Мы можем использовать как положительные, так и отрицательные числа. Диапазон используемых чисел: от -2 53 до 2 53

Дробные числа (числа с плавающей точкой), например, 3.5575. Опять же можно использовать как положительные, так и отрицательные числа. Для чисел с плавающей точкой используется тот же диапазон: от -2 53 до 2 53

Например:

Var x = 45; var y = 23.897;

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

Строки

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

Если внутри строки встречаются кавычки, то мы их должны экранировать слешем. Например, пусть у нас есть текст "Бюро "Рога и копыта"" . Теперь экранируем кавычки:

Var companyName = "Бюро \"Рога и копыта\"";

Также мы можем внутри стоки использовать другой тип кавычек:

Var companyName1 = "Бюро "Рога и копыта""; var companyName2 = "Бюро "Рога и копыта"";

Тип Boolean

Тип Boolean представляет булевые или логические значения true и false (то есть да или нет):

Var isAlive = true; var isDead = false;

null и undefined

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

Var isAlive; console.log(isAlive); // выведет undefined

Присвоение значение null означает, что переменная имеет некоторое неопределенное значение (не число, не строка, не логическое значение), но все-таки имеет значение (undefined означает, что переменная не имеет значения):

Var isAlive; console.log(isAlive); // undefined isAlive = null; console.log(isAlive); // null isAlive = undefined; // снова установим тип undefined console.log(isAlive); // undefined

object

Тип object представляет сложный объект. Простейшее определение объекта представляют фигурные скобки:

Var user = {};

Объект может иметь различные свойства и методы:

Var user = {name: "Tom", age:24}; console.log(user.name);

В данном случае объект называется user, и он имеет два свойства: name и age. Это краткое описание объектов, более подробное описание приводится в соответствующей главе.

Слабая типизация

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

Var xNumber; // тип undefined console.log(xNumber); xNumber = 45; // тип number console.log(xNumber); xNumber = "45"; // тип string console.log(xNumber);

Несмотря на то, что во втором и третьем случае консоль выведет нам число 45, но во втором случае переменная xNumber будет представлять число, а в третьем случае - строку.

Это важный момент, который надо учитывать и от которого зависит поведение переменной в программе:

Var xNumber = 45; // тип number var yNumber = xNumber + 5; console.log(yNumber); // 50 xNumber = "45"; // тип string var zNumber = xNumber + 5 console.log(zNumber); // 455

Выше в обоих случая к переменной xNumber применяется операция сложения (+). Но в первом случае xNumber представляет число, поэтому результатом операции xNumber + 5 будет число 50.

Во втором случае xNumber представляет строку. Но операция сложения между строкой и числом 5 невозможна. Поэтому число 5 будет преобразовываться к строке, и будет происходить операция объединения строк. И результатом выражения xNumber + 5 будет стока "455".

Оператор typeof

С помощью оператора typeof можно получить тип переменной:

Var name = "Tom"; console.log(typeof name); // string var income = 45.8; console.log(typeof income); // number var isEnabled = true; console.log(typeof isEnabled); // boolean var undefVariable; console.log(typeof undefVariable); // undefined

Начнем, как обычно, с определения того, с чем мы знакомимся. Что же такое типы данных? Это понятие относится ко всем языкам программирования и JavaScript здесь не уникален. Если мы обратимся к определению в Википедии, то узнаем, что типы данных — это множество значений и операций на этих значениях. Говоря проще, тип данных это, по сути, тип значений, которые мы можем сохранить в переменную и работать с ними.

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

Итак, в JavaScript можно выделить шесть типов данных:

JavaScript. Быстрый старт

логическое или булево значение

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

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

var name = "John", surname = "Doe";

var name = "John" , surname = "Doe" ;

JavaScript. Быстрый старт

Изучите основы JavaScript на практическом примере по созданию веб-приложения

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

var num1 = 2, num2 = 3.4 num3 = -5;

var num1 = 2 , num2 = 3.4 num3 = - 5 ;

Обратите внимание, дробная часть числа отделяется не запятой, а точкой (десятичная точка). Также число может быть со знаком: -5 в примере.

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

Итак, логический тип или булев тип данных. У него всего два возможных значения: true и false. Если упростить, то их можно сравнить с словами «да» и «нет» или «истина» и «ложь». Пример записи булевых значений в JavaScript:

var yes = true, no = false;

var yes = true , no = false ;

Обратите внимание, значения true и false регистрозависимы. В PHP, к примеру, константы true и false не зависят от регистра.

Следующие два специальных значения — null и undefined. Они очень похожи и по сути обозначают одно и то же — отсутствие значения. undefined будет значением переменной, которая просто объявлена, но для нее не установлено значение, т.е. значение не определено. null же часто записывают в переменную, чтобы обнулить значение переменной, сделать его неизвестным, если можно так сказать. В следующих статьях мы детальнее увидим специфику работы с этими типами данных в JavaScript.

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

// запись объекта var user = { name: "John", surname: "Doe", year: 2016 }; // обращение к свойствам объекта alert(user.name); alert(user.surname); alert(user.year);

В процессе работы компьютерные программы манипулируют значениями, такими как число 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, если операндом является несуществующая переменная.

var bar; document.write(bar); Попробовать »

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

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

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

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

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

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

В этом уроке мы познакомимся с очень важным понятием – типы данных 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 .

Ключевое слово 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 есть необязательный параметр - строка, которая служит для описания символа:

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

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

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

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

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

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

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

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

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

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

Значение (undefined) имеет переменная, объявленная с помощью оператора var , но не инициализированная.

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

• с помощью объектного литерала
• с помощью метода, называемого конструктором

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