一、基础类型

接口

接口我们可以理解为是传参的一个统一表示

不加接口
function carit(skoda: {carname: string, carspeed: number}){
    console.log(`skoda is ${skoda.carname} and the speed is ${skoda.carspeed}`)
}
let onething={ carname: 'super', carspeed: 220}
carit(onething)

我们可以看出，如果不加接口，我们需要每次都对传入参数的格式进行描述，为了将传参继续简化，我们让整个传参变量化

添加接口
interface Car {
    carname: string
    carspeed: number
}
function carit(skoda: Car){
    console.log(`this is a car ${skoda.carname} and the speed is ${skoda.carspeed}`)
}
let onething={ carname: 'super', carspeed: 520}
carit(onething)

我们统一制定了传参格式

可选属性

interface Car {
    carname: string
    carspeed: number
    color?: string
}
其中这个问号就是表示这个属性可有可无

只读属性

当作为不变的属性时候，我们可以用readonly，我们只能读取这个属性，但是并不能修改它
interface Car {
    readonly carname: string
    readonly carspeed: number
    readonly carcolour: string
}
let one:Car = {carname:'skoda', carspeed: 220, carcolour:'red'}
one.carname='audi'

额外属性检测

额外属性检测的作用就是一种保护模式，对于其他可能出现的属性进行归类

interface Car {
    readonly carname: string
    readonly carspeed: number
    readonly carcolour: string
    [something: string]:any
}
let one:Car = {carname:'skoda', carspeed: 220, carcolour:'red',giaotogether: 'giao'}

函数类型

interface test {
    (name: string, age: number):string
    一个类似函数签名的结构，只有参数，参数类型和返回值类型
}
接口限定了它是怎么样的一个函数
let one:test = function(name: string, age: number){
    return `${name} + ${age}`
}
console.log(one('zhao',12))

索引类型

interface test {
    [index: number]: string
}
let one: test = ['red', 'green']
let two : test ={1:'red',2: 'gren'}
我们可以根据索引值，实现对数据的访问

类类型

继承接口

接口中定义的属性和类是十分相似的，也是可以继承的
interface father{
    name: string
    age: number
}
interface son extends father{
    play: string
}
let one = {} as son
one.go='giao' 没有任何一个接口中又go属性，所以会报错
one.name='zhao'

混合类型

接口继承类

interface one
interface two extends class implement interface

类

类的概念和js中的类十分相似，不同之处在于type的控制上

class Animal {
    name: string
    constructor(name: string){
        this.name = name
    }
    distance(val: number){
        console.log(`already walk ${val} miles`)
    }
}
class wowo extends Animal {
    constructor(name: string){
        super(name)
    }
    distance(val: number=1000000){
        console.log('i am wowo')
        super.distance(val)
    }
}

let sam = new wowo('BIGWOWO')
sam.distance(0.00005)
let smith = new wowo('SMITH')
sam.distance()

private public protected

在这其中
private是只能在person类中访问的
protected是能在person的继承类中访问的

class Person {
    name: string
    protected age: number
    constructor(name: string,age: number){
        this.name = name
        this.age = age
    }
    yourage(){
        console.log(`my age is ${this.age}`)
    }
}
class Employee extends Person{
    department: string
    constructor(name: string, age: number,depart: string){
        super(name,age)
        this.department = depart
        this.age = age
    }
    yourself(){
        console.log(`this is ${this.name}, and i am in ${this.department}`)
    }
}

类的存取器

类的存取器是类的一个属性，而不是一个方法，这个是需要注意的

class Employee{
    private name :string
    constructor(name: string, age: number){
        this.name = name
    }
    get fullname():string{
        return `${this.name} is very great`
    }
    set fullname(name: string){
        console.log(`the oral name is ${this.name}`)
        this.name = name
        console.log(`this is present name ${this.name}`)
    }
}

类的静态属性

静态属性是属于类自身的属性，不会随实例创建而变化

class Point {
	static origin = {x:1, y:2}
}

抽象类

抽象类需要在定义时添加abstract
abstract class Person {
    name: string
    constructor(name: string) {
        this.name = name
    }
    printName(){
        console.log('my name is ' + this.name)
    }
    abstract printmeeting (): void
}
class Employee extends Person{
    constructor(name: string){
        super(name)
    }
    printmeeting(){
        console.log('this is metting')
    }
    printgiao(){
        console.log('this is gioa')
    }
}
let one:Person
当定义变量的时候指明了是抽象类的类型，我们不能直接实例化
one = new Employee('zhaohaha')
one.printName()
one.printmeeting()

类中的typeof