typeScript中特殊类型定义

// Js八种内置类型, string, number, boolean, undefined, null, object, bigint symbol

// ECMAScript内置对象 Array, Date Error

// DOM和BOM   HTMLElement, MoserEvent

// 工具类Partial,可以把定义的属性变成可选的，当然age?: number也可以解决
interface IStudent {
    address: string
    age: number
}
// 正常
const Tom:IStudent = {
    address: '湖北',
    age: 19
}
// 报错
const Jack:IStudent = {
    address: '湖北'
}
// 解决
type OptionIStudent = Partial<IStudent>

const Jack1:OptionIStudent = {
    address: '湖北'
}

// Partial底层实现
type Partial<T> = {
    [P in keyof T]?: T[P]
}

// 描述函数类型
interface Isum {
    (x: number, y: number): number
}

const add:Isum =  (num1, num2) => {
  return num1 + num2
}

add(2,3)

implements 实现的意思，主要用来给class定义约束

interface MusicInterface {
    pay():void
}

// phone类如果没有pay方法会报错
class phone implements MusicInterface {
    pay() {}
}

// 这样phone就可以有两条约束了

class phone implements MusicInterface, CallInterface {

    pay() {}

    makePhone() { }

}

// 枚举，特点： 数字递增，反向映射
enum Direction {
    Up,
    Down,
    Left,
    Right
}
// 数字递增
console.log(Direction.Up);    // 0
console.log(Direction.Down); // 1

// 反向映射
console.log(Direction[0]);  // Up

// 当然也可以自己定义递增的初始值
enum Direction1 {
    Up = 2,
    Down,
    Left,
    Right
}
console.log(Direction.Down); // 3

// 当然也可以定义字符串枚举
enum Direction2 {
    Up = 'UP',
    Down = 'DOWN'
}

// Ts高级类型
// | 指可以是其中一种类型 & 把类型合并成一个新的类型
// 联合类型
let num: number | string

// 交叉类型
interface Student {
  name: string
}
type Person = Student & { age:number }

let alan: Person = {
    name: 'alan',
    age: 18
}

// 定义类型可以用type 和 interface
// 相同点是： 都可以定义对象或者函数类型，都允许继承
// 不同点是： interface是Ts的产物，用来定义对象类型，interface可以合并重复声明，type 不行
              type是js的，可以用来定义基本类型，联合类型，交叉类型，元组,interface不行

// 重复声明的例子：

interface Sttudent1 {

    name: string

}

interface Sttudent1 {

    age: number

}

let zack:Sttudent1 = {

    name: 'zack',

    age: 19

}

// typeof类型判断和 as类型断言
function getLength(str: number | string): number {
    // return str.length 会报错应为number类型没有length
    if (typeof str  === 'string') {
        return str.length
    }
    return str.toString().length
}

function getLength1(str: number | string): number {
    const str1 = str as string
    if (str1.length) return str1.length
    const str2 = str as number
    return str2.toString().length
}

// 字面量类型
type sex = '男' |  '女'

// 泛型语法是<> 里面写类型参数，一般用<T>来标识，可以解决输入和输出一致的问题
function student<T>(name: T):T {
    return name
}
const res: string = student('123')
const res1: Number = student(123)

// 添加默认参数
interface IPay<T =string> {
    (age:T): T
}
function pay<T>(age: T) {
    return age
}
const mypay:IPay = pay

// 泛型约束

interface Ilength {

    length: number

}

function getlength<T extends Ilength>(age: T):T {

    return age

}

const str1 = getlength('123')

const str2 = getlength([])

const str3 = getlength(123)  // 报错