JavaScript. Подробное руководство, 6-е издание
вернуться

Флэнаган Дэвид
Шрифт:

Мы уже видели, что строки обладают свойствами и методами:

var s = "hello world!"; // Строка

var word = s.substring.indexOf(" ")+1, s.length); // Использование свойств строки

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

new String(s)
. Этот объект наследует (раздел 6.2.2) строковые методы и используется интерпретатором для доступа к свойствам. После обращения к свойству вновь созданный объект уничтожается. (От реализаций не требуется фактически создавать и уничтожать этот промежуточный объект, но они должны вести себя так, как если бы объект действительно создавался и уничтожался.)

Наличие методов у числовых и логических значений объясняется теми же причинами: при обращении к какому-либо методу создается временный объект вызовом конструктора

Number
или
Boolean
, после чего производится вызов метода этого объекта. Значения
null
и
undefined
не имеют объектов-оберток: любые попытки обратиться к свойствам этих значений будет вызывать ошибку ТуреError.

Рассмотрим следующий фрагмент и подумаем, что происходит при его выполнении:

var s = "test"; // Начальное строковое значение.

s.len = 4; // Установить его свойство.

var t = s.len; // Теперь запросить значение свойства.

В начале этого фрагмента переменная

t
имеет значение
undefined
. Вторая строка создает временный объект
String
, устанавливает его свойство
lеn
равным 4 и затем уничтожает этот объект. Третья строка создает из оригинальной (неизмененной) строки новый объект
String
и пытается прочитать значение свойства
len
. Строки не имеют данного свойства, поэтому выражение возвращает значение
undefined
. Данный фрагмент показывает, что при попытке прочитать значение какого-либо свойства (или вызвать метод) строки числа и логические значения ведут себя подобно объектам. Но если попытаться установить значение свойства, эта попытка будет просто проигнорирована: изменение затронет только временный объект и не будет сохранено.

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

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

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

String, Number
или
Boolean
:

var s = "test", n = 1, b = true; // Строка, число и логическое значение,

var S = new String(s); // Объект String

var N = new Number(n); // Объект Number

var В = new Boolean(b); // Объект Boolean

При необходимости интерпретатор JavaScript обычно автоматически преобразует объекты-обертки, т. е. объекты S, N и В в примере выше, в обертываемые ими простые значения, но они не всегда ведут себя точно так же, как значения s, n и Ь. Оператор равенства

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

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

Между простыми значениями (

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

var s = "hello"; // Изначально имеется некоторый текст из строчных символов

s.toUpperCase; // Вернет "HELLO", но значение s при этом не изменится

s // =>» "hello": оригинальная строка не изменилась

Кроме того, величины простых типов сравниваются по значению: две величины считаются одинаковыми, если они имеют одно и то же значение. Для чисел, логических значений,

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