Типы данных

Веб-программирование --- JavaScript --- Типы данных

Типы данных в 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³⁰⁸ до ±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 <= x < 1.0
Math.PI                   // Длина окружности (3.1415)
Math.E                    // Основание натурального логарифма (2.71)
Math.sqrt(3)              // Корень квадратный из 3
Math.pow(3, 1/3)          // Корень кубический из 3
Math.sin(0)               // Тригонометрия: имеются также Math.cos, Math.atan и другие    
Math.log(10)              // Натуральный логарифм 10
Math.log(100)/Math.LN10   // Логарифм 100 по основанию 10 (десятичный)
Math.log(512)/Math.LN2    // Логарифм 512 по основанию 2
Math.exp(3)               // Math.E в кубе

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

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

В дополнение к перечисленным методам экземпляра в объекте 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')[0];
	
	// Устанавливаем дату
	var date = new Date();
	
	var hours = date.getHours();
	var minutes = date.getMinutes();
	var seconds = date.getSeconds();
	
	if (hours < 10) hours = "0" + hours;	   // Для удобства отображения
	if (minutes < 10) minutes = "0" + minutes;
	if (seconds < 10) seconds = "0" + seconds;
	
	h1.innerHTML = hours + ":" + minutes + ":" + seconds;
	
	// Вызываем функцию раз в одну секунду
	setTimeout('timer()', 1000);
}

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

<body onload="timer()">
<h1></h1>

</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 обозначает символ π.

Если символ «\» предшествует любому символу, отличному от приведенных в этой таблице, обратный слеш просто игнорируется (хотя будущие версии могут, конечно, определять новые управляющие последовательности). Например, \# - это то же самое, что и #. Наконец, как отмечалось выше, стандарт 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:

var str = 'Hello, world!';
document.write(str.charAt(4));     // Результат 'o'

var str = 'Hello, world!';
document.write(str.charCodeAt(4));     // Результат 111 - код символа 'o'

// Получаем одну строку
(new String()).concat('Мы рады ', 'приветствовать ', 'вас на нашем сайте');

var str = 'Hello, world!';

if (str.indexOf('world', 0) != -1)
   document.write('Подстрока \'world\' найдена в исходной строке.');

var str = 'Hello, world!';

document.write('Позиция последней буквы "o" в исходной строке: ' + 
       + str.lastIndexOf('o'));     // Результат 8

var str1 = 'Строка1';
var str2 = 'Строка2';

if (str1.localeCompare(str2) != 0)
    document.write('Строки не идентичны');

var str = '1 плюс 2 равно 3'.match(/\d+/g);    // Вернет массив {'1', '2', '3'}

var str =  'javascript - интерпретируемый язык программирования.';

// Обеспечение правильного регистра букв в слове «JavaScript»
str = str.replace(/JavaScript/i, "JavaScript");

var str =  'JavaScript - интерпретируемый язык программирования.';

i = str.search('язык');     // Результат 30 (позиция слова 'язык' в исходной строке)

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() наиболее полезен при работе
// с сильно структурированными строками
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"]

var str =  'абвгдежзик';
str = str.substr(2,5);    // Результат 'вгдеж'

var str =  'абвгдежзик';
str = str.substring(2,7);    // Результат 'вгдеж'

var str =  'JavaScript';
str = str.toLowerCase();     // Результат 'javascript'

var str =  'JavaScript';
str = str.toUpperCase();     // Результат 'JAVASCRIPT'

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

var str =  'щелкни здесь!';
var a_href = str.bold().fontcolor('green').link('JavaScript:alert("Привет!")');

document.write(a_href);

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

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

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

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

a == 4;

Это выражение проверяет, равно ли значение переменной 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 = [1,2,3];	// Массивы также являются изменяемыми объектами 
a[0] = 0;		// Изменить значение первого элемента массива
a[3] = 4;		// Добавить новый элемент (индекс 3 соответствует четвертой позиции в массиве)

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

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

var a = [];	// Переменная a ссылается на пустой массив.
var b = a;	// Теперь b ссылается на тот же массив.

b[0] = 1;	// Изменение массива с помощью ссылки в переменной b.

console.log(a === b);               // Вернет 'true'
console.log('a[0] = ' + a[0]);      // Изменение объекта b изменяет объект a

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