Типы данных

Типы данных в 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

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

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

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

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

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

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

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

Var x = 16 + "Volvo";

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

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

Var x = "16" + "Volvo";

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

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

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

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

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

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

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

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

Строки в JavaScript

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

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

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

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

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

Числа в JavaScript

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

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

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

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

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

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

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

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

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

Массивы в JavaScript

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

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

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

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

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

Объекты в JavaScript

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

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

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

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

Оператор typeof

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

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

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

Тип undefined

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

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

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

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

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

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

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

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

Null

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

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

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

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

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

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

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

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

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

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

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

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

• string
• number
• boolean
• undefined

typeof "John" // Вернет "string" typeof 3.14 // Вернет "number" typeof true // Вернет "boolean" typeof false // Вернет "boolean" typeof x // Вернет "undefined" (если у переменной x нет значения)

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

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

• function
• object

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

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

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

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

Переменная – это именованный участок памяти, в который можно как сохранить некоторую информацию, так и получить её из неё.

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

// message - имя переменной var message;

При создании переменной ей сразу же можно присвоить значение.

Присвоение переменной значения осуществляется с помощью оператора «=».

// например, создадим переменную email и присвоим ей строку "[email protected]" var email = "[email protected]"; // установим переменной email новое значение email = "[email protected]";

Для того чтобы получить значение переменной достаточно просто обратиться к ней по имени.

// например, выведем в консоль браузера значение переменной email: console.log(email);

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

Var price = 78.55, quantity = 10, message;

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

Var output = "успех"; // переменная имеет строковый тип данных output = 28; // эта же переменная, но уже имеющая тип данных «число» output = true; // эта же переменная, но уже хранящая булевское значение

Значение переменной можно изменять неограниченное количество раз.

// создана переменная age var age; // переменной age присвоено значения 67 age = 67; // переменной age установлено значение «Пенсионный возраст» age = "Пенсионный возраст"; // переменной age установлено число 55 age = 55;

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

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

// создание двух переменных, первая переменная имеет имя phone, вторая - meassage; var phone, message;

Регистр букв в имени переменной имеет значение. Т.е., например, переменная phone и Phone - это две разные переменные.

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

Price = 250.00; // создали переменную и инициализировали её числом 250.00 percent = "20%"; // создали переменную и инициализировали её строкой «20%»

Но создавать, таким образом, переменные не рекомендуется.

Типы данных

В JavaScript типы данных можно разделить на примитивные и объектные.

Переменные, содержащие примитивные типы данных хранят значение явно.

В JavaScript выделяют 5 примитивных типов данных:

• число (number);
• строка (string);
• булевый тип (boolean);
• null;
• undefined.

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

Var x = 77, y = x; x = 55; y; // 77

Переменные, содержащие объект, на самом деле хранят не сам объект, а ссылку на него.

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

// пример 1 (с типом данных «объект») var coord1 = {x: 77, y: 100}, coord2 = coord1; coord1.x = 55; // установим свойству x объекта новое значение coord2.x; // 55, т.к. coord1 и coord2 содержат ссылку на один и тот же объект // пример 2 (с типом данных «массив») var coord1 = , coord2 = coord1; coord1 = 55; // установим элементу с 0 индексом новое значение coord2; // 55, т.к. coord1 и coord2 содержат ссылку на один и тот же объект // пример 3 (с типом данных «дата») var date1 = new Date(2018,00,01), date2 = date1; date2 = date2.setDate(date2.getDate()+7); // увеличим дату на 7 дней date1; // 07.01.2018, т.к. date1 и date2 содержат ссылку на один и тот же объект

Число (number)

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

Var int = 5; // целое число var float = 5.98; // дробное число

Формат представления чисел в JavaScript осуществляется в соответствии со стандартом IEEE 754-2008.

Целые числа в JavaScript можно задавать не только в десятичной системе счисления, но и в восьмеричной (0) или шестнадцатеричной системе счисления (0x) с использованием префиксов, указанных в круглых скобках:

Var int = 010; // 8 int = 055; // 45 int = 0xFF; //255 int = 0xB8; // 184

Записывать числа возможно в экспоненциальной форме :

Var num = 2e3; // экспоненциальная запись числа 2*10^3 (2000) num = 2e-3; // экспоненциальная запись числа 2*10^-3 (0,002) num = 3.2e3; // 3200 num = 1.5e-2; // 0.015

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

• Infinity (положительная бесконечность);
• -Infinity (отрицательная бесконечность);
• NaN (Not a Number – не число).

Специальное значения Infinity означает очень большое положительное число, т.е. число, которое не может быть представлено в JavaScript по причине того, что оно слишком велико.

Специальные значения -Infinity означает наоборот очень большое отрицательное число, т.е. число, которое не может быть представлено JavaScript по причине того, что оно тоже слишком велико.

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

5/0; // Infinity -5/0; // -Infinity Math.pow(10,399); // Infinity (10 в степене 399) Math.pow(10,399); // -Infinity (-10 в степене 399)

Значение NaN возвращается в результате выполнения математических операций, которые JavaScript не может вычислить.

5 - "Hi"; // NaN (от числа 5 отнять строку) 1000 / "20px"; // NaN (число поделить на строку) true * "1rem"; // NaN (логическое значение true умножить на строку)

При этом очень интересным является то, что значение NaN в JavaScript не равно ничему включая себя.

NaN == NaN; // false NaN === NaN; //false

Логический тип данных (Boolean)

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

Var a = true; var b = false;

Строка (String)

Строка (String) – это тип данных, который используется в JavaScript для представления текста.

Строка JavaScript может состоять из 0 или большего количества символов.

В качестве формата строки в JavaScript всегда использутся кодировка Unicode.

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

"JavaScript"; "ECMAScript";

В JavaScript нет разницы между одинарными и двойными кавычками.

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

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

""ECMAScript""; // без экранирования (с использованием одинарных кавычек) "\"ECMAScript\""; // с экранированием

Строка в JavaScript может содержать специальные символы. Например, \n (перевод строки), \t (табуляция), \r (возврат каретки) и др.

"Это предложение.\nА это тоже предложение, но оно будет начинаться с новой линии.";

Со строками можно произовдить операцию сложения (объединения) или другими словами конкатенацию. Для этого используется оператор "+". Сымысл данной операции заключается в присоединении второй строки к концу первой.

"Я люблю " + "JavaScript"; // Я люблю JavaScript

Значение "undefined"

undefined - специальный примитивный тип данных, который имеет одно значение, равное undefined .

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

Var num; // undefined

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

Var obj = {}; // пустой объект obj.prop; // undefined

Значение "null"

null - специальный примитивный тип данных, который имеет одно значение, равное null .

null - это просто специальное значение, которое имеет смысл «ничего» или «неизвестное значение», т.е. оно явно ничего не означает.

Объект (Object)

Объект – это структура данных, состоящая из пар имя-значение.

Создание объекта с помощью нотации литерала объекта осуществляется следующим образом:

{ имя_1: значение_1, имя_2: значение_2, имя_3: значение_3, ... }

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

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

Другими словами, объект - это структура данных, состоящая из свойств и методов.

Var person = { name: "Виталий", age: 27, getAge: function () { return "Возраст: " + this.age; } }

Обращение к свойствам объекта выполняется через точку или посредством скобочной записи.

// выведем значение свойства age в консоль браузера // 1 способ (через точку) console.log(person.age); // 2 способ (с помощью скобок) console.log(person["age"]); // вызовем метод getAge; значение, которое он вернет, выведем в консоль console.log(person.getAge());

Оператор typeof

Оператор typeof используется для получения информации о типе данных выражения в виде строки.

Синтаксис оператора typeof (вариант без круглых скобок):

Typeof выражение

Синтаксис оператора typeof (с использованием круглых скобок):

Typeof(выражение)

Var name, age = 37, email = "[email protected]", isLicense = true, interest: null, lastExperience: { period: "June 2011 - June 2018", place: "ISACA, Moscow", position: "Web designer" }, getExperience: function() { return lastExperience.period + " ("+ lastExperience.position + " - " + lastExperience.place + ")"; }; typeof name; // "undefined" typeof age; // "number" typeof isLicense; // "boolean" typeof interest; // "object" (1) typeof lastExperience; // "object" typeof getExperience; // "function" (2) /* (1) - это ошибка, которая присутствует в языке, начиная с его первой реализации; она не была исправлена в целях сохранения совместимости и это необходимо учитывать, при написании сценариев; null - это примитивный тип данных, он не является объектом */ /* (2) - это очень удобно, что оператор typeof выделяет функции отдельно; но функция в JavaScipt - это тоже объект; в этом легко убедиться если выполнить следующую конструкцию: */ typeof getExperience.__proto__.__proto__ // "object" (прототипом функции является объект)

Константы

С выходом ECMAScript 6 появилось возможность создавать константы. Осуществляется это с помощью ключевого слова const.

Const COLOR_RED = "#ff0000";

Константа – это переменная, значение которой защищено от изменения. Т.е. при попытке поменять значение будет брошена ошибка.

Const COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Uncaught TypeError: Assignment to constant variable.

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

Const COLORS = { red: "#ff0000", green: "#00ff00", blue: "#00ff00" } COLORS = ["#ff0000","#00ff00","#00ff00"]; // Uncaught TypeError: Assignment to constant variable. COLORS.green = "#4caf50";

Важные заметки

null

В JavaScript кроме undefined существует null . Оно означает, что «значение отсутствует». Например, если создать переменную, но не задавать ей значения, то у нее будет значение undefined:

Let a; console.log(a); // undefined

Тут значения не оказалось ненамеренно. Видимо, просто еще не пришло время дать этой переменной значение.

null нужен для явного, намеренного указания, что значения нет. Можно сказать let a = null; . Например, вы попросили пользователя ввести информацию, но он ничего не ввел. В таком случае уместно записать в результат null .

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

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

При сравнении null и undefined нужно быть осторожным:

Typeof null; // "object" (не "null" по историческим причинам) typeof undefined; // "undefined" null === undefined; // false null == undefined; // true null === null; // true null == null; // true !null; // true isNaN(1 + null); //false isNaN(1 + undefined); //true

Сравнение

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

A === b; 12 === 12;

Это сравнение прямое: являются ли эти данные абсолютно идентичными?

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

1 === "1"; // false 1 == "1"; // true true === 1; // false true == 1; // true

Конспект урока

Типизация в JavaScript

JavaScript имеет представление о типах: числах, строках, функциях, логических значениях и так далее. typeof возвращает строку, в которой записан тип:

NaN означает "не число", но тип этого значения - number .

Переменная без значения имеет специальное значение undefined . Тип такой переменной - undefined:

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

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

После того, как компиляция закончена, запускается программа и период, пока она запущена, называется стадией исполнения (run time).

Статически типизированные языки проверяют типы и ищут ошибки типизации на стадии компиляции.

Динамически типизированные языки проверяют типы и ищут ошибки типизации на стадии исполнения.

Иными словами: статическое типизирование означает проверку типов перед запуском программы; динамическое - проверку типов пока программа запущена.

Слабая и сильная типизация

JavaScript часто конвертирует типы автоматически:

JavaScript - это язык со слабой типизацией. У него есть представление о типах, но он расслаблено к ним относится и может оперировать значениями, можно сказать, произвольно. Чем сильнее система типизации, тем строже правила.

Явные конверсии в JavaScript

Опционально

Fun

Транскрипт урока

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

Взгляните на этот код:

Const length = 12; const num = length(54);

Сначала мы создали константу. Помните, что это как давать чему-то название: в нашем случае - числу 12 даётся название length . В следующей строке мы вызываем функцию length и передаём ей аргумент - число 54. Но подождите! length - это не функция! Это всего лишь число. Числа - это не функции, не ящики, которые производят какие-то действия. И JavaScript пожалуется именно на это:

→ node test.js /Users/rakhim/test.js:2 const num = length(-54); ^ TypeError: length is not a function at Object. (/Users/rakhim/test.js:2:13) at Module._compile (module.js:571:32) at Object.Module._extensions..js (module.js:580:10) at Module.load (module.js:488:32) at tryModuleLoad (module.js:447:12) at Function.Module._load (module.js:439:3) at Module.runMain (module.js:605:10) at run (bootstrap_node.js:420:7) at startup (bootstrap_node.js:139:9) at bootstrap_node.js:535:3

Это Ошибка типизации : тип объекта, который вы использовали, неверный. Интерпретатор JavaScript не скажет чем что-то является , но точно скажет чем оно не является . length - это не функция.

Ошибка типизации - это как просить кошку постирать бельё. Возможно, вы хотели попросить об этом вашего друга.

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

typeof - это специальный оператор, который возвращает строку, в которой написан тип.

Typeof 42; // "number" typeof 3.14; // "number" typeof NaN; // "number" typeof "Berry"; // "string" typeof true; // "boolean" typeof false; // "boolean"

42 и 3.14, очевидно, числа, несколько комбинаций букв в кавычках - строка, а true и false - булеан. Всё это - типы в JavaScript - число, строка и булеан.

NaN означает - "не число", но тип NaN - это "число". Да, я знаю. Еще одна странность JavaScript. Такие правила в этом языке.

Типизация полезна. Когда мы попытаемся запустить число, как будто это функция, JavaScript начнёт жаловаться и мы увидим ошибку и починим её. Если бы никакого обозначения типов в JavaScript не было, мы бы сталкивались либо с каким-нибудь аномальным поведением, либо с мистической ошибкой. Вместо чёткого "length - это не функция", мы бы видели что-то вроде "I"m sorry Dave, I"m afraid I can"t do that".

А что, если создать переменную, но не задать ей никакого значения? Какой в этом случае будет тип? Это ни число, ни строка, ничто... Потому что нет значения, правильно?

JavaScript в этом случае кое-что делает в тайне от вас. Переменная без значения на самом деле имеет специальное значение - "undefined". И тип такой переменной называется "undefined".

Let a; console.log(a); // undefined typeof a; // "undefined"

Например, тип number имеет множество потенциальных значений: 1, 2, -10, 69000 и другие числа. А тип undefined только одно - undefined .

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

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

Код, который вы пишите, обычно конвертируется в понятную для запуска компьютером форму. Этот процесс называется компиляцией, а промежуток времени, за который это происходит - "стадией компиляции" или compile time.

После того, как компиляция закончена и программа запущена, начинается отсчёт времени, который называется "стадией исполнения" или run time.

Некоторые языки проверяют типы и ищут ошибки типизации на стадии компиляции. У них статическая типизация.

Другие языки проверяют типы и ищут ошибки типизации на стадии исполнения. Такая типизация - динамическая.

Иными словами: статическая типизация означает проверку типов перед запуском программы, динамическая - проверку типов, когда программа запущена.

C#, C++, Java, Go - статически типизированные языки. Если в одном из этих языков вы создадите число и попытаетесь проводить с ним операции, как с функцией, вы получите ошибку во время компиляции, а программа не станет запускаться - она даже не дойдёт до этой стадии, потому что ошибка типизации будет обнаружена перед исполнением, в период компиляции.

JavaScript, Ruby, PHP - динамически типизированные языки. Как вы видели раньше, если использовать неверную типизацию, ваша программа запустится, а ошибка обнаружится только когда будет исполняться конкретная строчка кода. Здесь типы проверяются в период исполнения.

Вообще-то, в JavaScript обычно нет никакой компиляции, но это тема другого урока.

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

Теперь давайте поговорим о слабой и сильной типизации. Посмотрите на этот JavaScript код:

4 + "7"; // "47" 4 * "7"; // 28 2 + true; // 3 false - 3; // -3

М-да… Это… Ок, что тут происходит? Сложение числа 4 со строкой "7" даёт нам строку "47". JavaScript конвертирует число 4 в строку "4" и конкатенирует две строки - склеивает их друг с другом. JavaScript просто берёт на себя ответственность предположить, что это то, что мы хотели. Глупо обвинять его - чего мы действительно хотели? Складывать число со строкой не имеет никакого смысла. Какой-нибудь другой язык, вроде Ruby или Python просто бы пожаловался и ничего не сделал.

Произведение числа 4 со строкой "7", это, как видите, 28, по мнению JavaScript. В этом случае он сконвертировал строку "7" в число 7 и произвёл обычное умножение.

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

У этой концепции нет ничего общего с динамической и статической типизацией, смысл которых - КОГДА проверять типы. Сильная против слабой - это НАСКОЛЬКО СЕРЬЁЗНО проверять типы.

В отличие от динамичности-статичности, сила типизации это спектр. У PHP типизация немного сильнее. У Python ещё сильнее. И все они динамически типизированные языки.

JavaScript делает множество неявных конверсий, но он так же даёт нам инструменты, чтобы мы могли делать явные конверсии сами. Мы можем конвертировать строки в числа, числа в строки, булевы в строки и так далее:

Number("590"); // 590 Number("aaa!!"); // NaN Boolean(1); // true Boolean(0); // false String(true); // "true" String(false); // "false" String(44843); // "44843"

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

The typeof operator returns a string indicating the type of the unevaluated operand.

The source for this interactive example is stored in a GitHub repository. If you"d like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

Syntax

The typeof operator is followed by its operand:

Typeof operand typeof(operand )

Parameters

operand An expression representing the object or whose type is to be returned.

Description

The following table summarizes the possible return values of typeof . For more information about types and primitives, see also the JavaScript data structure page.

Type	Result
	"undefined"
Null	"object" (see )
Boolean	"boolean"
Number	"number"
BigInt	"bigint"
String	"string"
Symbol (new in ECMAScript 2015)	"symbol"
Host object (provided by the JS environment)	Implementation-dependent
Function object (implements [] in ECMA-262 terms)	"function"
Any other object	"object"

Examples

// Numbers typeof 37 === "number"; typeof 3.14 === "number"; typeof(42) === "number"; typeof Math.LN2 === "number"; typeof Infinity === "number"; typeof NaN === "number"; // Despite being "Not-A-Number" typeof Number("1") === "number"; // Number tries to parse things into numbers typeof Number("shoe") === "number"; // including values that cannot be type coerced to a number typeof 42n === "bigint"; // Strings typeof "" === "string"; typeof "bla" === "string"; typeof `template literal` === "string"; typeof "1" === "string"; // note that a number within a string is still typeof string typeof (typeof 1) === "string"; // typeof always returns a string typeof String(1) === "string"; // String converts anything into a string, safer than toString // Booleans typeof true === "boolean"; typeof false === "boolean"; typeof Boolean(1) === "boolean"; // Boolean() will convert values based on if they"re truthy or falsy typeof !!(1) === "boolean"; // two calls of the ! (logical NOT) operator are equivalent to Boolean() // Symbols typeof Symbol() === "symbol" typeof Symbol("foo") === "symbol" typeof Symbol.iterator === "symbol" // Undefined typeof undefined === "undefined"; typeof declaredButUndefinedVariable === "undefined"; typeof undeclaredVariable === "undefined"; // Objects typeof {a: 1} === "object"; // use Array.isArray or Object.prototype.toString.call // to differentiate regular objects from arrays typeof === "object"; typeof new Date() === "object"; typeof /regex/ === "object"; // See Regular expressions section for historical results // The following are confusing, dangerous, and wasteful. Avoid them. typeof new Boolean(true) === "object"; typeof new Number(1) === "object"; typeof new String("abc") === "object"; // Functions typeof function() {} === "function"; typeof class C {} === "function"; typeof Math.sin === "function";

Additional information

null

// This stands since the beginning of JavaScript typeof null === "object";

In the first implementation of JavaScript, JavaScript values were represented as a type tag and a value. The type tag for objects was 0. null was represented as the NULL pointer (0x00 in most platforms). Consequently, null had 0 as type tag, hence the "object" typeof return value. (reference)

A fix was proposed for ECMAScript (via an opt-in), but was rejected . It would have resulted in typeof null === "null" .

Using new operator

// All constructor functions, with the exception of the Function constructor, will always be typeof "object" var str = new String("String"); var num = new Number(100); typeof str; // It will return "object" typeof num; // It will return "object" var func = new Function(); typeof func; // It will return "function"

Need for parentheses in Syntax

// Parentheses can be used for determining the data type of expressions. var iData = 99; typeof iData + " Wisen"; // "number Wisen" typeof (iData + " Wisen"); // "string"

Regular expressions

Callable regular expressions were a non-standard addition in some browsers.

Typeof /s/ === "function"; // Chrome 1-12 Non-conform to ECMAScript 5.1 typeof /s/ === "object"; // Firefox 5+ Conform to ECMAScript 5.1

Errors

Before ECMAScript 2015, typeof was always guaranteed to return a string for any operand it was supplied with. Even with undeclared identifiers, typeof will return "undefined" . Using typeof could never generate an error.

But with the addition of block-scoped let and Statements/const using typeof on let and const variables (or using typeof on a class) in a block before they are declared will throw a ReferenceError . Block scoped variables are in a "temporal dead zone " from the start of the block until the initialization is processed, during which, it will throw an error if accessed.

Typeof undeclaredVariable === "undefined"; typeof newLetVariable; // ReferenceError typeof newConstVariable; // ReferenceError typeof newClass; // ReferenceError let newLetVariable; const newConstVariable = "hello"; class newClass{};

Exceptions

All current browsers expose a non-standard host object document.all with type undefined .

Typeof document.all === "undefined";

Although the specification allows custom type tags for non-standard exotic objects, it requires those type tags to be different from the predefined ones. The case of document.all having type "undefined" is classified in the web standards as a "willful violation" of the original ECMA JavaScript standard.

Specifications

Specification	Status	Comment
ECMAScript Latest Draft (ECMA-262)	Draft
ECMAScript 2015 (6th Edition, ECMA-262) The definition of "The typeof Operator" in that specification.	Standard
ECMAScript 5.1 (ECMA-262) The definition of "The typeof Operator" in that specification.	Standard
ECMAScript 3rd Edition (ECMA-262) The definition of "The typeof Operator" in that specification.	Standard
ECMAScript 1st Edition (ECMA-262) The definition of "The typeof Operator" in that specification.	Standard	Initial definition. Implemented in JavaScript 1.1.

Browser compatibility

The compatibility table on this page is generated from structured data. If you"d like to contribute to the data, please check out https://github.com/mdn/browser-compat-data and send us a pull request.

Update compatibility data on GitHub

	Desktop						Mobile						Server
	Chrome	Edge	Firefox	Internet Explorer	Opera	Safari	Android webview	Chrome for Android	Firefox for Android	Opera for Android	Safari on iOS	Samsung Internet	Node.js
typeof	Chrome Full support Yes	Edge Full support 12	Firefox Full support 1	IE Full support Yes	Opera Full support Yes	Safari Full support Yes	WebView Android Full support Yes	Chrome Android Full support Yes	Firefox Android Full support 4	Opera Android Full support Yes	Safari iOS Full support Yes	Samsung Internet Android Full support Yes	nodejs Full support Yes