Typescript学习三

接口

interface ClockInterface{
    tick():void
}
interface ClockConstructor{
    new (hour:number, minute:number):ClockInterface
}
function createClock(ctor:ClockConstructor,hour:number,minute:number):ClockInterface{
    return new ctor(hour,minute)
}

interface Shape{
    color:string
}
interface Square extends Shape{
    sideLength:number
}
let square={} as Square
square.color='blue'
square.sideLength=12

interface Counter{
    (start:number):string;
    interval:number;
    reset():void;
}

function getCounter():Counter{
    let counter=function(start: number){} as Counter
    counter.interval=123
    counter.reset=function(){}
    return counter
}

类

class Control{
    private state: any
}
interface SelectableControl extends Control{
    select(): void
}


class Octopus{
    constructor(readonly name:string,readonly nub:number){}
}

class Employee{
   public readonly name:string
   private _age:number
   get age():number{
       return this._age
   }
   set age(nage:number){
    this._age=nage
   }
}

class Grid{
    static origin={x:0,y:0}
    constructor(public scale:number){}
    calculate(point:{x:number,y:number}){
        let x=(point.x-Grid.origin.x)
        let y=(point.y-Grid.origin.y)
        return Math.sqrt(x*x+y*y)/this.scale
    }
}
let g1=new Grid(1)
g1.calculate({x:10,y:10})


abstract class Dep{
    abstract printm():void;
    constructor(public name:string){}
}
class Adep extends Dep{
    constructor(){
        super('test')
    }
    printm():void{
        console.log('test11')
    }
}
let dep:Dep
dep.printm()

函数

function(x?:string,...y:string[]):string{
    return y.join('')
}
function add(x?:number,y:number):number{
    return x+y
}
let add1=function(x:number,y:number):number{return x+y}

泛型

function ide<T>(arg:Array<T>):Array<T>{
    return arg
}
function ide1<T>(arg:T):T{
    return arg
}
let aa:{<T>(arg:T):T}=ide1
interface gen{
    <T>(arg:T):T
}

function getP<T,K extends keyof T>(obj:T,key:K){
    return obj[key]
}

enum E{
    x,
    y
}
const enum Dir{
    up,
    down,
}

交叉类型

function ext<First,Second>(first:First,second:Second):First&Second{
    const res:Partial<First&Second>={}
    return res as First&Second
}

联合类型

function del(v:string,p:string|number){
}
function isFish<T,U>(pet:T|U):pet is T{
    if("t" in pet)
        return (pet as T).t()
}
type T = {a:number}