Web—Typescript语言(更新中)

2026/11/10

Web—Typescript语言(更新中)

基本类型

number、string、boolean、null、undefined 数组 枚举 元组

类型推断

ts很智能能进行类型推断。但是也很坑:所以记得变量类型、参数类型都定义写上类型,不要走类型推断。

let num1: number = 1
let arry1:string[] or Array<string> = ['a']
let t1: [number, string, number?] = [1, 'a']

enum MyE {A,B,C}
MyE.A or MyE[0]

函数

function MyFn (b: string, a = 10, c?: boolean, ...rest: number[]): number {
    return 1
}
const f = MyFn('abc', true, 1 ,2 ,3)

接口

会进行对象的类型检查

interface Obj = {
    name: string,
    age: number
}
const obj: Obj = {
    name: 'a',
    age: 10
}

类型别名

type MyUserName = string | number
let a: MyUserName = 'a' or 1

范型

function myFn<T> (a: T, b: T): T {
    return [a, b]
}

函数重载

function fc( a:number | string) : string {
    return a + '1'
}
console.log(1)
console.log('a')

接口继承

interface Parent {
    prop1: string,
    prop2: number
}
interface Child extends Parent {
    prop3: string
}
const child: Child = {
    prop1: 'a',
    prop2: 0,
    prop3: 'a'
}

类

修饰符、抽象类、接口类、范类

class Article {

    // get、set方法
    private _passsword: string = ''
    get password(): string {
        return "*******"
    }
    set password(newPass: string) {
        this._passsword = newPass
    }

    // 默认public,都能访问
    public title: string
    public content: string
    aaa?: string
    bbb = 100

    private tempData? : string
    // 继承类可以访问
    protected innerData? : string

    // static 表示类变量,readonly表示只读
    private static readonly author: string = 'abc'

    constructor (title: string, content: string) {
        this.title = title
        this.content = content
    }
}

const a = new Article('标题', '内容')

class ChildArticle extends Article{
    constructor (title: string, content: string) {
        super(title, content)

        this.innerData
    }
}
// abstract 表示抽象类,抽象定义属性和方法,可以不写具体内容
abstract class Animal {

    abstract name: string
    abstract maskSound(): void
    move (): void {
        console.log('移动')
    }
}

class Dog extends Animal {
    name: string = '小狗'
    maskSound(): void {
        console.log('汪汪汪')
    }
}
// 接口类,可以实现多个类
interface Pa1 {
    name: string
    get sound(): string
    move (): void;
}
interface Pa2 {
    age: number
}
class So implements Pa1,Pa2 {
    name: string = '儿子'
    age: number = 3
    get sound(): string {
        return '爹'
    }
    move(): void {
        console.log('爬')
    }
}
// 范型类
class MyClass<T> {
    value: T
    constructor (value: T) {
        this.value = value
    }

    do (input: T) : T {
        console.log('处理数据', this.value)
        return input
    }
}
const myStr = new MyClass<string>('hello')
myStr.do('abc')