JS Fest 2019/Autumn. Андрей Старовойт. Зачем нужен тип "true" в TypeScript?

Старовойт Андрей
Зачем нужен тип “true”?
PROFESSIONAL JS CONFERENCE
8-9 NOVEMBER‘19 KYIV, UKRAINE

@JetBrains. All rights reserved
About
—
• Работаю в команде WebStorm 5 лет
• Занимаюсь поддержкой JavaScript, TypeScript, JSX, …

Type “true”
—

Type “true”
—
let a: true;
TypeScript 2.0

Type “true”
—
let a: true;
a = true; //ok
a = false; //error
a = 1; //error
TypeScript 2.0

Зачем?
Type “true”
—

String Literal
Overloads
—
function create(p: “string"):string;
function create(p: "number"):number;
function create(p):any;
TypeScript 1.1

function create(p: true): string;
function create(p: false): number;
function create(p: boolean): string | number;
Type “true”
—
Boolean literals in overloads

_
@types/node TSLSocket

function check(checkType?: true);Optional
—

function check(checkType?: true);
check();
Optional
—

function check(checkType?: true);
check();
check(true);
Optional
—

_
@types/babel__core

TypeScript 2.0
Features
—

Type Guard
—

class Cat { meow() }
class Dog { woof() }
function say(animal: Cat | Dog) {
if (animal instanceof Cat) {
animal.meow();
animal.woof();
}
}
Type Guard
—

class Cat { meow() }
class Dog { woof() }
function say(animal: Cat | Dog) {
if (animal instanceof Cat) {
animal.meow(); //ok, no cast
animal.woof(); //error
}
}
Type Guard
—

interface ICat { meow() }
interface IDog { woof() }
function say(animal: ICat | IDog) {
if (animal instanceof ICat) {
animal.meow();
}
}
Type Guard
—

interface ICat { meow() }
interface IDog { woof() }
animal.meow();
}
}
//Compiled file
function say(animal) {
animal.meow();
}
}
Type Guard
—

Type Guard
—
Discriminated union types

interface ICat { kind: "cat"; meow() }
interface IDog { kind: "dog"; woof() }
if (animal.kind == "cat") {
animal.meow(); //ok
}
}
Discriminated
Union Types
—

animal.meow(); //ok
}
}
say({ kind: "cat" }) //error
Discriminated
Union Types
—

animal.meow(); //ok
}
}
say({ kind: "cat" }) //error
say({ kind: "cat", meow() {}}) //ok
Discriminated
Union Types
—

Boolean literals?
Discriminated
Union Types
—

type Result = {
success: boolean;
callback?() //if success=true
}
Discriminated
Union Types
—

type Result = {
success: boolean;
callback?() //if success=true
}
function process(p: Result) {
p.callback(); //ok, can throw error
}
Discriminated
Union Types
—

type Result =
{ success: true, callback() } |
{ success: false };
Discriminated
Union Types
—

type Result =
{ success: false };
p.callback(); //error
}
Discriminated
Union Types
—

type Result =
{ success: false };
if (p.success) {
p.callback(); //ok
}
}
Discriminated
Union Types
—

type Result =
{ success: false };
if (p.success) {
p.callback(); //ok
}
}
process({success : true}) //error
Discriminated
Union Types
—

type Result =
{ success: false };
if (p.success) {
p.callback(); //ok
}
}
process({success : true}) //error
process({success : true, callback() {}}) //ok
Discriminated
Union Types
—

_
@types/jsforce

Literal Types
—

Literal Types
—
: true
: false

Literal Types
—
: true
: false
: boolean

Const
—
const checkValue = true;

Const
—
const checkValue = true;
let falseValue: false = checkValue; //error
let trueValue: true = checkValue; //ok

Let
—
let checkValue: true = true;

Let
—

Let
—
checkValue = false; //error

Let
—
let checkValue = true;

Let
—
Type: true

Let
—
checkValue = false;
Type: true

Let
—
checkValue = false; //ok
Type: boolean
Inferred type: true

Let
—
checkValue = false; //ok
falseValue: false = checkValue; //ok
trueValue: true = checkValue; //error
Type: boolean
Inferred type: true
Inferred type: false

function getBoolean() {
let value: true = true;
return value;
}
Return Type
—

return value;
} //: true
Type: true
Inferred type: true
Return Type
—

let value = true;
return value;
}
Return Type
—
Type: boolean
Inferred type: true

let value = true;
return value;
} //: boolean
Return Type
—
Type: boolean
Inferred type: true

function getNumber() {
let value: number | string = 1;
return value;
}
Type: number | string
Inferred type: 1
Return Type
—

return value;
}
: 1
: number | string
Inferred type: 1
Return Type
—

return value;
}
: 1
: number
: number | string
Inferred type: 1
Return Type
—

Return Type
—
return value;
}
: 1
: number
: number | string
Return Type = Fixed(Inferred Type)
Inferred type: 1

function getBoolean1() {
return value;
}
let value = true;
return value;
}
Return Type
—

return value; //: true
}
let value = true;
return value;
}
Return Type
—

}
let value = true;
return value; //: true(widening)
}
Return Type
—

• Литеральные типы: расширяемый и нерасширяемый
• Литералы используемые в коде имеют расширяемый
тип
• При некоторые операциях типы расширяются до
соответствующих примитивных типов
Widening
Literal Types
—

Операции расширяющие тип:
• Вычисление возвращаемого типа функции
• Присваивание
• Вызов метода
Widening
Literal Types
—

Операции расширяющие тип*:
• Вычисление возвращаемого типа функции
• Присваивание
• Вызов метода
* Есть исключения
Widening
Literal Types
—

Afterwords
—

}
let value = true;
}
Literal Types
—

function getBoolean1(): boolean {
}
function getBoolean2(): boolean {
let value = true;
}
Literal Types
—

Используйте явные типы!
Widening
Literal Types
—

jetbrains.com
Thanks
—
@anstarovoyt
andrey.starovoyt@jetbrains.com

JS Fest 2019/Autumn. Андрей Старовойт. Зачем нужен тип "true" в TypeScript?

More Related Content

What's hot (19)

Similar to JS Fest 2019/Autumn. Андрей Старовойт. Зачем нужен тип "true" в TypeScript? (20)

More from JSFestUA (20)

Recently uploaded (20)

JS Fest 2019/Autumn. Андрей Старовойт. Зачем нужен тип "true" в TypeScript?