Приведение типы данных в javascript. JavaScript: Преобразование типов данных

Facebook

JavaScript предоставляет несколько встроенных типов данных. В дополнение к ним эта статья рассматривает виртуальные типы в jQuery такие как селекторы, расширенные псевдотипы как события, а также все виды функций.

Лучше если вы попробуете большинство примеров, изложенных ниже. Это можно легко сделать, просто скопировав эти примеры в консоль Firebug — расширения браузера Firefox.

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

Var x = "" if (x) console.log("x defaulted to true") else console.log("x defaulted to false")

В этом случае напечатается "x приравнивается к false".

Для уменьшения объема примеров используется оператор отрицания, чтобы показать булевский контекст:

X // true

Типы данных в jQuery

Строки
- Встроенные методы для строк
- Свойство length
- Булевский контекст
Числа
- Булевский контекст
- Parsing Numbers
- Numbers to Strings
- NaN and Infinity
- Integer
- Float
Булевский тип
Объекты
- Dot Notation
- Array Notation
- Iteration
- Boolean default
- Prototype
Options
Массивы
- Iteration
- Boolean Default
- Array Notation
Функции
- Аргументы
- Context, Call and Apply
- Область видимости
- Closures
- Proxy Pattern
Callback-функции
Селекторы
События
Элементы
jQuery-тип
Тип XMLHttpRequest

Строки

"Это строка JavaScript!" "И это тоже строка!"

Строка в JavaScript — это неизменяемый объект, который содержит ни одного, один или несколько символов.

Типом строк является "string". Узнать тип строки можно так:

Typeof "some string"; // "string"

Использование кавычек в строках

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

"You make "me" sad." "Holy "cranking" moses!" "Главная" "Главная"

Встроенные методы для строк

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

"hello".charAt(0) // "h" - получение символа в нужной позиции строки "hello".toUpperCase() // "HELLO" - преобразование строки в верхний регистр "Hello".toLowerCase() // "hello" - преобразование строки в нижний регистр "hello".replace(/e|o/g, "x") // "hxllx" - замена части строки на подстроку по шаблону регулярного выражения "1,2,3".split(",") // ["1", "2", "3"] - разбиение строки на массив по определенной подстроке

Свойство length

Строки имеют свойство length, которое определяет длину строки.

"Hello".length // 5 "".length // 0

Булевский контекст

Пустая строка приравнивается к значению false:

!"" // true !"hello" // false !"true" // false !new Boolean(false) // false

Числа

12 3.543

Числа в JavaScript имеют 64-битный формат двойной точности по стандарту IEEE 754. Они также являются неизменяемыми. Для работы с числами доступны все операторы, такие же как в языке C (+, -, *, /, %, =, +=, -=, *=, /=, ++, --).

Типом для чисел является "number". Проверить тип чисел можно так:

Typeof 12 // "number" typeof 3.543 // "number"

Булевский контекст

Если число равно нулю, то оно приравнивается к false:

0 // true !1 // false !-1 // false

Из-за того, что числа реализованы в формате с двойной точностью, результат следующего примера не является ошибочным:

0.1 + 0.2 // 0.30000000000000004

Объект Math

JavaScript предоставляет функции для работы с числами в объекте Math:

Math.PI // 3.141592653589793 Math.cos(Math.PI) // -1

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

Функции parseInt и parseFloat преобразуют строки в числа. И та, и другая функция выполняет неявное преобразование, если не указана система счисления:

ParseInt("123") = 123 (неявное преобразование десятичного числа) parseInt("010") = 8 (невяное преобразование восьмеричного числа) parseInt("0xCAFE") = 51966 (неявное преобразование шестнадцатеричного числа) parseInt("010", 10) = 10 (явное преобразование десятичного числа с указанием системы счисления 10) parseInt("11", 2) = 3 (явное преобразование двоичного числа) parseFloat("10.10") = 10.1

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

Если добавлять числа к строке с помощью операции "+", то результатом всегда будет строка. Чтобы произвести вычисления и только потом добавить число к строке, не забудьте заключить вычисления в круглые скобки:

"" + 1 + 2; // "12" "" + (1 + 2); // "3" "" + 0.0000001; // "1e-7" parseInt(0.0000001); // 1 (обратите внимание!)

Вы также можете использовать JavaScript-класс String, который преобразует переданное значение в строку:

String(1) + String(2); // "12" String(1 + 2); // "3"

Типы NaN и Infinity

Преобразование значений, которые не являются числами, приводит к результату NaN. Функция isNaN определяет, равно ли переданное в неё значение NaN:

ParseInt("hello", 10) // NaN isNaN(parseInt("hello", 10)) // true

Деление на ноль дает в качестве результата бесконечность (Infinity):

1 / 0 // Infinity

И значение NaN и Infinity имеют тип "number":

Typeof NaN // "number" typeof Infinity // "number"

Обратите внимание, что сравнение значений NaN происходит нестандартным способом:

NaN == NaN // false (!)

Infinity == Infinity // true

Тип Integer

Integer — целочисленный тип.

Тип Float

Float — тип чисел с плавающей точкой.

Булевский тип (Boolean)

Булевский тип в JavaScript может принимать значение true или false:

If (true) console.log("always!") if (false) console.log("never!")

Например, булевский тип выглядит следующим образом при задании настроек при подключении плагинов jQuery:

$("...").somePlugin({ hideOnStartup: true, onlyOnce: false });

Объекты

Всё в JavaScript является объектом. Самый простой способ создать объект:

Var x = {}; var y = { name: "Pete", age: 15 };

Типом для объектов является "object":

Typeof {} // "object"

Свойства объекта

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

Y.name // "Pete" y.age // 15 x.name = y.name + " Pan" // "Pete Pan" x.age = y.age + 1 // 16

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

Var operations = { increase: "++", decrease: "--" } var operation = "increase"; operations // "++"; operations["multiply"] = "*"; // "*"

Итерации у объектов

Итерирование над объектами осуществляется очень легко с помощью оператора цикла for-in:

Var obj = { name: "Pete", age: 15 }; for(key in obj) { alert("key is "++", value is "+obj); }

jQuery предоставляет функцию

для итерираций по свойствам объектов или элементам массивов:

JQuery.each(obj, function(key, value) { console.log("key", key, "value", value); });

Булевский контекст

Объект, независимо от того, имеет ли он свойства или нет, всегда имеет значение true:

!{} // false

Прототипы

Все объекты имеют свойство prototype . Всякий раз, когда интерпретатор ищет какое-либо свойства у объекта, он также проверяет его прототип. В jQuery этот механизм широко используется для добавления методов к экземплярам объектов jQuery.

Var form = $("#myform"); form.clearForm; // undefined form.fn.clearForm = function() { return this.find(":input").each(function() { this.value = ""; }).end(); }; form.clearForm() // может быть применено ко всем экземплярам объектов jQuery, так как новый метод был добавлен к прототипу

JavaScript – нетипизированный язык (точнее, слабо типизированный или динамически типизированный). Это значит, что мы не должны задавать тип переменной при ее объявлении. Нетипизированность придает JavaScript гибкость и простоту, предпочтительную для языка сценариев (хотя эти особенности достаются ценой отсутствия строгости, важной для длинных и более сложных программ, которые часто пишутся на более строгих языках, таких как C или Java). Важной чертой гибкой работы с типами данных в JavaScript являются выполняемые интерпретатором автоматические преобразования данных. Например, если методу document.write() передается число, JavaScript автоматически преобразует его в эквивалентное строковое представление. Аналогично, проверяя строковое значение в условии инструкции if, JavaScript автоматически преобразует эту строку в логическое значение – в false, если строка пуста, и в true в противном случае.

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

Объект в строковом контексте преобразуется в строку. Cтроку в числовом контексте JavaScript пытается преобразовать в число.

Преобразования «объект-элементарный тип»
Например, в логическом контексте все приведенные ниже объекты преобразуются в true:

New Boolean(false) // Внутреннее значение равно false, но объект
// преобразуется в true
new Number(0)
new String("")
new Array()

Преобразование объектов в числа начинается с вызова метода valueOf() этого объекта. Большинство объектов наследуют стандартный метод valueOf() класса Object, который просто возвращает сам объект. Так как стандартный метод valueOf() не возвращает элементарного значения, JavaScript затем пытается преобразовать объект в число путем вызова его метода toString() и преобразования полученной строки в число. Для массивов это приводит к интересным результатам. Вспомните, что метод toString()преобразует элементы массива в строки, а затем возвращает результат конкатенации этих строк с запятыми между ними. Следовательно, массив без элементов преобразуется в пустую строку, которая преобразуется в 0! Кроме того, если массив состоит из одного элемента, числа n, то массив преобразуется в строковое представление этого числа, которое затем преобразуется обратно в само число n.

Если массив содержит более одного элемента, или если его единственный элемент не является числом, массив преобразуется в NaN. В JavaScript контекст не всегда определяется однозначно! Оператор + и операторы сравнения (и >=) работают как с числами, так и со строками, поэтому когда объект используется с одним из этих операторов, неясно, во что он должен преобразовываться – в число или в строку. В большинстве случаев JavaScript сначала пытается преобразовать объект путем вызова метода valueOf(). Если этот метод возвращает элементарное значение (обычно число), используется это значение. Однако часто valueOf() просто возвращает объект без преобразования; в этом случае JavaScript затем пытается преобразовать объект в строку с помощью вызова метода toString(). Имеется только одно исключение из этого правила преобразования: когда объект Date используется с оператором +, преобразование выполняется с помощью метода toString(). Существование этого исключения обусловлено тем, что Date имеет как метод toString(), так и метод valueOf(). При использовании Date с оператором + почти всегда требуется выполнить строковую конкатенацию. Но когда Date участвует в операциях сравнения, почти всегда требуется выполнить числовое сравнение, для того чтобы определить, какой из двух моментов времени предшествовал другому.

Большинство объектов либо не имеют метода valueOf(), либо этот метод не возвращает полезных результатов.

Когда к объекту применяется оператор +, обычно имеет место строковая конкатенация, а не сложение. Когда к объекту применяется оператор сравнения, обычно выполняется строковое сравнение, а не числовое.

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

И наконец, помните, что метод valueOf() не называется toNumber(), строго говоря, его задача состоит в преобразовании объекта в осмысленное элементарное значение, поэтому некоторые объекты могут иметь методы valueOf(), возвращающие строки.

Явные преобразования типов
Java-Script не определяет оператор преобразования, как в языках C, C++ и Java, но предоставляет сходные средства. В JavaScript 1.1 (и в стандарте ECMA-262) Number(), Boolean(), String() и Object() могут вызываться не только как конструкторы, но и как функции. Будучи вызваны таким образом, эти функции пытаются преобразовать свои
аргументы в соответствующий тип. Например, вы можете преобразовать любое значение x в строку с помощью String(x) и любое значение y в объект с помощью Object(y).

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

Var x_as_string = x + "";

Чтобы преобразовать значение в число, вычтите из него ноль:

Var x_as_number = x - 0;

Принудительно преобразовать какое-либо значение в логическое можно с помощью оператора!, примененного дважды:

Var x_as_boolean = !!x;

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

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

Var string_value = String(number); // Использование конструктора String()
// в качестве функции
var string_value = number + ""; // Конкатенация с пустой строкой

Еще одну возможность предоставляет метод toString():

String_value = number.toString();

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

Var n = 17;
binary_string = n.toString(2); // Равно "10001"
octal_string = "0" + n.toString(8); // Равно "021"
hex_string = "0x" + n.toString(16); // Равно "0x11"

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

ECMAScript v3 и JavaScript 1.5 обходят это препятствие, добавляя в класс Number три новых метода преобразования числа в строку. Метод toFixed() преобразует число в строку и выводит указанное количество цифр после десятичной точки, не используя экспоненциальной нотации. Метод toExponential() преобразует число в строку, записывая его в экспоненциальной нотации с одной цифрой перед десятичной точкой и указанным количеством цифр после нее. Метод toPrecision() выводит число с помощью указанного количества значащих цифр. Если такого количества значащих цифр недостаточно для вывода целой части числа, оно записывается в экспоненциальной нотации. Обратите внимание, что все три метода корректно округляютфинальные цифры результирующей строки. Посмотрите на следующие примеры:

Var n = 123456.789;
n.toFixed(0); // "123457"
n.toFixed(2); // "123456.79"
n.toExponential(1); // "1.2e+5"
n.toExponential(3); // "1.235e+5"
n.toPrecision(4); // "1.235e+5"
n.toPrecision(7); // "123456.8"

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

Var number = Number(string_value);
var number = string_value - 0;

Такое преобразование неудобно из-за своей излишней строгости. Оно работает только с десятичными числами, и хотя преобразование допускает ведущие и замыкающие пробелы, оно не допускает наличия в строке каких-либо непробельных символов после числа. Для более гибких преобразований можно применять функции parseInt() и parseFloat(). Эти функции преобразуют и возвращают любое число, присутствующее в начале строки, игнорируя любые замыкающие нечисловые символы. Функция parseInt() обрабатывает только целые, а parseFloat() – как целые числа, так и числа с плавающей точкой. Если строка начинается с «0x» или «0X», parseInt() интерпретирует ее как шестнадцатеричное число. Например:

ParseInt("3 blind mice"); // Возвращает 3
parseFloat("3.14 meters"); // Возвращает 3.14
parseInt("12.34"); // Возвращает 12
parseInt("0xFF"); // Возвращает 255

Функция parseInt() может иметь второй аргумент, указывающий основание системы счисления обрабатываемого числа. Допустимые значения – от 2 до 36. Например:

ParseInt("11", 2); // Возвращает 3 (1*2 + 1)
parseInt("ff", 16); // Возвращает 255 (15*16 + 15)
parseInt("zz", 36); // Возвращает 1295 (35*36 + 35)
parseInt("077", 8); // Возвращает 63 (7*8 + 7)
parseInt("077", 10); // Возвращает 77 (7*10 + 7)

Если parseInt() и parseFloat() не могут преобразовать указанную строку в число, они возвращают NaN.

ParseInt("eleven"); // Возвращает NaN
parseFloat("$72.47"); // Возвращает NaN

В JavaScript существуют 2 встроенные функции для преобразования строк в числа: parseFloat() и parseInt() .

parseFloat() принимает аргументом строку, которую необходимо привести к численному типу, и возвращает число типа float. Число должно содержаться в начале строки. Если после числа в строке идут ещё какие-то символы, то они отсекаются. Дробная часть числа должна быть записана через точку (запятая не воспринимается как разделитель). В случае, если parseFloat() не может преобразовать строку, то она возвращает NaN.

Также функция может обработать «число n, умноженное на 10 в степени x», которое в программировании принято записывать через букву E, например: 0.5E6 или 0.5E+6. Степень может быть также отрицательная: 0.5E-6, что равно 0.5*10^-6 или 0.5/1000000.

ParseFloat(""3.78kg"") // 3.78 parseFloat(""kg33"") // NaN parseFloat(""0004.111"") // 4.111 parseFloat(""0x66"") // 0 parseFloat("".5"") // 0.5 parseFloat(""-.5"") // -0.5 parseFloat(""0.5e6"") // 500000 parseFloat(""0.03E+2"") // 3 parseFloat(""3E-4"") // 0.0003 parseFloat(""-3E-4"") // -0.0003

Функция parseInt(string[, radix]) принимает в качестве первого аргумента строку, анализирует её и возвращает целое число (тип integer). Функция пытается анализировать систему счисления, в которой записано число в исходной строке (например, десятичная, восьмеричная или шестнадцатеричная — но не только эти). Также систему счисления можно указать явно, передав её вторым параметром radix. Параметр radix может принимать любое число от 2 до 36 (в системах выше 10-й используются буквы английского алфавита, от A до Z).

Числа типа 1.5e6 функция не обрабатывает так, как parseFloat() .

Ознакомьтесь, пожалуйста, с примерами ниже, чтобы не наколоться на подводные камни, запрятаны в работе функции parseInt() .

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045"",10) // 45 parseInt(""70"",8) // 56 (70 в восьмеричной системе это 56 в десятичной) parseInt(""070"") // 56 (ВАЖНО!!! нуль вначале заставит функцию проанализировать строку как восьмеричное число) parseInt(""88"",8) // NaN (в восьмеричной системе нет цифры 8) parseInt(""a1"") // NaN (ВАЖНО!!! Функция по умолчанию не воспринимает число как 16-ричное, если не дописать в начале строки 0x) parseInt(""a1"",16) // 161 (здесь явно указана система счисления) parseInt(""0xa1"") // 161 (правильный формат 16-ричного числа, можно не указывать второй параметр) parseInt(""099"") // 0 (ВАЖНО!!! Число воспринимается как восьмеричное, но содержащее недопустимые символы) parseInt(""0.5e6"") // 0 (ВАЖНО!!! не работает как parseFloat) parseInt(""ZZ"",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF"",16) // -255

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

В JavaScript существуют 2 встроенные функции для преобразования строк в числа: parseFloat() и parseInt() .

Числа типа 1.5e6 функция не обрабатывает так, как parseFloat() .

В 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. JavaScript: Преобразование типов данных

Типы данных в jQuery

Строки

Использование кавычек в строках

Встроенные методы для строк

Свойство length

Булевский контекст

Числа

Булевский контекст

Объект Math

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

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

Типы NaN и Infinity

Тип Integer

Тип Float

Булевский тип (Boolean)

Объекты

Свойства объекта

Итерации у объектов

Булевский контекст

Прототипы

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

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

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

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

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

Популярные статьи

Последние статьи

Разделы

Страницы

Спецпроекты

Контакты