Symbols

You are probably familiar with the six datatypes in Javascript:
String, number, boolean, undefined, null, object.
But did you know that with ECMAScript 6 came a new, SECRET datatype?

Symbols.
They are so important, they don't even have literal forms. They are created with the Symbol() function.
Symbols are primitive, so the Symbol() function cannot be called with new.
They can also be given an optional argument; which describes the symbol.
Even when symbols have the same description, they are not the same.

// A simple symbol
let symbol = Symbol();

// Symbols can't be made with new
Program.except(() => {
    let symbol = new Symbol();
});

Program.output(typeof symbol, "Symbols with typeof");

// Symbol with description
symbol = Symbol("name");

// Symbols turned into strings
    Program.output(String(symbol), "Symbols to strings");

//Symbols are usually used for objects
let obj = {
    [symbol]: "Barack Obama"
};

Program.output(obj[symbol], "Symbols used with objects");
Program.output("name" in obj, "Searching for Symbol(name) in the object");

let symbol2 = Symbol("name");

Program.output(symbol === symbol2, "Symbols aren't equal 1");
Program.output(obj[symbol2], "Symbols aren't equal 2");

Run code

This is fine and everything that symbols aren't the same, but sometimes you want the same symbols twice.
You could just assign them to be the same, but that is really lame.
Symbol.for() creates symbols that can be similar.
It searches for a symbol that has the same description given, and if it finds one, they will then be the same.
Shared symbols have a 'key' (their description), which you can access via Symbol.keyFor().

let symbols = [];

// Using Symbol.for the first time with "mySymbol"
symbols[0] = Symbol.for("mySymbol");

let obj = {
    [symbols[0]]: "This is mine."
};

// Using Symbol.for the second time with "mySymbol" too
symbols[1] = Symbol.for("mySymbol");

Program.output(symbols[0] === symbols[1], "These two symbols are now equal");
Program.output(obj[symbols[1]], "Really, you can trust me");

// However, using Symbol(), they will not be :(
symbols[2] = Symbol("mySymbol");
Program.output(symbols[0] === symbols[2], "But these are not");
Program.output(obj[symbols[2]], "Really, you can trust me");

// Using Symbol.keyFor()
Program.output(Symbol.keyFor(symbols[0]), "Shared symbols have keys 1");
Program.output(Symbol.keyFor(symbols[1]), "Shared symbols have keys 2");
Program.output(Symbol.keyFor(symbols[2]), "Regular symbols don't");

Run code

Unfortunately, symbols and operators don't get on well.
Yes, symbols can be made strings using String(), but if you dare to try and concatinate it with an empty string, it will throw an error.
They don't like other arithmetic operators either.
They will also throw errors.
If you don't believe me, try it yourself:

let symbol = Symbol();

Program.except(() => symbol + "");
Program.except(() => symbol + 0);
Program.except(() => symbol * 1);
Program.except(() => symbol / 1);

Run code

Now, you might be thinking:
Cool, I can make private object members for objects with symbols!
But nooo...
There is a specific function just to stab you in the back: Object.getOwnPropertySymbols().
Sounds evil, right?
It returns an array containing all property symbols of the object.

let private = Symbol("Very private.");

let myObj = {
    mine: true,
    yours: false,
    [private]: "Of course"
};

let getRekt = Object.getOwnPropertySymbols(myObj);

Program.output(myObj[getRekt[0]], "You just got rekt");

Run code

But, other than being evil, symbols have a very important and epic function:
They can expose internal operations of the program.

Meet some of the well-known symbol properties

Symbol.hasInstance: Defines the object's inheritance, used by instanceof.
Symbol.iterator: Returns an iterator discussed in an eariler code. (Please follow me)
Symbol.toPrimitive: Returns a primitive value representation of the object
Symbol.species: Constructor for making derived classes
Symbol.toStringTag: Returns a string description of the object
Symbol.unscopables: An object whose properties are the names of object properties that should not be included in a with statement

Now that I think about it I don't care enough to finish writing it, so goodnight.

Thank you for reading!8

ES6 - Symbols