Сложно о простом. Типы данных JS. В поисках истины примитивов и объектов

Я решил написать цикл статей, под названием «Сложно о простом». Этот цикл будет посвящён языку JavaScript. Почему «сложно о простом»? Потому что всё, что я буду рассказывать я буду рассказывать учитывая особенности работы интерпретатора, начиная с типов данных. Всё это будет делатья для того, что бы потом можно было рассказать просто о сложном, например, о способах наследования в JavaScript и прочих патернах.

JavaScript – это объектно-ориентированный язык программирования, с прототипной организацией.
Что значит «с прототипной организацией», мы поговорим в следующей статье (она обязательно будет), а вот почему он «объектно-ориентированный» и всё ли в JS — объект, мы узнаем сегодня.
Для выполнения своих целей JS`у достаточно всего 9 типов. Причём только 6 из них доступны программе, оставшиеся же 3 доступны лишь на уровне реализации и используется спецификацией. На первый взгляд(и это первое заблуждение) всё в JS является объектами. Так вот пять из шести доступных программе типов являются так называемыми примитивами и не есть объектами(ниже я поясню почему и как их путают с объектами). Эти пять примитивов это:

— String (s=’str’)
— Number (n=10)
— Boolean (b=true)
И как я их называю «философские типы»:
— null (v = null)
— undefined (u=undefined)

Философские по тому, что null означает, что переменной присвоено ничего, а undefined – означает, что в переменную присвоили пустоту. Чем отличается «ничего» от «пустоты» в данном случае – поразмыслите на досуге. Сейчас мы этого делать не станем.

Шестой, доступный программе тип(объектный) – это:
- Object (не путайте с конструктором Object, мы сейчас ведём речь лишь об абстрактных типах!) – единственный тип, представляющий объекты в JavaScript.
Объект — это структура данных(целый их набор), представленный в виде набора пар «ключ-значение». Ключ может быть как числовой(нумерованный), так и буквенный(именованный). Значением может быть любой из типов данных — тогда это будет свойство объекта, или даже функция — тогда это будет метод объекта.

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

Вот несколько примеров:

var v1;        //undefined (пустая) локальная переменная
var v2='2'; //строковая локальная литеральная переменная
var v3 = new String(2); //строковая локальная, объявленная через конструктор переменная. Создаст новый объект типа String
v4 = String(2); //строковая глобальная переменная вызванная через конструктор. Создаст переменную window.v4
'2'.length;        // строка не станет переменной но её можно уже использовать как Объект
34..toString(); //число не станет переменной но его уже можно использовать как объект
12. toString(); //число не станет переменной но его уже можно использовать как объект
(22).toString();//число не станет переменной но его уже можно использовать как объект

В последних 4-х командах, как раз хорошо видно как примитив путают с объектом – ведь мы же вызываем метод, через точку – прямо как у объекта. Действительно создаётся впечатление, что эти примитивы – объекты.

Заблуждение усугубляется, когда мы проверяем тип переменной, например

var v = null;
typeof v;

и получаем в ответ «object».

А если мы напишем:

var v = null;
v instanceof Object;

То в голове вообще возникнет каша, потому, что результат последней строчки будет «false». То есть переменная v имеет тип object, но не унаследована от типа Object. Что за дела?!

Для начала объясню подвох с typeof null. Этот оператор возвращает тип объекта. А дело в том, что оператор typeof возвращает строковое значение, взятое из жёстко закреплённой таблицы, где прописано: «для null – возвращать «object»». Оператор же instanceof – проверяет принадлежит ли что-то к указанному типу данных. Как он это делает, я расскажу в следующей статье, но, уверяю вас, в данном случае он отработал верно, примитив null ни в коем случае не унаследован от типа Object – он сам по себе, примитив – низшая ступень развития.

Ладно, с typeof и instanceof разобрались, но методы то у примитивов вызываются – как у объектов прям! Как, если это не объект?

Тут дело вот в чём. Существует такая вещь как функции-обёртки(конструкторы)(и снова всё прояснится во второй статье). Они есть для всех примитивов (Number(), Boolean(), String(), Object()), а так же и другие. Их суть состоит в том, что бы из примитива создать объект, у которого будут вспомогательные методы для работы с данным типом примитива.
Например переменную можно создать так:

Var num = new Number(23.456);

В таком случае из примитива 23.456 мы получим объект.
Для типа number конструктор Number() имеет вспомогательный метод toPrecision() – он определяет для числа количество значимых цифр. Например, если числу 23.456 установить количество значимых цифр 4, то мы получим число 23.45.
И вот когда мы пытаемся обратится к примитиву как к объекту:

(23.456). toPrecision(4);

Интерпретатор, временно, оборачивает, приметив в объект вызовом new Number(23.456) и потом уже у этого объекта вызывает метод toPrecision(), который у него теперь есть. Таким образом, многие ошибочно считают, что всё в JS есть объектом.

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

var str = ‘str’;
str.test = ‘test’;
//ошибки не будет, программа продолжит работать, но
console.log(str.test); //undefined

Если бы мы считали, как раньше, что str – это объект, мы бы удивились, почему он не запомнил в себе новое свойство test. Но теперь мы знаем, что при обращении к примитиву как к объекту, он временно оборачивается в объект типа Number. Но после выполнения операции эта обёртка исчезает, а вместе с ней и новое свойство test. Вот и всё, никакой магии.

На самом деле, забегая наперёд, во время оборачивания примитива в объект, выстраивается целая цепочка наследования (как это организовано мы поговорим позже), но по сути получается такая вот «матрёшка»:

Object(Number(<примитив>)). Родителем любого объекта в JS, так или иначе, будет Object. При вызове свойства в объекте поиск проходит по всей этой «матрёшке» пока не найдёт в одном из объектов это свойство или вернёт undefined или если искали метод, то выбросит исключение. Таким образом, у примитива также доступны свойства объекта Object. Как работает прототипное наследование и о его тонкостях мы поговорим во второй статье.

Для интриги над второй статьёй, которую я хочу выпустить, расскажу про ещё один момент связанный с функциями конструкторами — это преобразование типов. JS — это не строго типизированный язык. Это значит, что в момент объявления переменной мы не обязаны указать какого она типа, и более того во время работы программы в эту переменную можно ложить данные абсолютного любого типа. А так же мы можем использовать, например, строковые переменные в математических действиях или наоборот, числа в операции конкатенации. Пример:

var str = 'abc';
str+1; // 'abc1'

Здесь примитив типа number — 1, будет преобразован в строковый примитив. В объектах эта возможность доступна через вызов метода toString(), в объектах типа number, есть метод valueOf(), который вернёт примитив типа number. Но мы вроде как говорили что методы могут быть только у объектов. Значит в процессе преобразования примитива из одного типа в другой, происходит тоже оборачивание в объект? Уверяю вас что нет. Вызов этого метода происходит не явно, когда функция-конструктор вызывается интерпретатором без оператора new. Что за волшебный оператор new и что происходит когда функция-конструктор вызывается без него, да и что блин в конце то концов за функция-конструктор такая, мы поговорим в следующей статье. Пока поверьте мне на слово — преобразование типов происходит сразу — из примитива в примитив.

Пока, конечно, больше вопросов чем ответов, однако, поверьте, всё станет намного прозрачнее после прочтения второй статьи. Здесь я в основном заинтриговал и поднял ряд вопросов — так сказать взбудоражил умы. Но всё же кое-что можно вынести и из этой статьи:
1. Не смотря на расхожее мнение «всё в JS является объектами» — это не так, мы выяснили, что из 6 доступных программисту типов данных аж 5 является примитивами и лишь один представляет тип объектов.
2. Про объекты мы узнали, что это такая структура данных, которая содержит в себе пары «ключ-значение». При чём ключом может быть как число, так и строка (нумерованные и именованные), а значением — любой из типов данных (и это будет свойство объекта) или функция (и это будет метод объекта).
3. А вот примитивы – это не объекты. Хотя с ними и можно работать как с объектом (и это вызывает заблуждение что примитив – это объект), но…
4. Переменные можно объявить как по простому (литерально) (var a = ‘str’), так и через функцию-конструктор (обёртка)(var a = new String(‘str’)). Во втором случае мы получим уже не примитив, а объект созданный функцией-обёрткой String(). (что за магический оператор new и что такое функция-конструктор мы узнаем дальше).
5. Узнали, что именно за счёт создания обёртки над примитивом (new String(‘str’)) c ним можно работать как с объектом. Именно эту обёртку создаёт интерпретатор вокруг примитива, когда мы пытаемся работать с ним как с объектом, но после выполнения операции она разрушается (поэтому примитив никогда не сможет запомнить свойство, которое мы ему присвоим a.test = ‘test’- свойство test исчезнет с обёрткой).
6. Узнали, что у объектов есть метод toString() который возвращает строковое представление объекта (для типа number valueOf() – вернёт числовое значение).
7. Поняли, что при выполнении операций конкатенации или математических операциях примитивы могут переопределить свой тип в нужный. Для этого они используют функции-обёртки своих типов, но без оператора new (str = String(str)).(в чём разница и как это работает, поговорим дальше)
8. И наконец, узнали, что typeof берёт значения из жёстко зафиксированной таблицы (вот откуда ещё одно заблуждение, основанное на typeof null //object).

Автор: drinkcsis