TypeScript - 仅提取接口成员 - 可能吗？

Question

有没有办法从属于接口的对象中动态提取成员（即不再明确指定它们），如下所示：

let subset = { ...someObject as ISpecific }; 

目前我得到了 someObject 碰巧拥有的所有成员。 所以扩展运算符在这里不起作用。有没有办法做到这一点？

例子：

interface ISpecific { A: string; B: string; }
class Extended implements ISpecific { public A: string = '1'; public B: string = '2'; public C: string = '3'; }

let someObject = new Extended(); 
let subset = { ...someObject as ISpecific }; 
console.log(subset);  // -> { A, B, C } but want { A, B }

TypeScript 转换只是对编译器的提示，而不是运行时的真正转换。

Answer 1

更新：这似乎不起作用，所以不是答案。

let subset = Object.create(someObject as ISpecific); 

Object.create 使用指定的原型创建一个新对象，但 TypeScript 转换只是对编译器的提示。它可能使用具体的类层次结构然后引用原型来工作，但这可能包括比接口声明的更多的实际成员。

Answer 2

如果你想限制你使用的类型，你可以简单而安全地做到这一点：

let subset = someObject as ISpecific; 

subset 上的属性仍将存在，但编译器会阻止您依赖它们，即subset.age 将在下面失败，尽管该属性确实仍然存在。

interface ISpecific {
    name: string;
}

const someObject = {
    name: 'Fenton',
    age: 21
};

let subset = someObject as ISpecific; 

console.log(subset.age);

你可以真的通过像这样解构来放弃属性，危险在于你需要在...subset之前的列表中包含“所有我不想要的东西”。

interface ISpecific {
    name: string;
}

const someObject = {
    name: 'Fenton',
    age: 21
};

let { age, ...subset } = someObject;   

console.log(JSON.stringify(someObject));
console.log(JSON.stringify(subset));

Answer 3

由于 typescript 接口在运行时不存在，我们不能使用它们来指导任何运行时行为，只能在编译时进行类型检查。然而，我们可以创建一个与接口具有相同属性的对象（具有true 类型的所有属性，例如以简化初始化），如果该对象具有比接口更多或更少的字段，则使编译器触发错误。我们可以使用这个对象作为我们提取哪些属性的指南：

function extract<T>(properties: Record<keyof T, true>){
    return function<TActual extends T>(value: TActual){
        let result = {} as T;
        for (const property of Object.keys(properties) as Array<keyof T>) {
            result[property] = value[property];
        }
        return result;
    }
}

interface ISpecific { A: string; B: string; }
const extractISpecific = extract<ISpecific>({ 
    // This object literal is guaranteed by the compiler to have no more and no less properties then ISpecific
    A: true,
    B: true
})
class Extended implements ISpecific { public A: string = '1'; public B: string = '2'; public C: string = '3'; }

let someObject = new Extended(); 
let subset = extractISpecific(someObject); 

Answer 4

可以使用装饰器来实现（见文末要求）。 它只能与方法一起使用（复制属性 get/set 访问器只会产生它的瞬时返回值，而不是访问器函数）。

// define a decorator (@publish) for marking members of a class for export: 
function publish(targetObj: object, memberKey: string, descriptor: PropertyDescriptor) { 
    if (!targetObj['_publishedMembers']) 
        targetObj['_publishedMembers'] = []; 
    targetObj['_publishedMembers'].push(memberKey); 
}

// this function can return the set of members of an object marked with the @publish decorator: 
function getPublishedMembers(fromObj: object) {
    const res = {}; 
    const members = fromObj['_publishedMembers'] || []; 
    members.forEach(member => { res[member] = fromObj[member].bind(fromObj); }); 
    return res; 
}

// this is for making sure all members are implemented (does not make sure about being marked though): 
interface IPublishedMembers {
    A(): string; 
    B(): number; 
    C(): void; 
}

// this class implements the interface and has more members (that we do NOT want to expose): 
class Full implements IPublishedMembers {
    private b: number = 0xb; 

    @publish public A(): string { return 'a'; }
    @publish public B(): number { return this.b; }
    @publish public C(): boolean { return true; }
    public D(): boolean { return !this.C(); } 
    public E(): void { } 
}

const full = new Full(); 
console.log(full);  // -> all members would be exposed { A(), B(), b, C(), D(), E() }

const published = getPublishedMembers(full) as IPublishedMembers; 
console.log(published);  // -> only sanctioned members { A(), B(), C() }
console.log(published.B());  // -> 11 = 0xb (access to field of original object works)

（这需要 tsconfig.json 中的 compilerOption "experimentalDecorators":true 和一个 ES5 目标，更多信息请参见 http://www.typescriptlang.org/docs/handbook/decorators.html）

Answer 5

很遗憾，您需要指定并重复这些部分。

export interface Machine {
  id: string;
  name: string;
  logo: string;
  location: Location;
  products: Item[];
  restriction: string;
  categories: string[];
  star: number;
  distance: number;
}

export interface MachineIdentification {
  id: string;
  name: string;
  logo: string;
  location: Location;
}

//Object Destructuring fat object in parts
const {id, name, logo, location} = machine; 

//Compose a ligth object from parts and apply interface type
const mi: MachineIdentification = {id, name, logo, location}; 

Answer 6

我遇到的另一个简单选项是使用 lodash 的 pick 函数。这有点乏味，但做得很好。

首先，定义一个代表您的界面的类。稍后您将需要它来轻松创建该类的对象。

class Specific {
  constructor(readonly a?: string, readonly b?: string) {}
}
interface ISpecific extends Specific {}
interface IExtended extends ISpecific {
  c: string;
}

那么假设这是您要从中提取数据的原始对象：

const extended: IExtended = { a: 'type', b: 'script', c: 'is cool' };

现在是有趣的部分。基于类的新实例化获取Specific 键的列表，以及来自原始对象的pick 这些成员。
换句话说：

const specificMembers: string[] = Object.keys(new Specific());
const specific: ISpecific = lodash.pick(extended, specificMembers);
console.log(specific); // {a: "type", b: "script"}

瞧！ :)