ESX

Типы данных

  1. Undefined
  2. Null
  3. Object
  4. Boolean
  1. String
  2. Number
  3. Symbol

Undefined

[undefined]
// x объявлен
var x;
if (x === undefined) {}
if (x === void 0) {}
 
// x не объявлен
if (typeof x === "undefined") {}

NULL

[null]

Object

  1. Constructor
  2. Prototype
  3. Ordinary
  1. Exotic
  2. Standard
  3. Built-in
  1. Boolean
  2. Number
  1. String
  2. Symbol
let container;
 
container = {};
container = Object();
container = new Object();
container = Object.create(prototype, props);

Boolean

[true; false]
let flag;
 
flag = false;
typeof flag; // boolean
flag = Boolean(false);
typeof flag; // boolean
 
flag = new Boolean(flag);
typeof flag; // object
 
flag = flag.valueOf();
typeof flag; // boolean
flag = Boolean(); // false
flag = Boolean(document.all); // false
flag = new Boolean(false);
if (flag) {
  // ???
}
flag = new Boolean(false);
typeof flag; // object
if (flag) {
  // будет выполнено    
}

String

[0; FFFF₁₆]{0, 2⁵³-1}
let container;
 
container = "Содержимое";
typeof container; // string
 
container = String("Содержимое");
typeof container; // string
 
container = new String(container);
typeof container; // object
 
container = container.valueOf();
typeof container; // string
container = "Содержимое";
typeof container; // string
container.charAt(2); // д
typeof container; // string
container[2]; // д
container = "Cтрока 1" + 
            "Cтрока 2" +
            "Cтрока 3";
 
container = "Cтрока 1 \ 
             Cтрока 2 \
             Cтрока 3";

String.→

  1. startsWith("Подстрока")
  2. endsWith("Подстрока")
  3. includes("Подстрока")
  4. repeat(count)
  1. raw(callSite, ...substitutions)
  2. fromCodePoint(...codePoint)
  3. codePointAt(pos)
  4. normalize(form)

Литерал шаблона

`Литерал`
`Строка 1
 Строка 2`
let name = "Валера"
  , result;
result = `А где же наш ${name}?`
result; // А где же наш Валера?
let  result
  , price = 234
  , tax = price * 0.05;
result = `Товар стоит ${(price + tax).toFixed(2)} ₴`
result; // Товар стоит 245.70 ₴
currency`Товар стоит 
         ${price + tax}:c(UAH,uk-ua), 
         так то.`;
// Товар стоит 245,70 грн., так то.
 
currency`Товар стоит 
         ${price + tax}:c(JPY,ja-JP), 
         так то.`;
// Товар стоит ￥246, так то.
function currency(strings, ...values) {
 // string = ["Товар стоит ", ":c(UAH,uk-ua), так то."]
 // values = [245.7]
 // …
}
// …
const regExp = /^:c(\((.+),(.+)\))?/;
let strings_set = [...strings]
  , values_set = [...values];
// …
// …
for (let key in values_set) {
    const index = +key+1
        , string = strings_set[index]
        , match = regExp.exec(string);
    // …
}
// …
// …
if (match === null) continue;
// …
// …
// [":c(UAH,uk-ua)", "(UAH,uk-ua)", "UAH", "uk-ua"]
const [ , , currency, locale] = match;
strings_set[index] = strings_set[index]
                      .replace(regExp, "");
values_set[key] = values_set[key]
                      .toLocaleString(locale, {
                          style: 'currency'
                        , currency: currency });
// …
// …
return String.raw({
  raw: strings_set
 }, ...values_set);

Пример использования шаблонных литералов

QRCODE cо ссылкой на IEEE 754-2008

https://jsfiddle.net/zrv9azyw/

Number

IEEE 754-2008

QRCODE cо ссылкой на IEEE 754-2008

http://ieeexplore.ieee.org/document/4610935/

Number.→

  1. isFinite(число)
  2. isNaN(число)
  3. EPSILON
  4. toLocaleString(locales, options)
  1. isSafeInteger(число)
  2. MIN_SAFE_INTEGER
  3. MAX_SAFE_INTEGER
[-(2⁵³ - 1); +(2⁵³ - 1)]
+0
-0
+Infinity
−Infinity
NaN
-1/0; // -Infinity
Infinity/Infinity; // NaN
-1/Infinity; // -0
Math.round(-0.1); // -0
NaN === NaN; // false
+0 === -0; // true
let container;
 
container = 123.12;
typeof container; // number
 
container = Number(123.12);
typeof container; // number
 
container = new Number(container);
typeof container; // object
 
container = container.valueOf();
typeof container; // number
23.51 // десятичная
2351e-2 // научный формат, 23.51
0x10 // шеснадцатеричная, 16
0b10 // бинарная, 2
0o10 // восьмиричная, 8
let x = 10;
x.toString(16); // a
x.toString(8); // 12
x.toString(6); // 14
x.toString(2); // 1010
x.toExponential(1); // 1.0e+1
0.2 + 0.1 !== 0.3 
// 0.30000000000000004
0.2.toFixed(20) 
// 0.20000000000000001110
0.1.toString(2) 
// 0.000110011001100[1100]
(
  Math.abs(
        (0.2 + 0.1) - 0.3 
  ) < Number.EPSILON
); // true
Number.isNaN('???') //false
isNaN('???') //true
12.34.toPrecision();  // 12.34
12.34.toString();     // 12.34
12.34.toPrecision(5); // 12.340
12.34.toPrecision(4); // 12.34
12.34.toPrecision(3); // 12.3
12.34.toPrecision(2); // 12
12.34.toPrecision(1); // 1e+1
0.002345.toPrecision(5); // 0.0023450
0.002345.toPrecision(4); // 0.002345
0.002345.toPrecision(3); // 0.00234
0.002345.toPrecision(2); // 0.0023
0.002345.toPrecision(1); // 0.002
0.002385.toFixed(5); // 0.00238
0.002386.toFixed(5); // 0.00239
0.002385.toFixed(4); // 0.0024
0.002385.toFixed(3); // 0.002
0.002385.toFixed(2); // 0.00
0.002385.toFixed(1); // 0.0
0.002385.toFixed(0); // 0
10..toFixed(5); // 10.00000
// .toLocaleString([locales [, options]])
10000000..toLocaleString(); // 10,000,000
10000000..toLocaleString('RU'); // 10 000 000
10000000..toLocaleString('DE'); // 10.000.000
// .toLocaleString([locales [, options]])
10000000..toLocaleString(); 
// 10,000,000
10000000..toLocaleString('RU'); 
// 10 000 000
10000000..toLocaleString('DE'); 
// 10.000.000
10000000..toLocaleString('en-US', {
  style: "currency",
  currency: "USD"   
}); // $10,000,000.00
10000000..toLocaleString('RU', {
  style: "currency",
  currency: "RUB"   
}); // 10 000 000,00 ₽
10000000..toLocaleString('DE', {
  style: "currency",
  currency: "EUR"   
}); // 10.000.000,00 €

symbol

let key_name;
 
// Уникальный символ
key_name = Symbol(); 
key_name = Symbol("Пространное описание"); 
 
// Символ, который будет внесен в реестр символов
key_name = Symbol.for("Пространное описание"); 
this[key_name] = "Значение";
let key_1, key_2;
 
key_1 = Symbol("Пространное описание");
key_2 = Symbol("Пространное описание"); 
(key_1 === key_2) // false
 
key_1 = Symbol.for("Пространное описание");
key_2 = Symbol.for("Пространное описание"); 
(key_1 === key_2) // true
key_name = new Symbol(); // TypeError
key_name = Symbol();
typeof key_name; // "symbol" 
key_name = Object(key_name);
typeof key_name; // "object" 
key_name = key_name[Symbol.toPrimitive]('symbol');
typeof key_name; // "symbol" 
this[key_name] = "Значение";
let obj = {"a": 123}
  , key = Symbol.for('Пространное описание');
obj[key] = "Некое значение";
Object.getOwnPropertySymbols(obj);
// [Symbol(Пространное описание)]
for (let x of obj) {} // Работает как обычно
for (let x in obj) {} // Игнорирует символы

typeof

  • Undefined
  • Null баг
  • Boolean
  • String
  • "undefined"
  • "object"
  • "boolean"
  • "string"
  • Number
  • Object
  • Object callable
  • Symbol
  • "number"
  • "object"
  • "function"
  • "symbol"

Приведение типов

→ ToPrimitive(input, hint)

Undefined input
Null input
Number input
Boolean input
String input
Symbol input
Object Хитрый алгоритм

→ ToPrimitive(input, hint)

  1. hint может быть [default, string, number]
  2. если input экзотический объект проверяем есть ли в нём символ @@toPrimitive
  3. если есть и можно вызвать — вызываем и возвращаем результат или TypeError
  4. если нет или input — обычный объект, идем дальше
  5. если hint == "default", заменяем на "number"
  6. вызываем OrdinaryToPrimitive(input, hint)

→ ToPrimitive(input, hint)

  1. hint — string применяем toString, valueOf
  2. hint — number применяем valueOf, toString
  3. если метод есть и можно вызвать — вызываем и возвращаем результат или TypeError

→ toBoolean

Undefined false
Null false
Number false для [+0; -0; NaN] или true
String false для [""] или true
Symbol true
Object true
(value === 'true');  // true
typeof (value === 'true');  // boolean
!!+"1"; // true
typeof !!+"1"; // boolean

→ toNumber

Undefined NaN
Null +0
Boolean 1 если true, 0 если false
String
  1. Пытаемся обработать как последовательность StringNumericLiteral UTF-16
  2. Если не вышло — возвращаем NaN
Symbol TypeError
Object
  1. ToPrimitive(input, number)
  2. ToNumber(input)
parseInt(value, 10);
parseFloat(value);
+value;
Number(value);

→ toString

Undefined "undefined"
Null "null"
Boolean "true" если true, "false" если false
Symbol TypeError
Object
  1. ToPrimitive(input, string)
  2. ToString(input)

→ toString

Number "NaN" если NaN
"0" если +0 или -0
"Infinity" если +∞
"-" + toString(arg) если значение меньше 0
число N переводим в UTF-16
value.toString(); 
// не работает с null
// не работает с undefined
"" + value;
String(value);

→ toObject

Undefined TypeError
Null TypeError
BooleanНовый объект Boolean
NumberНовый объект Number
StringНовый объект String
SymbolНовый объект Symbol

Домашка

{} + {}; // ?
[] + {}; // ?
{} + []; // ?
[] + []; // ?
1 + true; // ?
1 + {}; // ?
{} + 1; // ?
"1" + 3; // ?
"123"/1; // ?
"123 12"/1; // ?

Антон Немцев

http://silentimp.info/

skype: ravencry

QRCODE cо ссылкой на доклад

https://github.com/SilentImp/ES6Types