Learning typescript (II)

type inference

Joint type

let numberOrString: number | string
numberOrString.toString() //  Common properties and methods of union types


Types of assertions

When using non common properties and methods , utilize  as  keyword , Treat variables as a type , Or use  typeof  Judgment type

// union types
let numberOrString: number | string

function getLength(input: string | number): number {
 const str = input as string
 if (str.length) {
 return str.length
 } else {
 const number = input as number
 return number.toString().length
 }
}

//type guard
function getLength2(input: string | number): number {
 if (typeof input === 'string') {
 return input.length
 } else {
 return input.toString().length
 }
}


enumeration  enums

//  Enumeration of numbers , Enumeration members are assigned from the first value （ The default is 0） The number that starts to increase
enum Direction {
 Up,
 Down,
 Left,
 Right,
}
console.log(Direction.Up) // 0
console.log(Direction[0]) // Up

//  String Enum
enum Direction {
 Up = 'UP',
 Down = 'DOWN',
 Left = 'LEFT',
 Right = 'RIGHT',
}
const value = 'UP'
if (value === Direction.Up) {
 console.log('go up!')
}

//  Constant enumeration , Reduce performance
const enum Direction {...}


Generic  Generics

Generic basis

Generic （Generics） It means defining functions 、 Interface or class , Do not specify specific types in advance , And when you use it, you specify a feature of type .

function echo<T>(arg: T): T {
 return arg
}

const result = echo(true)

function swap<T, U>(tuple: [T, U]): [U, T] {
 return [tuple[1], tuple[0]]
}
const result2 = swap(['string', 123])


Constraint generics

When using generic variables inside a function , Because I don't know what type it is in advance , So you can't manipulate its properties or methods at will

Typescript Medium extends keyword - Technology circle  (proginn.com)

interface IWithLength {
 length: number
}

function echoWithLength<T extends IWithLength>(arg: T): T {
 console.log(arg.length)
 return arg
}

const str = echoWithLength('str') //  Want to have length attribute
const obj = echoWithLength({ length: 10, width: 10})
const arr2 = echoWithLength([1, 2, 3])


Class

class Queue<T> {
 private data = [];
 push(item: T) {
 return this.data.push(item)
 }
 pop(): T {
 return this.data.shift()
 }
}
const queue = new Queue<number>()
queue.push(1)
console.log(queue.pop().toFixed())


Application in interface

interface KeyPair<T, U> {
 key: T
 value: U 
}
let kp1: KeyPair<number, string> = { key: 1, value: &quot;string&quot;}
let kp2: KeyPair<string, number> = { key: 'str', value: 2 }
let arr: number[] = [1,2,3]
let arrTwo: Array<number> = [1,2,3] // Array Built in generics