Всего в JavaScript, существует 6 типов данных :
— Число number ,
— Строка string ,
— Логический (булев) тип данных boolean ,
— Отсутствие значения undefined ,
— Пустота, ничто null ,
— Объект object .

Эти 6 типов данных, делятся на два вида, простые типы данных и составные (объектные) типы данных.

Простые (примитивные) типы данных: number, string, boolean, undefined, null.
Составные (объектные) типы данных: object

Составным типом данных являются: объект, функция, массив (см. в конце статьи).

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

Var имяПеременной; имяПеременной = значение; alert(typeof имяПеременной);

Тип данных: number

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

Var myNumber = 5; var myNumber2 = 5.5;

В JavaScript в числах с плавающей запятой, используются точки, а не запятые 🙂

Alert(typeof myNumber); alert(typeof myNumber2);

В обоих случаях, скрипт выдаст нам сообщение number .

Тип данных: string

String — тип данных строка. Чтобы превратить значение переменной в строку, её нужно обрамить кавычками: дойными «строка» или одинарными ‘строка’. Если число обрамить кавычками, то её тип данных из number превратится в string:

Var myString = "Привет я строка JavaScript"; var myString2 = "5";

Проверяем с помощью оператора typeof, тип данных наших переменных:

Alert(typeof myString); alert(typeof myString2);

В обоих случаях скрипт выдаст нам сообщение string .

Тип данных: boolean

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

Var myBoolean = true; var myBoolean2 = false;

Проверяем с помощью оператора typeof, тип данных наших переменных:

Alert(typeof myBoolean); alert(typeof myBoolean2);

В обоих случаях, скрипт выдаст нам сообщение boolean .

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

Тип данных: undefined

Undefined — тип данных который имеет всего одно значение undefined . Этот тип данных появляется тогда, когда переменная объявлена, но не инициализирована, т.е. когда у переменной (свойства объекта или элемента массива) отсутствует значение.

// Объявили переменную, но не присвоили ей значения var myUndefined; // Проверяем с помощью оператора typeof, тип данных нашей переменной alert(typeof myUndefined);

Функция alert() выдаст нам сообщение undefined .

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

Var myUndefined2 = undefined; alert(typeof myUndefined2);

Если значение undefined обрамить кавычками, то его тип данных из undefined превратится в string.

Тип данных: object

Object — тип данных объект.

Var myObject; myObject = { svoistvo: "znachenie", svoistvo2: "znachenie2", };

Проверяем с помощью оператора typeof, тип данных нашего объекта:

Alert(typeof myObject);

Скрипт выдаст нам сообщение object . Так же оператор typeof, покажет object у массивов и функций (см. ниже).

Тип данных: null

Null — это специальный тип данных обозначающий пустоту (ничего). Null — это специальный пустой объект. Например null может появиться при нажатии на кнопку отмена при использовании функции promt() .

Var myNull = null; alert(typeof myNull);

Данный скрипт выдаст сообщение object , почему так происходит читайте ниже.

Если null обрамить кавычками, то его тип данных из null превратится в string.

Уточнение по работе с оператором typeof

Здесь сообщу о некоторых подводных камнях которые есть в операторе typeof, например при работе с null и с функциями он выдаёт не верный тип данных, что часто путает начинающих. Ниже я составил небольшую табличку, показывающую как работает

Переменные в 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 типы данных можно разделить на две категории: простые (их также называют примитивными) типы и составные (их также называют ссылочными или объекты).

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

Типы данных

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Тип данных Number

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

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

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

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

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

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

Тип данных String

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

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

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

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

Тип данных Null

Нулевой тип (null) содержит единственное специальное значение – null .

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

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

Тип данных Undefined

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

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

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

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

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

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

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

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

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

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

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

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

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

var mySymbol = Symbol();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Console.log(10 + " машин"); // "10 машин". Число неявно преобразуется в строку console.log("7" * "4"); // 28. Обе строки неявно преобразуются в числа

Неявное преобразование - это когда интерпретатор автоматически выполняет преобразование типов, т. е. без участия программиста. Явное преобразование - это когда преобразование выполняет сам программист. Явное преобразование иначе называют приведением типов :

Console.log("7" * "4"); // 28. Неявное преобразование console.log(Number("7") * Number("4")); // 28. Явное преобразование

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

Значение	Преобразование в:
	Строку	Число	Булево	Объект
undefined null	"undefined" "null"	NaN 0	false false	ошибка typeError ошибка typeError
true false	"true" "false"	1 0		new Boolean(true) new Boolean(false)
"" (пустая строка) "1.2" "one" "-10" "+10" "011" "0xff"		0 1.2 NaN -10 10 11 255	false true true true true true true	new String("") new String("1.2") new String("one") new String("-10") new String("+10") new String("011") new String("0xff")
0 -0 NaN Infinity -Infinity 3	"0" "0" "NaN" "Infinity" "-Infinity" "3"		false false false true true true	new Number(0) new Number(-0) new Number(NaN) new Number(Infinity) new Number(-Infinity) new Number(3)
{} (любой объект) (пустой массив) (1 числовой элемент) arr (любой другой массив) function(){} (любая функция)	см. Преобразование объектов "" "9" см. Преобразование объектов см. Преобразование объектов	см. Преобразование объектов 0 9 NaN NaN	true true true true true

Для явного преобразования в простые типы используются следующие функции: Boolean() , Number() , String() . При неявном преобразования интерпретатор использует те же функции, что используются для явного преобразования.

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

X + "" // То же, что и String(x) +x // То же, что и Number(x). Можно также встретить x - 0 !!х // То же, что и Boolean(x)

Преобразование в числа

Функция Number() преобразует значения по следующим правилам:

• Логические значения true и false преобразуются в 1 и 0 соответственно.
• Числа возвращаются без изменения.
• Значение null преобразуется в 0 .
• Значение undefined преобразуется в NaN .

Для строк действуют особые правила:

• Если строка содержит только цифры с начальным знаком + или - либо без знака, она всегда преобразуется в целое десятичное число. Начальные нули игнорируются, например "0011" преобразуется в 11.
• Если строка представляет собой число с плавающей точкой с начальным знаком + или - либо без знака, она преобразуется в соответствующее число с плавающей точкой (начальные нули также игнорируются).
• Если строка представляет собой число в шестнадцатеричном формате, она преобразуется в соответствующее целое десятичное число.
• Если строка пустая, она преобразуется в 0 .
• Если строка содержит что-то отличное от предыдущих вариантов, она преобразуется в NaN .
• Для объектов вызывается метод valueOf() , а возвращаемое им значение автоматически преобразуется по предыдущим правилам. Если это преобразование даёт в результате NaN , вызывается метод toString() и применяются правила преобразования строк в числа.

Унарные операторы + и - работают по тем же правилам, что и функция Number() .

Преобразование в булевы значения

Функция Boolean() преобразует значение в его логический эквивалент:

• Следующие значения в результате преобразования дают значение false: undefined , null , 0 , -0 , NaN , "" .
• Значение false возвращается без изменения.
• Все остальные значения в результате преобразования дают значение true .

Преобразование в строки

Функция String() преобразует значения по следующим правилам:

• Для всех значений кроме null и undefined автоматически вызывается метод toString() и возвращается строковое представление значения.
• Для значения null возвращается строка "null" .
• Для значения undefined возвращается строка "undefined" .

Преобразование простых типов в объекты

Для преобразования простых значений в объекты используются конструкторы Boolean() , Number() , String() :

Var oNum = new Number(3); var oStr = new String("1.2"); var oBool = new Boolean(true); alert(typeof oNum); // "object" alert(typeof oStr); // "object" alert(typeof oBool); // "object"

Преобразование объектов в простые значения

Все объекты наследуют два метода преобразования: toString() и valueOf() .

Метод toString() возвращает строковое представление объекта. По умолчанию он ничего интересного не возвращает:

Alert({x: 1}.toString()); // ""

Некоторые типы имеют более специализированные версии метода toString() . Например, метод toString() у массива преобразует все его элементы в строки и затем объединяет их в одну строку, вставляя запятые между ними:

Alert(.toString()); // "1,2,3"

Задача метода valueOf() определена не так чётко: предполагается, что он должен преобразовать объект в представляющее его простое значение, если такое значение существует. Объекты по своей сути являются составными значениями, и большинство объектов не могут быть представлены в виде единственного простого значения, поэтому по умолчанию метод valueOf() возвращает не простое значение, а ссылку на него:

Alert(typeof {x:2}.valueOf()); // "object"

При преобразовании объекта в строку интерпретатор JavaScript выполняет следующие действия:

• Если объект имеет метод toString() , интерпретатор вызывает его. Если он возвращает простое значение, интерпретатор преобразует значение в строку (если оно не является строкой) и возвращает результат преобразования.
• Если объект не имеет метода toString() или этот метод не возвращает простое значение, то интерпретатор проверяет наличие метода valueOf() . Если этот метод определён, интерпретатор вызывает его. Если он возвращает простое значение, интерпретатор преобразует это значение в строку (если оно не является строкой) и возвращает результат преобразования.

При преобразовании объекта в число интерпретатор выполняет те же действия, но первым пытается применить метод valueOf() :

• Если объект имеет метод valueOf() , возвращающий простое значение, интерпретатор преобразует (при необходимости) это значение в число и возвращает результат.
• Если объект не имеет метода valueOf() или этот метод не возвращает простое значение, то интерпретатор проверяет наличие метода toString() . Если объект имеет метод toString() , возвращающий простое значение, интерпретатор выполняет преобразование и возвращает полученное значение.
• В противном случае интерпретатор делает вывод, что ни toString() ни valueOf() не позволяют получить простое значение и возбуждает ошибку TypeError .

Методы toString() и valueOf() доступны для чтения и записи, поэтому их можно переопределить и явно указать, что будет возвращаться при преобразовании:

Var obj = {}; obj.toString = function() { return "объект"; }; alert("Это " + obj); // "Это объект"

JavaScript или JS (сокращенно) не простой язык и начинающие разработчики узнают об этом не сразу. По началу они узнают азы и все кажется красочным и прекрасным. Заходя чуть глубже, появляются JavaScript массивы, объекты, callback’и и все подобное, что часто выносит мозг.

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

Проверка типа переменной

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

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

Var _comparison = { string: "строка", int: 99, float: 13.555, object: {hello: "привет"}, array: new Array(1, 2, 3) }; // Вернет массив с ключами объекта var _objKeys = Object.keys(_comparison); for(var i = 0; i <= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Результат выполнения кода:

String number number object object

Верно? — Нет, конечно. Есть две проблемы. Каждая из них будет подробно описана и предложено решение.

Первая проблема: float число, выводится как number

Comparison.float не является числом и вместо number должно быть float (число с плавающей точкой).Чтобы это исправить, можно создать функцию с проверкой как в коде ниже.

Var _floatNumber = 9.22; var _notFloatNumber = 9; console.log(isFloat(_floatNumber)); console.log(isFloat(_notFloatNumber)); console.log(isFloat("")); function isFloat(n){ return Number(n) === n && n % 1 !== 0; }

Функция isFloat() выполняет проверку всех значений на числа с плавающей точкой. Сначала проверяется равна ли переменная n числу (Number(n) === n) и если да, то делается еще одна проверка на деление с остатком и если остаток есть, то возвращается булевой (true или false ) результат (n % 1 !== 0).

В примере выше она возвращает true , false и false . Первое значение имеет float тип, второе нет — это обычное число и последнее всего лишь пустая строка, которая не подходит под правила.

Вторая проблема: массив определился как объект

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

Есть несколько способов для проверки переменной на тип массива.

Первый вариант (хороший вариант). Проверяем принадлежность data к массиву с помощью instanceof ().

Var data = new Array("hello", "world"); var isArr = data instanceof Array;

Второй вариант (хороший вариант). Метод Array.isArray() возвращает булевое значение, которе будет зависеть от того является ли переменная массивом или нет ().

Var data = new Array("hello", "world"); var isArr = Array.isArray(data);

Третий вариант (самый лучший, но длинный). Для удобности, вы можете сделать этот способ функцией. Используя Object, мы делаем . Если результат Object.prototype.toString.call(data) не равен значит переменная не массив ().

Var data = new Array("hello", "world"); var isArr = Object.prototype.toString.call(data) == ""; console.log(isArr);

Последний результат в виде удобной функции:

Function isArray(data) { return Object.prototype.toString.call(data) == "" }

Теперь вы можете вызвать функции isArray() и как аргумент задать массив или что-то иное и посмотреть результат.

Послесловие

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

Если у вас остались какие-либо вопросы — пишите их ниже к этому записи. Я буду рад помочь.