Question

想象一下，我有以下界面

interface IMarket {
    ID: number,
    Name: string,
    MarketDescription: string
}
interface IDepartment {
    ID: number,
    Name: string,
    DepartmentDescription: string
}

有没有办法将接口存储在这样的对象中？

var typeMap = { Markets: IMarket, Departments: IDepartment }

我想做这样的事情。我想基于我传递给构造函数的字符串值动态设置“getQueryResults”的泛型类型。

export class Service {
    protected baseURL = "";
    protected typeName = "";
    private typeMap = { Markets: IMarket, Departments: IDepartment }

    constructor(typeName) {
        this.baseURL = 'http://localhost/API/odata/' + typeName;

        this.currentType = typeMap[typeName];
    }
    getQueryResults(): Promise<this.currentType> {
        return new Promise<this.currentType>((resolve, reject) => {
            $.getJSON(this.baseURL, function (returnValue) {
                resolve(returnValue.value);
            });
        })
    }
}

var marketService = new Service("Markets");
var topMarket = marketService.getQueryResults();
//topMarket is an instance(?) of IMarket

var departmentService = new Service("Departments");
var topDepartment = departmentServicegetQueryResults();
//topDepartment is an instance(?) of IDepartment

Answer 1

从TypeScript文档中记下：

http://www.typescriptlang.org/docs/handbook/namespaces.html#namespaced-validators

namespace Validation {
    export interface StringValidator {
        isAcceptable(s: string): boolean;
    }

看起来你想要：

namespace YourNamespace {
    export interface IMarket {
        ID: number,
        Name: string,
        MarketDescription: string
    }

    export interface IDepartment {
        ID: number,
        Name: string,
        DepartmentDescription: string
    }
}

Answer 2

这可以使用generics简单地解决，它正是它的用途：

export class Service<T> {
    protected baseURL = "";

    constructor() {
        this.baseURL = 'http://localhost/API/odata/' + typeName;
    }

    getQueryResults(): Promise<T> {
        return new Promise<T>((resolve, reject) => {
            $.getJSON(this.baseURL, function (returnValue) {
                resolve(returnValue.value);
            });
        })
    }
}

var marketService = new Service<IMarket>();
var topMarket: Promise<IMarket> = marketService.getQueryResults();

var departmentService = new Service<IDepartment>();
var topDepartment: Promise<IDepartment> = departmentService.getQueryResults();

修改

你可以再使用2个类来“摆脱”多次Service<TYPE>的需要（每个TYPE）：

export abstract class Service<T> {
    protected baseURL = "";

    constructor() {
        this.baseURL = 'http://localhost/API/odata/' + this.getTypeName();
    }

    getQueryResults(): Promise<T> {
        return new Promise<T>((resolve, reject) => {
            $.getJSON(this.baseURL, function (returnValue) {
                resolve(returnValue.value);
            });
        })
    }

    protected abstract getTypeName(): string;
}

export class MarketsService extends Service<IMarket> {
    protected getTypeName(): string {
        return "Markets";
    }
}

export class DepartmentsService extends Service<IDepartment> {
    protected getTypeName(): string {
        return "Departments";
    }
}

var marketService = new MarketsService();
var topMarket: Promise<IMarket> = marketService.getQueryResults();

var departmentService = new DepartmentsService();
var topDepartment: Promise<IDepartment> = departmentService.getQueryResults();

但与每次使用Service时指定类型的需要不同，这些额外的类将成为已编译的js的一部分，因此这是一个对您来说更重要的问题。

在对象中存储接口

2 个答案:

修改