Javascript 在对象中存储接口

假设我有以下接口

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

导出类服务{
受保护的baseURL=“”；
受保护的typeName=“”；
私有类型映射={Markets:IMarket，Departments:IDepartment}
构造函数（类型名）{
此.baseURL=http://localhost/API/odata/“+字体名称；
this.currentType=typeMap[typeName]；
}
getQueryResults（）：承诺{
返回新承诺（（解决、拒绝）=>{
$.getJSON（this.baseURL，函数（returnValue）{
解析（returnValue.value）；
});
})
}
}
var marketService=新服务（“市场”）；
var topMarket=marketService.getQueryResults（）；
//topMarket是IMarket的一个例子
var部门服务=新服务（“部门”）；
var topDepartment=departmentServicegetQueryResults（）；
//topDepartment是IdeDepartment的一个实例（？）

从TypeScript文档中记下注意事项：

似乎您希望：

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

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

---

这可以简单地用以下方法解决，这正是它的用途：

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();

导出类服务{
受保护的baseURL=“”；
构造函数（）{
此.baseURL=http://localhost/API/odata/“+字体名称；
}
getQueryResults（）：承诺{
返回新承诺（（解决、拒绝）=>{
$.getJSON（this.baseURL，函数（returnValue）{
解析（returnValue.value）；
});
})
}
}
var marketService=新服务（）；
var topMarket:Promise=marketService.getQueryResults（）；
var departmentService=新服务（）；
var topDepartment:Promise=departmentService.getQueryResults（）；

---

编辑 您可以使用另外两个类来“摆脱”对

服务的多次需求（每种类型）：

导出抽象类服务{
受保护的baseURL=“”；
构造函数（）{
此.baseURL=http://localhost/API/odata/“+this.getTypeName（）；
}
getQueryResults（）：承诺{
返回新承诺（（解决、拒绝）=>{
$.getJSON（this.baseURL，函数（returnValue）{
解析（returnValue.value）；
});
})
}
受保护的抽象getTypeName（）：字符串；
}
导出类市场服务扩展服务{
受保护的getTypeName（）：字符串{
回归“市场”；
}
}
导出类部门服务扩展服务{
受保护的getTypeName（）：字符串{
返回“部门”；
}
}
var marketService=新市场服务（）；
var topMarket:Promise=marketService.getQueryResults（）；
var departmentService=新部门服务（）；
var topDepartment:Promise=departmentService.getQueryResults（）；

但是，与每次使用
服务时都需要指定类型不同，这些额外的类将是编译后的js的一部分，因此这是一个对您更重要的问题。
定义“存储”。是否希望在运行时使用此对象？你想用它做什么？是的，我喜欢在运行时使用它。我想做一些像这样的事。不，你不能那样做。接口在运行时不存在，它仅用于编译，编译后的javascript没有接口。如果你解释一下你想做什么，你可能会有其他选择。只是添加了一个更详细的解释，我是TypeScript新手，所以我想有一个更好的方法来实现这一点，但这只是我想到的第一个实现我要做的事情的方法。我希望在服务类中实现它。每次创建对象时都必须指定类型似乎很奇怪，因为它总是与传递给构造函数的“typeName”变量相关联而不是像
新服务（“市场”）
我只是觉得在每个typescript文件中都必须包含该类型很烦人，我更愿意将其包含在服务文件中。好吧，在您的代码中，除了使用它来决定您在承诺中返回的类型之外，这个
typeName
没有明显的用途，所以我只是删除了它。不幸的是，您需要这种双重性，因为正如我所写的，这些接口在运行时不可用，但同样，如果您能详细解释您的场景，那么我（或其他人）可以想出其他解决方案。
typeName
被添加到构造函数中的
this.baseURL
，对。我错过了，我的错。嗯，我想不出比泛型更简单的解决方案，但我不认为这是不好的，因为将url路径与接口绑定似乎是一个让人后悔的想法。如果明天您需要一项服务，该服务应向
IMarket
s数组返回承诺，该怎么办？
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();

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();