typescript

一、 继承，泛型

下面的例子是泛型，也有一部分重载。axois({})这种genertic type不支持<T>多态

api.ts

import axios from 'axios';

interface IUser {

    id: number;

    email: string;

}

function getUser<T>(type: 'username', data: string):Promise<T>;

function getUser<T>(type: 'id', data: number):Promise<T>;

async function getUser<T>(type: any, data: any){

    return await axios.get<T>('/user');

}

export {

    getUser,

    IUser

}

 

2.ts

import {

    getUser,

    IUser

} from './api';

~ async function(){

    let res = await getUser<IUser>('id', 1)

    res.email;

}()

 

二、type与interface的区别主要是interface可以用作类

interface IU {

    fn(x:number): number;

}

let a1:IU = {

    fn(x:number) {

        return x*10;

    }

}

interface IU{

    (x:number): number;

}

let a1: IU = function(x:number){

    return x*10;

}

interface IU{

    (x:number): number; //表示UI是函数

    uname: string; //表示包含了uname属性的函数

}

function fn(x:number){

    return x*10;

}

fn.uname = '123';

function f(callback:IU) { //需要callback是 IU，也就是uname需存在

}

f(fn)

 

三、重载

//为类型声明了一个变量，它只能作为类型去用
type ns = number|string
type os = {
username:string;
password: string;
}
// class,类似type， 但是可以为对象这种结构去定义
interface RegisterUser {
username: string;
password: string;
}

interface User extends RegisterUser{
id: number; // 包含password/username
}

registry(data:RegisterUser)
registry({username:'123', password:'123'})

string !=String
// let a:String;
// v = '1';
// v = new String('1')

重载
当同一个函数的参数的类型或者个数或者顺序不同的时候， 需要重载
function fn(x:number, y: number);
function fn(x:string, y: string);
function fn(x:any, y: any){
}
fn(1, 2) //correct
fn('1', '2') // correct
fn(1,'2') // incorrect

泛型
function getUser<T， >(userType: 'vip'|'normal'|'king'){
//返回三种类型,当函数的内部某个数据不确定的时候 ，
//而是在调用的时候才确定， 用泛型来解决这个问题
//泛型， 就是为不确定的函数定义变量
return new Array<T>();
}
getUser('vip');

fetch('/getUser').then(res=>{
return res.json();
}).then(data=>{
data.
})