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

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

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

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

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

Прежде чем использовать переменную, её нужно объявить с использованием ключевого слова var или let . Если речь идёт о константе, применяется ключевое слово const . Объявить переменную и присвоить ей некое значение можно и не используя эти ключевые слова, но делать так не рекомендуется.

▍Ключевое слово var До появления стандарта ES2015 использование ключевого слова var было единственным способом объявления переменных.

Var a = 0
Если в этой конструкции опустить var , то значение будет назначено необъявленной переменной. Результат этой операции зависит от того, в каком режиме выполняется программа.

Так, если включён так называемый строгий режим (strict mode), подобное вызовет ошибку. Если строгий режим не включён, произойдёт неявное объявление переменной и она будет назначена глобальному объекту. В частности, это означает, что переменная, неявно объявленная таким образом в некоей функции, окажется доступной и после того, как функция завершит работу. Обычно же ожидается, что переменные, объявляемые в функциях, не «выходят» за их пределы. Выглядит это так:

Function notVar() { bNotVar = 1 //лучше так не делать } notVar() console.log(bNotVar)
В консоль попадёт 1 , такого поведения от программы обычно никто не ждёт, выражение bNotVar = 1 выглядит не как попытка объявления и инициализации переменной, а как попытка обратиться к переменной, находящейся во внешней по отношению к функции области видимости (это - вполне нормально). Как результат, неявное объявление переменных сбивает с толку того, кто читает код и может приводить к неожиданному поведению программ. Позже мы поговорим и о функциях, и об областях видимости, пока же постарайтесь всегда, когда смысл некоего выражения заключается в объявлении переменной, пользоваться специализированными ключевыми словами. Если в этом примере тело функции переписать в виде var bNotVar = 1 , то попытка запустить вышеприведённый фрагмент кода приведёт к появлению сообщения об ошибке (его можно увидеть в консоли браузера).

Выглядеть оно, например, может так: Uncaught ReferenceError: bNotVar is not defined . Смысл его сводится к тому, что программа не может работать с несуществующей переменной. Гораздо лучше, при первом запуске программы, увидеть такое сообщение об ошибке, чем писать непонятный код, который способен неожиданно себя вести.

Если, при объявлении переменной, её не инициализируют, не присваивают ей какого-либо значения, ей автоматически будет присвоено значение undefined .

Var a //typeof a === "undefined"
Переменные, объявленные с помощью ключевого слова var , можно многократно объявлять снова, назначая им новые значения (но это может запутать того, кто читает код).

Var a = 1 var a = 2
В одном выражении можно объявить несколько переменных:

Var a = 1, b = 2
Областью видимости переменной (scope) называют участок программы, в котором доступна (видима) эта переменная.

Переменная, инициализированная с помощью ключевого слова var за пределами какой-либо функции, назначается глобальному объекту. Она имеет глобальную область видимости и доступна из любого места программы. Если переменная объявлена с использованием ключевого слова var внутри функции, то она видна только внутри этой функции, являясь для неё локальной переменной.

Если в функции, с использованием var , объявлена переменная, имя которой совпадает с именем некоей переменной из глобальной области видимости, она «перекроет» глобальную переменную. То есть, при обращении к такой переменной внутри функции будет использоваться именно её локальный вариант.

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

Если в коде функции объявлена некая переменная, она видна всему коду функции. Даже если переменная объявлена с помощью var в конце кода функции, обратиться к ней можно и в начале кода, так как в JavaScript работает механизм поднятия переменных (hoisting). Этот механизм «поднимает» объявления переменных, но не операции их инициализации. Это может стать источником путаницы, поэтому возьмите себе за правило объявлять переменные в начале функции.

▍Ключевое слово let Ключевое слово let появилось в ES2015, его, упрощённо, можно назвать «блочной» версией var . Область видимости переменных, объявленных с помощью ключевого слова let , ограничивается блоком, оператором или выражением, в котором оно объявлено, а также вложенными блоками.

Если само слово «let» кажется не очень понятным, можно представить, что вместо него используется слово «пусть». Тогда выражение let color = "red" можно перевести на английский так: «let the color be red», а на русский - так: «пусть цвет будет красным».

При использовании ключевого слова let можно избавиться от неоднозначностей, сопутствующих ключевому слову var (например, не удастся два раза, используя let , объявить одну и ту же переменную). Использование let за пределами функции, скажем, при инициализации циклов, не приводит к созданию глобальных переменных.

Например, такой код вызовет ошибку:

For (let i = 0; i < 5; i++) { console.log(i) } console.log(i)
Если же, при инициализации цикла, счётчик i будет объявлен с использованием ключевого слова var , то i будет доступно и за пределами цикла, после того, как он завершит работу.

В наши дни, при разработке JS-программ на основе современных стандартов, вполне можно полностью отказаться от var и использовать только ключевые слова let и const .

▍Ключевое слово const Значения переменных, объявленных с использованием ключевых слов var или let , могут быть перезаписаны. Если же вместо этих ключевых слов используется const , то объявленной и инициализированной с его помощью константе новое значение присвоить нельзя.

Const a = "test"
В данном примере константе a нельзя присвоить новое значение. Но надо отметить, что если a - это не примитивное значение, наподобие числа, а объект, использование ключевого слова const не защищает этот объект от изменений.

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

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

Const obj = {} console.log(obj.a) obj.a = 1 //работает console.log(obj.a) //obj = 5 //вызывает ошибку
В константу obj , при инициализации, записывается новый пустой объект. Попытка обращения к его свойству a , несуществующему, ошибки не вызывает. В консоль попадает undefined . После этого мы добавляем в объект новое свойство и снова пытаемся обратиться к нему. В этот раз в консоль попадает значение этого свойства - 1 . Если раскомментировать последнюю строку примера, то попытка выполнения этого кода приведёт к ошибке.

Ключевое слово const очень похоже на let , в частности, оно обладает блочной областью видимости.

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

Типы данных JavaScript иногда называют «нетипизированным» языком, но это не соответствует реальному положению дел. В переменные, и правда, можно записывать значения разных типов, но типы данных в JavaScript, всё-таки, есть. В частности, речь идёт о примитивных и об объектных типах данных.

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

▍Примитивные типы данных Вот список примитивных типов данных JavaScript:

• number (число)
• string (строка)
• boolean (логическое значение)
• null (специальное значение null)
• undefined (специальное значение undefined)
• symbol (символ, используется в особых случаях, появился в ES6)

Здесь названия типов данных приведены в том виде, в котором их возвращает оператор typeof .

Поговорим о наиболее часто используемых типах данных из этого списка.

Тип number Значения типа number в JavaScript представлены в виде 64-битных чисел двойной точности с плавающей запятой.

В коде числовые литералы представлены в виде целых и дробных чисел в десятичной системе счисления. Для записи чисел можно использовать и другие способы. Например, если в начале числового литерала имеется префикс 0x - он воспринимается как число, записанное в шестнадцатеричной системе счисления. Числа можно записывать и в экспоненциальном представлении (в таких числах можно найти букву e).

Вот примеры записи целых чисел:

10 5354576767321 0xCC // шестнадцатеричное число
Вот дробные числа.

3.14 .1234 5.2e4 //5.2 * 10^4
Числовые литералы (такое поведение характерно и для некоторых других примитивных типов), при попытке обращения к ним как к объектам, автоматически, на время выполнения операции, преобразуются в соответствующие объекты, которые называют «объектными обёртками». В данном случае речь идёт об объектной обёртке Number .

Вот, например, как выглядит попытка обратиться к переменной a , в которую записан числовой литерал, как к объекту, в консоли Google Chrome.

Подсказка по объектной обёртке Number

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

A.toString()
Обратите внимание на двойные скобки после имени метода. Если их не поставить, система не выдаст ошибку, но, вместо ожидаемого вывода, в консоли окажется нечто, совсем не похожее на строковое представление числа 5.

Глобальный объект Number можно использовать в виде конструктора, создавая с его помощью новые числа (правда, в таком виде его практически никогда не используют), им можно пользоваться и как самостоятельной сущностью, не создавая его экземпляры (то есть - некие числа, представляемые с его помощью). Например, его свойство Number.MAX_VALUE содержит максимальное числовое значение, представимое в JavaScript.

Тип string Значения типа string представляют собой последовательности символов. Такие значения задают в виде строковых литералов, заключённых в одинарные или двойные кавычки.

"A string" "Another string"
Строковые значения можно разбивать на несколько частей, используя символ обратной косой черты (backslash).

"A \ string"
Строка может содержать так называемые escape-последовательности, интерпретируемые при выводе строки в консоль. Например, последовательность \n означает символ перевода строки. Символ обратной косой черты можно использовать и для того, чтобы добавлять кавычки в строки, заключённые в такие же кавычки. Экранирование символа кавычки с помощью \ приводит к тому, что система не воспринимает его как специальный символ.

"I\"m a developer"
Строки можно конкатенировать с использованием оператора + .

"A " + "string"

Шаблонные литералы В ES2015 появились так называемые шаблонные литералы, или шаблонные строки. Они представляют собой строки, заключённые в обратные кавычки (`) и обладают некоторыми интересными свойствами.

`a string`
Например, в шаблонные литералы можно подставлять некие значения, являющиеся результатом вычисления JavaScript-выражений.

`a string with ${something}` `a string with ${something+somethingElse}` `a string with ${obj.something()}`
Использование обратных кавычек упрощает многострочную запись строковых литералов:

`a string with ${something}`

Тип boolean В JavaScript есть пара зарезервированных слов, использующихся при работе с логическими значениями - это true (истина), и false (ложь). Операции сравнения, например, такие, как == , === , < , > , возвращают true или false .

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

При этом надо отметить, что там, где ожидается значение true или false , можно использовать и другие значения, которые автоматически расцениваются языком как истинные (truthy) или ложные (falsy).

В частности, ложными значениями являются следующие:

0 -0 NaN undefined null "" //пустая строка
Остальные значения являются истинными.

Тип null В JavaScript имеется специальное значение null , которое указывает на отсутствие значения. Подобные значения используются и в других языках.Тип undefined Значение undefined , записанное в некую переменную, указывает на то, что эта переменная не инициализирована и значение для неё отсутствует.

Это значение автоматически возвращается из функций, результат работы которых не возвращается явно, с использованием ключевого слова return . Если функция принимает некий параметр, который, при её вызове, не указан, он также устанавливается в undefined .

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

Typeof variable === "undefined"

▍Объекты Все значения, не являющиеся примитивными, имеют объектный тип. Речь идёт о функциях, массивах, о том, что мы называем «объектами», и о многих других сущностях. В основе всех этих типов данных лежит тип object , и они, хотя и во многом друг от друга отличаются, имеют и много общего.Выражения Выражения - это фрагменты кода, которые можно обработать и получить на основе проведённых вычислений некое значение. В JavaScript существует несколько категорий выражений.Арифметические выражения В эту категорию попадают выражения, результатом вычисления которых являются числа.

1 / 2 i++ i -= 2 i * 2

Строковые выражения Результатом вычисления таких выражений являются строки.

"A " + "string" "A " += "string"

Первичные выражения В эту категорию попадают литералы, константы, ссылки на идентификаторы.

2 0.02 "something" true false this //контекст выполнения, ссылка на текущий объект undefined i //где i является переменной или константой
Сюда же можно отнести и некоторые ключевые слова и конструкции JavaScript.

Function class function* //генератор yield //команда приостановки/возобновления работы генератора yield* //делегирование другому итератору или генератору async function* //асинхронное функциональное выражение await //организация ожидания выполнения асинхронной функции /pattern/i //регулярное выражение () //группировка

Выражения инициализации массивов и объектов //литерал массива {} //объектный литерал {a: 1, b: 2} {a: {b: 1}} Логические выражения В логических выражениях используются логические операторы, результатом их вычисления оказываются логические значения.

A && b a || b !a

Выражения доступа к свойствам Эти выражения позволяют обращаться к свойствам и методам объектов.

Object.property //обращение к свойству (или методу) объекта object object["property"]

Выражения создания объектов new object() new a(1) new MyRectangle("name", 2, {a: 4}) Выражения объявления функций function() {} function(a, b) { return a * b } (a, b) => a * b a => a * 2 () => { return 2 } Выражения вызова Такие выражения используются для вызова функций или методов объектов.

A.x(2) window.resize()

Работа с объектами Выше мы уже сталкивались с объектами, говоря об объектных литералах, о вызове их методов, о доступе к их свойствам. Здесь мы поговорим об объектах подробнее, в частности, рассмотрим механизм прототипного наследования и использование ключевого слова class .▍Прототипное наследование JavaScript выделяется среди современных языков программирования тем, что поддерживает прототипное наследование. Большинство же объектно-ориентированных языков используют модель наследования, основанную на классах.

У каждого JavaScript-объекта есть особое свойство (__proto__), которое указывает на другой объект, являющийся его прототипом. Объект наследует свойства и методы прототипа.

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

Const car = {}
Или мы создали объект, воспользовавшись конструктором Object .

Const car = new Object()
В любом из этих случаев прототипом объекта car будет Object.prototype .

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

Const list = //или так const list = new Array()
Проверить это можно следующим образом.

Car.__proto__ == Object.prototype //true car.__proto__ == new Object().__proto__ //true list.__proto__ == Object.prototype //false list.__proto__ == Array.prototype //true list.__proto__ == new Array().__proto__ //true
Здесь мы пользовались свойством __proto__ , оно не обязательно должно быть доступно разработчику, но обычно обращаться к нему можно. Надо отметить, что более надёжным способом получить прототип объекта является использование метода getPrototypeOf() глобального объекта Object .

Object.getPrototypeOf(new Object())
Все свойства и методы прототипа доступны объекту, имеющему этот прототип. Вот, например, как выглядит их список для массива.

Подсказка по массиву

Базовым прототипом для всех объектов является Object.prototype .

Array.prototype.__proto__ == Object.prototype
У Object.prototype прототипа нет.

То, что мы видели выше, является примером цепочки прототипов.

При попытке обращения к свойству или методу объекта, если такого свойства или метода у самого объекта нет, их поиск выполняется в его прототипе, потом - в прототипе прототипа, и так - до тех пор, пока искомое будет найдено, или до тех пор, пока цепочка прототипов не кончится.

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

Const car = Object.create(Object.prototype)
Проверить, входит ли некий объект в цепочку прототипов другого объекта, можно с использованием метода isPrototypeOf() .

Const list = Array.prototype.isPrototypeOf(list)

Функции-конструкторы Выше мы создавали новые объекты, пользуясь уже имеющимися в языке функциями-конструкторами (при их вызове используется ключевое слово new). Такие функции можно создавать и самостоятельно. Рассмотрим пример.

Function Person(name) { this.name = name } Person.prototype.hello = function() { console.log(this.name) } let person = new Person("Flavio") person.hello() console.log(Person.prototype.isPrototypeOf(person))
Здесь мы создаём функцию-конструктор. При её вызове создаётся новый объект, на который указывает ключевое слово this в теле конструктора. Мы добавляем в этот объект свойство name и записываем в него то, что передано конструктору. Этот объект возвращается из конструктора автоматически. С помощью функции-конструктора можно создать множество объектов, свойства name которых будут содержать то, что передано при их создании конструктору.

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

▍Классы В стандарте ES6 в JavaScript пришло такое понятие как «класс».

До этого в JavaScript можно было пользоваться лишь вышеописанным механизмом прототипного наследования. Этот механизм непривычно выглядел для программистов, пришедших в JS из других языков. Поэтому в языке и появились классы, которые, по сути, являются «синтаксическим сахаром» для прототипного механизма наследования. То есть, и объекты, созданные традиционным способом, и объекты, созданные с использованием классов, имеют прототипы.

Объявление класса Вот как выглядит объявление класса.

Class Person { constructor(name) { this.name = name } hello() { return "Hello, I am " + this.name + "." } }
У класса есть идентификатор, который можно использовать для создания новых объектов с применением конструкции new ClassIdentifier() .

При создании нового объекта вызывается метод constructor , ему передаются параметры.

В классе можно объявлять методы. В нашем случае hello() - это метод, который могут вызывать все объекты, созданные на основе класса. Вот как выглядит создание нового объекта с использованием класса Person .

Const flavio = new Person("Flavio") flavio.hello()

Наследование, основанное на классах Классы могут расширять другие классы. Объекты, созданные на основе таких классов, будут наследовать и методы исходного класса, и методы, заданные в расширенном классе.

Если класс, расширяющий другой класс (наследник этого класса) имеет метод, имя которого совпадает с тем, который есть у класса-родителя, этот метод имеет преимущество перед исходным.

Class Programmer extends Person { hello() { return super.hello() + " I am a programmer." } } const flavio = new Programmer("Flavio") flavio.hello()
При вызове метода hello() в вышеприведённом примере будет возвращена строка Hello, I am Flavio. I am a programmer .

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

Внутри класса можно обращаться к родительскому классу с использованием ключевого слова super .

Статические методы Методы, описываемые в классе, можно вызывать, обращаясь к объектам, созданным на основе этого класса, но не к самому классу. Статические (static) методы можно вызывать, обращаясь непосредственно к классу.Приватные методы В JavaScript нет встроенного механизма, который позволяет объявлять приватные (частные, закрытые) методы. Это ограничение можно обойти, например, с использованием замыканий.Геттеры и сеттеры В классе можно описывать методы, предваряя их ключевыми словами get или set . Это позволяет создавать так называемые геттеры и сеттеры - функции, которые используются для управления доступом к свойствам объектов, созданных на основе класса. Геттер вызывается при попытке чтения значения псевдо-свойства, а сеттер - при попытке записи в него нового значения.

Class Person { constructor(name) { this.userName = name } set name(value) { this.userName = value } get name() { return this.userName } }

Итоги В этом материале мы поговорили о переменных, о типах данных, о выражениях и о работе с объектами в JavaScript. Темой нашего следующего материала будут функции.

Уважаемые читатели! Если вы уже давно пишете на JS, просим рассказать о том, как вы относитесь к появлению в языке ключевого слова class.

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

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

Примечание : Этот тип данных назван в честь математика Джорджа Буля.

Многие операции в математике дают результаты, которые можно оценить как истинные или ложные:

Больше чем:

• 500 > 100 true
• 1 > 5 false

Меньше чем:

• 200 < 400 true
• 4 < 2 false

• 5 = 5 true
• 500 = 400 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 объявляются с помощью ключевого слова var , например:

После этого можно задать значение переменной:

x = “Sample string”;

Язык JavaScript позволяет создавать переменные «на лету» без их объявления, например:

y = “Second string”;

При этом переменная y будет создана, и в памяти будет отведено для нее место, однако такая практика затрудняет чтение и отладку скрипта.

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

JavaScript поддерживает пять базовых типов данных: Number – числа; String – строки; Boolean – Булев тип; Undefined – неопределенный; Null – пустой. Эти пять типов данных называются базовыми, т.к. на основе их строятся более сложные типы данных. Фактический интерес с точки зрения хранения данных представляют три: числа, строки и логические значения, неопределенный и пустой типы представляют интерес в определенных ситуациях.

Числа

В языке JavaScript численный тип данных включает целые и вещественные числа. Целые числа могут принимать значения от –2 53 до 2 53 , вещественные могут принимать большие значения в пределах ±1.7976 x 10 308 или быть точными в пределах ±2.2250 x 10 -308 .

Числа также могут записываться в экспоненциальной форме.

Для записи целого шестнадцатеричного числа в начале ставится ноль, затем буква x , затем само число, которое может содержать цифры от 0 до 9 и буквы от A до F .

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

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

Специальные числа

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

Еще одним важным специальным значением является NaN – «не число» (not a number). Типичным примером операции, которая возвращает NaN , является деле­ние на ноль. Для определения, является ли значение переменной NaN , используется функция isNaN() , которая возвращает true , если число является действии­тельным (включая бесконечность), и false , если значение переменной NaN .

К специальным числам относятся максимальное и минимальное значения, кото­рые может принимать переменная. Все специальные числа приведены в таблице:

Строки

Строка – это последовательность символов огрниченная двойными или одинарными кавычками.

После создания строки она имеет одно свойство – length , возвращающее длину строки, и большое количество методов:

charAt (index : Number) : String – возвращает символ, находящийся на определенной позиции;

concat ([string1 : String [, … [, stringN : String]]]]) : String – соединяет строки (аналогично оператору «+»);

indexOf (subString : String [, startIndex : Number]) : Number – возвращает номер вхождения подстроки в строку, необязательным параметром является номер символа, с которого начинается поиск. Если подстрока не найдена, возвращается -1 . Поиск выполняется слева направо, для поиска справа налево используется метод lastIndexOf() , который имеет аналогичный синтаксис;

replace (rgExp : RegExp, replaceText : String) : String – выполняет замену регулярного выражения строкой;

split ([ separator : { String | RegExp } [, limit : Number]]) : Array – разбивает строку на массив подстрок. В качестве первого параметра передается разделитель, на основе которого производится разбиение, если разделитель не указан, возвращается массив, содержащий один элемент с исходной строкой. Второй параметр определяет максимальное количество элементов в возвращаемом массиве;

substr (start : Number [, length : Number]) : String – возвращает подстроку, которая начинается с определенной позиции и имеет определенную длину;

substring (start : Number, end : Number) : String – возвращает подстроку, которая начинается и заканчивается в позициях, определенных параметрами.

Булев тип

Переменные булевого типа могут принимать одно из двух значения: true – истина; false – ложь. Переменные булевого типа часто используются в условном операторе if . Пример:

var doAlert = true;

if (doAlert) { alert(“Hello, World!”); }

Переменные типа Undefined и Null

Тип Undefined используется для несуществующих переменных или переменных, значения которых еще не определены. В следующем примере переменная x будет иметь значение Undefined – то есть не определена.

Тип Null означает пустое значение. Пример объявления пустой переменной:

Массивы

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

myArr = “Hello!”;

Объявление пустого массива и массива, содержащего данные:

var emptyArr = ;

var filledArr = ["Hello", "World"];

Массивы могут быть многомерными. Объявление и обращение к многомерному массиву выглядит так:

var myArr = [,,];

//создается массив размером 3х2 и выводится элемент, содержащийся
в третьей строке, во втором столбце, равный 6.

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

Типы данных

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

Специальные значения null и undefined являются элементарными значениями, но они не относятся ни к числам, ни к строкам, ни к логическим значениям. Каждое из них определяет только одно значение своего собственного специального типа.

Любое значение в языке JavaScript, не являющееся числом, строкой, логическим значением или специальным значением null или undefined, является объектом. Объект (т.е. член объектного типа данных) представляет собой коллекцию свойств, каждое из которых имеет имя и значение (либо простого типа, такое как число или строка, либо объектного).

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

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

Функции, которые пишутся для инициализации вновь создаваемых объектов (с оператором new), называются конструкторами . Каждый конструктор определяет класс объектов - множество объектов, инициализируемых этим конструктором. Классы можно представлять как подтипы объектного типа.

В дополнение к классам Array и Function в базовом языке JavaScript определены еще три полезных класса. Класс Date определяет объекты, представляющие даты. Класс RegExp определяет объекты, представляющие регулярные выражения (мощный инструмент сопоставления с шаблоном). А класс Error определяет объекты, представляющие синтаксические ошибки и ошибки времени выполнения, которые могут возникать в программах на языке JavaScript. Имеется возможность определять собственные классы объектов, объявляя соответствующие функции-конструкторы.

Числа

В отличие от многих языков программирования, в JavaScript не делается различий между целыми и вещественными значениями. Все числа в JavaScript представляются вещественными значениями (с плавающей точкой). Для представления чисел в JavaScript используется 64-битный формат, определяемый стандартом IEEE 754 . Этот формат способен представлять числа в диапазоне от ±1,8 x 10 308 до ±5 x 10 -324 .

В JavaScript целые десятичные числа записываются как последовательность цифр. Помимо десятичных целых литералов JavaScript распознает шестнадцатеричные значения. Шестнадцатеричные литералы начинаются с последовательности символов «0x», за которой следует строка шестнадцатеричных цифр. Шестнадцатеричная цифра - это одна из цифр от 0 до 9 или букв от A до F, представляющих значения от 10 до 15:

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

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

Литералы вещественных чисел могут также представляться в экспоненциальной нотации: вещественное число, за которым следует буква e (или E), а затем необязательный знак плюс или минус и целая экспонента. Такая форма записи обозначает вещественное число, умноженное на 10 в степени, определяемой значением экспоненты:

Var a = 16.75; var b = 2e4; // 2 * 10^4 = 20 000

Арифметические операции

Обработка чисел в языке JavaScript выполняется с помощью арифметических операторов. В число таких операторов входят: оператор сложения +, оператор вычитания - , оператор умножения *, оператор деления / и оператор деления по модулю % (возвращает остаток от деления).

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

Math.pow(2,53) // 2 в степени 53 Math.round(.6) // Округление до ближайшего целого (результат 1.0) Math.ceil(.6) // Округление вверх (результат 1.0) Math.floor(.6) // Округление вниз (результат 0) Math.abs(-5) // Модуль числа (результат 5) Math.max(x,y,z) // Возвращает наибольший аргумент Math.min(x,y,z) // Возвращает наименьший аргумент\ Math.random() // Псевдослучайное число x, где 0

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

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

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

Деление на ноль не считается ошибкой в JavaScript: в этом случае просто возвращается бесконечность или отрицательная бесконечность. Однако есть одно исключение: операция деления нуля на ноль не имеет четко определенного значения, поэтому в качестве результата такой операции возвращается специальное значение «не число» (not-a-number), которое обозначается как NaN . Значение NaN возвращается также при попытке разделить бесконечность на бесконечность, извлечь квадратный корень из отрицательного числа или выполнить арифметическую операцию с нечисловыми операндами, которые не могут быть преобразованы в числа.

В JavaScript имеются предопределенные глобальные переменные Infinity и NaN, хранящие значения положительной бесконечности и «не число». В стандарте ECMAScript 3 эти переменные доступны для чтения/записи и могут изменяться в программах. Стандарт ECMAScript 5 исправляет эту оплошность и требует, чтобы эти переменные были доступны только для чтения.

Дата и время

В базовом языке JavaScript имеется конструктор Date() для создания объектов, представляющих дату и время. Эти объекты Date обладают методами для выполнения простых вычислений с участием дат. Объект Date не является фундаментальным типом данных, как числа.

// Несколько версий перегруженного конструктора Date() new Date(); new Date(миллисекунды); new Date(строка_даты); new Date(год, месяц, день, часы, минуты, секунды, мс)

Конструктор Date() без аргументов создает объект Date со значением, равным текущим дате и времени. Если конструктору передается единственный числовой аргумент, он используется как внутреннее числовое представление даты в миллисекундах, аналогичное значению, возвращаемому методом getTime(). Когда передается один строковый аргумент, он рассматривается как строковое представление даты в формате, принимаемом методом Date.parse().

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

Аргументы, передаваемые конструктору Date() Аргумент Обозначение

миллисекунды	Количество миллисекунд между нужной датой и полночью 1 января 1970 года (UTC). Например, передав в качестве аргумента число 5000, мы создадим дату, обозначающую пять секунд после полуночи 1 января 1970 года.
строка_даты	Единственный аргумент, задающий дату и (необязательно) время в виде строки. Строка должна иметь формат, понятный для Date.parse().
год	Год в виде четырех цифр. Например, 2001 для 2001 года. Для совместимости с более ранними реализациями JavaScript к аргументу добавляется 1900, если значение аргумента находится между 0 и 99.
месяц	Месяц, заданный в виде целого от 0 (январь) до 11 (декабрь).
день	День месяца, заданный в виде целого от 1 до 31. Обратите внимание, что наименьшее из значений этого аргумента равно 1, а остальных аргументов - 0. Необязательный аргумент.
часы	Часы, заданные в виде целого от 0 (полночь) до 23 (11 часов вечера). Необязательный аргумент.
минуты	Минуты в часах, указанные в виде целого от 0 до 59. Необязательный аргумент.
секунды	Секунды в минутах, указанные в виде целого от 0 до 59. Необязательный аргумент.
мс	Миллисекунды в секунде, указанные в виде целого от 0 до 999. Необязательный аргумент.

У объекта Date нет доступных для записи или чтения свойств; вместо этого доступ к значениям даты и времени выполняется через методы. Большинство методов объекта Date имеют две формы: одна для работы с локальным временем, другая - с универсальным временем (UTC или GMT). Если в имени метода присутствует строка «UTC», он работает с универсальным временем.

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

Методы объекта Date Метод Описание

getDate(), getUTCDate(), setDate(), setUTCDate()	Возвращает/устанавливает день месяца из объекта Date в соответствии с локальным или универсальным временем.
getDay(), getUTCDay()	Возвращает день недели из объекта Date в соответствии с локальным или универсальным временем.
getFullYear(), getUTCFullYear(), setFullYear(), setUTCFullYear()	Возвращает/устанавливает год даты в полном четырехзначном формате в локальном или универсальном времени.
getHours(), getUTCHours(), setHours(), setUTCHours()	Возвращает/устанавливает поле часов в объекте Date в локальном или универсальном времени.
getMilliseconds(), getUTCMilliseconds(), setMilliseconds(), setUTCMilliseconds()	Возвращает/устанавливает поле миллисекунд в объекте Date в локальном или универсальном времени.
getMinutes(), getUTCMinutes(), setMinutes(), setUTCMinutes()	Возвращает/устанавливает поле минут в объекте Date в локальном или универсальном времени.
getMonth(), getUTCMonth(), setMonth(), setUTCMonth()	Возвращает/устанавливает поле месяца в объекте Date в локальном или универсальном времени.
getSeconds, getUTCSeconds(), setSeconds, setUTCSeconds()	Возвращает/устанавливает поле секунд в объекте Date в локальном или универсальном времени.
getTime(), setTime()	Возвращает/устанавливает внутреннее представление (миллисекунды) объекта Date. Обратите внимание: это значение не зависит от часового пояса, следовательно, отдельный метод getUTCTime() не нужен.
getTimezoneOffset()	Возвращает разницу в минутах между локальным и универсальным представлениями даты в минутах. Обратите внимание: возвращаемое значение зависит от того, действует ли для указанной даты летнее время.
getYear(), setYear()	Возвращает/устанавливает поле года в объекте Date. Признаны устаревшими, рекомендуется вместо них применять методы getFullYear() и setFullYear(). .
toDateString()	Возвращает строку, представляющую дату из Date для локального часового пояса.
toGMTString()	Преобразует Date в строку, беря за основу часовой пояс GMT. Признан устаревшим, вместо него рекомендован метод toUTCString().
toISOString()	Преобразует Date в строку, используя стандарт ISO-8601, объединяющий формат представления даты/времени и UTC.
toJSON()	Сериализует объект Date в формат JSON с помощью метода toISOString().
toLocaleDateString()	Возвращает строку, представляющую дату из Date в локальном часовом поясе в соответствии с локальными соглашениями по форматированию дат.
toLocaleString()	Преобразует Date в строку в соответствии с локальным часовым поясом и локальными соглашениями о форматировании дат.
toLocaleTimeString()	Возвращает строку, представляющую время из Date в локальном часовом поясе на основе локальных соглашений о форматировании времени.
toString()	Преобразует Date в строку в соответствии с локальным часовым поясом.
toTimeString()	Возвращает строку, представляющую время из Date в локальном часовом поясе.
toUTCString()	Преобразует Date в строку, используя универсальное время.
valueOf()	Преобразует объект Date в его внутренний миллисекундный формат.

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

Date.now()

Возвращает текущее время в миллисекундах.

Date.parse()

Анализирует строковое представление даты и времени и возвращает внутреннее представление этой даты в миллисекундах.

Date.UTC()

Возвращает представление указанной даты и времени UTC в миллисекундах.

Объект Date - это тип данных, встроенный в язык JavaScript. Объекты Date создаются с помощью представленного ранее синтаксиса new Date().

После создания объекта Date можно воспользоваться его многочисленными методами. Многие из методов позволяют получать и устанавливать поля года, месяца, дня, часа, минуты, секунды и миллисекунды в соответствии либо с локальным временем, либо с временем UTC (универсальным, или GMT). Метод toString() и его варианты преобразуют даты в понятные для восприятия строки.

getTime() и setTime() преобразуют количество миллисекунд, прошедших с полуночи (GMT) 1 января 1970 года, во внутреннее представление объекта Date и обратно. В этом стандартном миллисекундном формате дата и время представляются одним целым, что делает дату очень простой арифметически. Стандарт ECMAScript требует, чтобы объект Date мог представить любые дату и время с миллисекундной точностью в пределах 100 миллионов дней до и после 01.01.1970. Этот диапазон равен ±273 785 лет, поэтому JavaScript-часы будут правильно работать до 275 755 года.

Примеры использования объекта Date

Известно множество методов, позволяющих работать с созданным объектом Date:

// Получает текущую дату и время d = new Date(); // Показывает дату document.write("Сегодня: " + d.toLocaleDateString() + ". "); // Показывает время document.write("Время: "+ d.toLocaleTimeString()); // День недели var dayOfWeek = d.getDay(); // Сегодня выходной? var weekend = (dayOfWeek == 0) || (dayOfWeek == 6);

Ниже показан простой пример часов, использующих объект Date. Здесь используется метод setTimeout() для обновления часов каждую секунду:

Function timer() { // Находим элемент h1 в документе h1 = document.getElementsByTagName("h1"); // Устанавливаем дату var date = new Date(); var hours = date.getHours(); var minutes = date.getMinutes(); var seconds = date.getSeconds(); if (hours

Разметка страницы довольно простая и подключает функцию timer() в обработчике события onload() элемента body:

Строки

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

В языке JavaScript нет специального типа для представления единственного элемента строки. Для представления единственного 16-битного значения просто используется строка с длиной, равной 1.

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

Var str = ""; // Пустая строка str = "простая строка"; str = "строка с "кавычками" внутри"; str = "В этом строковом литерале\nдве строки";

В ECMAScript 3 строковые литералы должны записываться в одной строке программы и не могут разбиваться на две строки. Однако в ECMAScript 5 строковые литералы можно разбивать на несколько строк, заканчивая каждую строку, кроме последней, символом обратного слеша (\). Ни один из символов обратного слеша, как и следующие за ними символы перевода строки, не будут включены в строковый литерал. Чтобы включить в строковый литерал символ перевода строки, следует использовать последовательность символов \n (как показано выше).

Символ обратного слеша (\) имеет специальное назначение в JavaScript-строках. Вместе с символами, следующими за ним, он обозначает символ, не представимый внутри строки другими способами. Например, \n - это управляющая последовательность (escape sequence) , обозначающая символ перевода строки.

Другой пример - это последовательность \", обозначающая символ одинарной кавычки. Эта управляющая последовательность необходима для включения символа одинарной кавычки в строковый литерал, заключенный в одинарные кавычки. Теперь становится понятно, почему мы называем эти последовательности управляющими - здесь символ обратного слеша позволяет управлять интерпретацией символа одинарной кавычки. Вместо того чтобы отмечать ею конец строки, мы используем ее как апостроф:

Var str = "\"JavaScript\" - интерпретируемый язык программирования";

В таблице ниже перечислены управляющие последовательности JavaScript и обозначаемые ими символы. Две управляющие последовательности являются обобщенными; они могут применяться для представления любого символа путем указания кода символа из набора Latin-1 или Unicode в виде шестнадцатеричного числа. Например, последовательность \xA9 обозначает символ копирайта, который в кодировке Latin-1 имеет шестнадцатеричный код A9. Аналогично управляющая последовательность, начинающаяся с символов \u, обозначает произвольный символ Юникода, заданный четырьмя шестнадцатеричными цифрами. Например, \u03c0 обозначает символ π .

Управляющие последовательности JavaScript Последовательность Представляемый символ

\0	Символ NUL (\u0000)
\b	Обратное перемещение (\u0008)
\t	Горизонтальная табуляция (\u0009)
\n	Перевод строки (\u000A)
\v	Вертикальная табуляция (\u000B)
\f	Перевод страницы (\u000C)
\r	Возврат каретки (\u000D)
\"	Двойная кавычка (\u0022)
\"	Одинарная кавычка (\u0027)
\\	Обратный слеш (\u005C)
\xZZ	Символ Latin-1, заданный двумя шестнадцатеричными цифрами ZZ
\uxZZZZ	Символ Unicode, заданный четырьмя шестнадцатеричными цифрами ZZZZ

Если символ «\» предшествует любому символу, отличному от приведенных в этой таблице, обратный слеш просто игнорируется (хотя будущие версии могут, конечно, определять новые управляющие последовательности). Например, \# - это то же самое, что и #. Наконец, как отмечалось выше, стандарт ECMAScript 5 позволяет добавлять в многострочные строковые литералы символ обратного слеша перед разрывом строки.

Работа со строками

Одной из встроенных возможностей JavaScript является способность конкатенировать строки. Если оператор + применяется к числам, они складываются, а если к строкам - они объединяются, при этом вторая строка добавляется в конец первой. Например:

Var str = "Hello, " + "world!"; // Получается строка Hello, world! // Конкатенация строки с переменной var name = "Александр"; str = "Добро пожаловать, " + name + "!";

Строки в JavaScript представлены объектом String , имеющим один конструктор, в котором передается строка. Когда функция String() вызывается в качестве конструктора (с оператором new), она возвращает объект String, содержащий строку s или строковое представление s. Конструктор String(), вызванный без оператора new, преобразует s в элементарное строковое значение и возвращает преобразованное значение:

New String(s); // Функция-конструктор String(s); // Функция преобразования

Объект String имеет единственное свойство - length , которое возвращает количество символов в строке.

В следующей таблице перечислены методы объекта String:

Методы класса String Метод Описание Пример использования

charAt()	Извлекает из строки символ, находящийся в указанной позиции. Номер первого символа в строке равен нулю.	var str = "Hello, world!"; document.write(str.charAt(4)); // Результат "o"
charCodeAt()	Возвращает код символа, находящегося в указанной позиции. (Код Юникода n-го символа в строке - 16-разрядное целое число между 0 и 65 535.)	var str = "Hello, world!"; document.write(str.charCodeAt(4)); // Результат 111 - код символа "o"
concat()	Выполняет конкатенацию одного или нескольких значений со строкой. concat() преобразует все свои аргументы в строки (если это нужно) и добавляет их по порядку в конец строки. Возвращает полученную объединенную строку.	// Получаем одну строку (new String()).concat("Мы рады ", "приветствовать ", "вас на нашем сайте");
indexOf (подстрока, начало)	Выполняет поиск в строке от начала к концу, чтобы увидеть, содержит ли она искомую подстроку. Поиск начинается с позиции "начало" в строке или с начала строки, если аргумент "начало" не указан. Если подстрока найдена, String.indexOf() возвращает позицию первого символа первого вхождения подстроки в строку. Позиции символов в строке нумеруются с нуля. Если подстрока в строке не найдена, String.indexOf() возвращает -1.	var str = "Hello, world!"; if (str.indexOf("world", 0) != -1) document.write("Подстрока \"world\" найдена в исходной строке.");
lastIndexOf()	Выполняет поиск символа или подстроки в строке с конца.	var str = "Hello, world!"; document.write("Позиция последней буквы "o" в исходной строке: " + + str.lastIndexOf("o")); // Результат 8
localeCompare()	Сравнивает строки с учетом порядка следования символов национальных алфавитов. Возвращает число, обозначающее результат сравнения. Если строка «меньше» целевой строки, localeCompare() возвращает отрицательное число. Если строка «больше» целевой строки, метод возвращает положительное число. Если строки идентичны или неразличимы в соответствии с региональными соглашениями о сортировке, метод возвращает 0. Когда к строкам применяются операторы, сравнение выполняется только по кодам Юникода этих символов; порядок сортировки, принятый в текущем регионе, не учитывается. Сортировка, выполняемая подобным образом, не всегда оказывается верной. Стандарт ECMAScript не определяет, как должно выполняться сравнение с учетом региона; в нем просто указано, что эта функция руководствуется порядком сортировки, определенным операционной системой.	var str1 = "Строка1"; var str2 = "Строка2"; if (str1.localeCompare(str2) != 0) document.write("Строки не идентичны");
match()	Выполняет поиск по шаблону с помощью регулярного выражения.	var str = "1 плюс 2 равно 3".match(/\d+/g); // Вернет массив {"1", "2", "3"}
replace()	Метод replace() выполняет операцию поиска и замены для строки. Он ищет в строке одну или несколько подстрок, соответствующих регулярному выражению и заменяет их. Если в регулярном выражении указан глобальный атрибут «g», replace() заменяет все найденные подстроки. В противном случае метод заменяет только первую найденную подстроку. В стандарте ECMAScript v3 определено, что второй аргумент метода replace() может быть функцией, а не строкой. В этом случае функция будет вызываться для каждого найденного соответствия, а возвращаемая ею строка будет использоваться в качестве текста для замены.	var str = "javascript - интерпретируемый язык программирования."; // Обеспечение правильного регистра букв в слове «JavaScript» str = str.replace(/JavaScript/i, "JavaScript");
search()	Метод search() ищет подстроку в строке, соответствующую регулярному выражению regexp, и возвращает позицию первого символа найденной подстроки или -1, если соответствие не найдено. Метод не выполняет глобального поиска, игнорируя флаг «g». Он также игнорирует свойство regexp.lastIndex и всегда выполняет поиск с начала строки, следовательно, всегда возвращает позицию первого соответствия, найденного в строке.	var str = "JavaScript - интерпретируемый язык программирования."; i = str.search("язык"); // Результат 30 (позиция слова "язык" в исходной строке)
slice()	Метод slice() возвращает строку, содержащую фрагмент, или подстроку строки, но не изменяет строку. Первый аргумент - это индекс в строке, с которого должен начинаться фрагмент. Если этот аргумент отрицателен, он обозначает позицию, измеряемую от конца строки. То есть -1 соответствует последнему символу, -2 - второму с конца и т.д.. Второй аргумент - индекс символа исходной строки непосредственно после конца извлекаемого фрагмента. Если он не указан, фрагмент включает все символы от позиции начало до конца строки. Если этот аргумент отрицателен, он обозначает позицию, отсчитываемую от конца строки.	var str = "абвгдежзик"; str1 = str.slice(0,4); // Вернет "абвг" str2 = str.slice(2,4); // Вернет "вг" str3 = str.slice(4); // Вернет "дежзик" str4 = str.slice(3,-1); // Вернет "гдежзи" str5 = str.slice(3,-2); // Вернет "гдежз" str6 = str.slice(-4,-2); // Вернет "жз"
split()	Разбивает строку на массив строк по указанной строке-разделителю. Метод split() создает и возвращает массив подстрок указанной строки, причем размер возвращаемого массива не превышает указанный лимит (передается во втором аргументе). Эти подстроки создаются путем поиска текста, соответствующего разделителю (первый аргумент), в строке от начала до конца и разбиения строки до и после найденного текста. Ограничивающий текст не включается ни в одну из возвращаемых строк.	// Метод split() наиболее полезен при работе // с сильно структурированными строками var str = "1:2:3:4:5"; str.split(":"); // Вернет ["1","2","3","4","5"] str = "a||b||c"; str.split("||"); // Вернет ["a","b","c"] // Чтобы разбить строку на массив символов, // возьмите в качестве разделителя пустую строку str = "hello"; str.split(""); // Вернет ["h","e","l","l","o"] str.split("",3); // Вернет ["h","e","l"]
substr()	Метод substr() извлекает и возвращает подстроку строки, но не изменяет строку. Обратите внимание: метод substr() задает нужную подстроку с помощью позиции символа и длины. Благодаря этому появляется удобная альтернатива методам String.substring() и String.splice(), в которых подстрока задается двумя символьными позициями. При этом следует отметить, что метод не стандартизован в ECMAScript и, следовательно, считается устаревшим.	var str = "абвгдежзик"; str = str.substr(2,5); // Результат "вгдеж"
substring()	Метод String.substring() возвращает подстроку строки, содержащую символы между позициями от (первый аргумент) и до (второй аргумент). Символ в позиции "от" включается в подстроку, а символ в позиции "до" не включается.	var str = "абвгдежзик"; str = str.substring(2,7); // Результат "вгдеж"
toLowerCase()	Возвращает копию строки, в которой все символы переведены в нижний регистр.	var str = "JavaScript"; str = str.toLowerCase(); // Результат "javascript"
toString()	Возвращает элементарное строковое значение. Вызов этого метода требуется редко. Исключение TypeError генерируется, если метод вызывается для объекта, не являющегося объектом String.
toUpperCase()	Возвращает копию строки, в которой все символы переведены в верхний регистр.	var str = "JavaScript"; str = str.toUpperCase(); // Результат "JAVASCRIPT"
trim()	Возвращает копию строки, из которой удалены все начальные и конечные пробельные символы.
valueOf()	Возвращает элементарное строковое значение (аналогично toString(), используется редко).

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

Поскольку эти методы не стандартизованы, для них отсутствуют отдельные справочные статьи.

Логические значения

Логическое значение говорит об истинности или ложности чего-то. Логический тип данных имеет только два допустимых логических значения. Эти два значения представлены литералами true и false.

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

Это выражение проверяет, равно ли значение переменной a числу 4. Если да, результатом этого сравнения будет логическое значение true. Если значение переменной a не равно 4, результатом сравнения будет false.

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

If (a == 4) { // ... } else { // ... }

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

Undefined null 0 -0 NaN "" // пустая строка

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

Логические значения имеют метод toString(), который можно использовать для преобразования этих значений в строки «true» или «false», но они не имеют других полезных методов.

Значения null и undefined

Ключевое слово null в языке JavaScript имеет специальное назначение и обычно используется для обозначения отсутствия значения. Оператор typeof для значения null возвращает строку «object», что говорит о том, что значение null является специальным «пустым» объектом. Однако на практике значение null обычно считается единственным членом собственного типа и может использоваться как признак отсутствия значения, такого как число, строка или объект. В большинстве других языков программирования имеются значения, аналогичные значению null в JavaScript: вам они могут быть известны как null или nil.

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

Идентификатор undefined является именем предопределенной глобальной переменной (а не ключевым словом, как null), которая инициализирована значением undefined. В ECMAScript 3 undefined является переменной, доступной для чтения/записи, которой можно присвоить любое другое значение. Эта проблема была исправлена в ECMAScript 5, и в реализациях JavaScript, соответствующих этому стандарту, переменная undefined доступна только для чтения. Оператор typeof для значения undefined возвращает строку «undefined», показывающую, что данное значение является единственным членом специального типа.

Несмотря на эти отличия, оба значения, null и undefined, являются признаком отсутствия значения и часто являются взаимозаменяемыми. Оператор равенства == считает их равными. (Чтобы отличать их в программе, можно использовать оператор идентичности ===.) Оба они являются ложными значениями - в логическом контексте они интерпретируются как значение false. Ни null, ни undefined не имеют каких-либо свойств или методов. На практике попытка использовать. или , чтобы обратиться к свойству или методу этих значений, вызывает ошибку TypeError.

Значение undefined можно рассматривать как признак неожиданного или ошибочного отсутствия какого-либо значения, а null - как признак обычного или вполне ожидаемого отсутствия значения . Если в программе потребуется присвоить одно из этих значений переменной или свойству или передать одно из этих значений функции, практически всегда предпочтительнее использовать значение null.

Неизменяемые простые значения и ссылки на изменяемые объекты

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

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

Var str = "простая строка"; str.slice(8,14); console.log(str); // Отобразит "простая строка" // Чтобы явно изменить строку нужно использовать присваивание str = str.slice(8,14); console.log(str); // Отобразит "строка"

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

Объекты отличаются от простых типов. Во-первых, они являются изменяемыми - их значения можно изменять:

Var o = { x:1 }; // Начальное значение объекта o.x = 2; // Изменить, изменив значение свойства o.y = 3; // Изменить, добавив новое свойство var a = ; // Массивы также являются изменяемыми объектами a = 0; // Изменить значение первого элемента массива a = 4; // Добавить новый элемент (индекс 3 соответствует четвертой позиции в массиве)

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

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

Var a = ; // Переменная a ссылается на пустой массив. var b = a; // Теперь b ссылается на тот же массив. b = 1; // Изменение массива с помощью ссылки в переменной b. console.log(a === b); // Вернет "true" console.log("a = " + a); // Изменение объекта b изменяет объект a

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