Exploring JavaScript Symbols. Symbol — новый тип данных в JavaScript

Это первая часть про символы и их использование в JavaScript.

Новая спецификация ECMAScript (ES6) вводит дополнительный тип данных — символ (symbol). Он пополнит список уже доступных примитивных типов (string, number, boolean, null, undefined). Интересной особенностью символа по сравнению с остальными примитивными типами является то, что он единственный тип у которого нет литерала.

Для чего же нужен был дополнительный тип данных?

В JavaScript нет возможности объявить свойство объекта как приватное. Чтобы скрыть данные можно использовать замыкания, но тогда все свойства нужно объявлять в конструкторе (так как нет возможности объявить их в прототипе), к тому же они будут создаваться для каждого экземпляра, что увеличит размер используемой памяти. ECMAScript 5 предоставил возможность указать enumerable: false для свойства, что позволяет скрыть свойство от перечисления в for-in и его не будет видно в Object.keys, но для этого нужно объявлять его через конструкцию Object.defineProperty.

    var user = {};

    Object.defineProperty( user, 'role', {
        enumerable: false,
        value: 'admin'
    });

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

    var userRole = user.role; // 'admin'

В других языках, к примеру, можно добавить модификатор метода, чтобы определить его видимость (protected, private, public). Но в новой спецификации JavaScript выбрали другой подход и решили не вводить модификаторы, а определять поведение в зависимости от типа идентификатора свойства. Раньше имя свойства было строкой, теперь же это может быть как строка так и символ. Такой подход позволяет не менять саму концепцию объявления объектов:

    var role = Symbol();
    var user = {
        id: 1001,
        name: 'Administrator',
        [role]: 'admin'
    };

В данном примере объявлен объект user у которого два свойства объявлены через строковые идентификаторы (id, name) и одно свойство через символ (role).
Свойство role объявлено в квадратных скобках, чтобы оно не интерпретировалось как строка, а было получено в результате вычисления выражения. Данный объект можно также объявить следующим образом, чтобы лучше понять данную конструкцию:

    var role = Symbol();
    var user = {
        ['id']: 1001,
        ['name']: 'Administrator',
        [role]: 'admin'
    };

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

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

    var userName = user.name;    // 'Administrator'
    // OR
    var userName = user['name']; // 'Administrator'

Получить роль пользователя таким образом мы не можем:

    var userRole = user.role;    // undefined
    // OR
    var userRole = user['role']; // undefined

Для того, чтобы получить роль, нужно обращаться к свойству по ссылке на символ:

    var role = Symbol();
    var user = {
        id: 1001,
        name: 'Administrator',
        [role]: 'admin'
    };

    var userRole = user[role]; // 'admin'

Свойство объявленное через символ не будет видно в for-in, Object.keys, Object.getOwnPropertyNames, также не будет добавлено при использовании JSON.stringify.

Рассмотрим особенности символов.

Как уже было показано в примере выше, чтобы создать символ нужно вызвать функцию Symbol:

    var score = Symbol();

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

    var score = Symbol('user score');

    console.log( score ); // Symbol(user score)

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

Спецификация ES6 больше не поддерживает явное создание объектов примитивов, поэтому следующая конструкция выбросит ошибку:

    var score = new Symbol('score'); // TypeError

В целях обратной совместимости для String, Number и Boolean — ошибка не будет выбрасываться (но лучше не использовать устарешнее поведение). Если нужно работать не с примитивом, а с его объектом можно воспользоваться функцией Object передав ей примитив в качестве параметра:

    var symbol = Symbol('symbol');
    var string = 'string';
    var number = 5;

    var symbolObj = Object( symbol );
    var stringObj = Object( string );
    var numberObj = Object( number );

    console.log( symbol );     // Symbol(symbol)
    console.log( string );     // 'string'
    console.log( number );     // 5
    console.log( symbolObj );  // Symbol {}
    console.log( stringObj );  // String { 0: 's', 1: 't', 2: 'r', 3: 'i', 4: 'n', 5: 'g', length: 6, [[PrimitiveValue]]: 'string' }
    console.log( numberObj );  // Number { [[PrimitiveValue]]: 5 }

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

    var firstScore = Symbol('score');
    var secondScore = Symbol('score');

    firstScore === secondScore; // false

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

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

    function isSymbol( value ) {
        return typeof value === 'symbol';
    }

    var firstScore = Symbol('score');
    var secondScore = 'score';

    isSymbol( firstScore );   // true
    isSymbol( secondScore );  // false

В текущей системе приведения типов JavaScript есть много нюансов и символы добавляют еще одну особенность тем, что в отличии от остальных примитивных значений символ нельзя преобразовать к строке или числу. При попытке преобразовать к числу или строке будет выброшена ошибка TypeError. Такое поведение выбрано для того, чтобы случайно не создать строковое значение, которое в итоге будет использовано как имя свойства:

    var userObject = {};
    var role = Symbol() + 'type';
    var id = 10001;

    userObject.id = id;
    userObject[ role ] = 'admin';

В данном примере не однозначно, что должно быть в результате сохранено в переменную role, если строка, тогда свойство userObject[ role ] = 'admin' будет объявлено через строку и к нему будет прямой доступ (но так как использовался символ, скорее всего было желание скрыть значение свойства). С другой стороны, если в результатом выражения будет символ, а так как получить значения символа нельзя, значит определить наличие в нем строки type нельзя, и это уже не явное поведение и нужно информировать разработчика в ситуациях, когда он преднамеренно пытается создать строковое значение из символа, потому что такая конструкция не имеет смысла.

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

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