这是一个艰难的问题!谢谢大家的帮助。

我的需要是将接口的键作为字符串数组来简化mocha/chai脚本。不关心在应用程序中使用(还)，所以不需要创建ts文件。感谢ford04的帮助，他上面的解决方案是一个巨大的帮助，它的工作完美，没有编译器黑客。下面是修改后的代码:

选项2:基于TS编译器API的代码生成器(TS -morph)

节点模块

npm install --save-dev ts-morph

keys.ts

注意:这里假设所有ts文件都位于./src的根目录下，并且没有子文件夹，请相应地调整

import {
  Project,
  VariableDeclarationKind,
  InterfaceDeclaration,
} from "ts-morph";

// initName is name of the interface file below the root, ./src is considered the root
const Keys = (intName: string): string[] => {
  const project = new Project();
  const sourceFile = project.addSourceFileAtPath(`./src/${intName}.ts`);
  const node = sourceFile.getInterface(intName)!;
  const allKeys = node.getProperties().map((p) => p.getName());

  return allKeys;
};

export default Keys;

使用

import keys from "./keys";

const myKeys = keys("MyInterface") //ts file name without extension

console.log(myKeys)

如果您不能使用自定义转换器(或不愿意使用)，我认为最好的方法就是我将要展示的方法，它具有以下优点:

它允许“半自动”填充数组(至少在VS Code中); 它会生成一个数组，TypeScript会将其识别为包含接口键的并集元素; 它不涉及降低性能的递归技巧。

方法如下:

interface Foo {
  fizz?: string;
  buzz: number;
}

const FooKeysEnum: { [K in keyof Required<Foo>]: K } = {
  fizz: 'fizz',
  buzz: 'buzz',
};

const FooKeys = Object.values(FooKeysEnum);

VS Code中“半自动”填充数组的原因是，当FooKeysEnum因为缺少属性而出现红色下划线时，你可以将鼠标悬停在它上面，从“快速修复”菜单中选择“添加缺少属性”。(这个好处已经在这篇文章中展示过了，但我认为还没有人提到过。埃塔:我弄错了;自动补全已经在线程的其他地方提到了。)

最后，通过使用Object.values()而不是Object.keys()来创建数组，你可以让TypeScript识别出FooKeys的类型是("fizz" | "buzz")[]。它不知道FooKeys[0]是“fizz”，FooKeys[1]是“buzz”，但仍然比你用Object.keys()得到的字符串[]要好。

编辑:

在VS Code中，你也可以在键盘绑定中设置快捷键。json用于执行“Quick Fix”，这使得它可以更快地触发添加缺失的属性。看起来是这样的:

{
  "key": "shift+cmd+a",
  "command": "editor.action.codeAction",
  "args": {
    "kind": "quickfix",
    "apply": "ifSingle"
  }
}

然后，如果某个东西有红色下划线，你可以单击它并使用键盘快捷键，如果只有一个可用的快速修复选项，那么它将运行。如果有一种方法可以针对特定的快速修复，那就太好了，如果它可以在文件保存时自动完成，那就更好了，但我认为在撰写本文时这是不可能的。

安全的变体

从具有安全编译时检查的接口创建键的数组或元组需要一点创造力。类型在运行时被擦除，对象类型(无序的，命名的)不能在不使用不支持的技术的情况下转换为元组类型(有序的，未命名的)。

与其他答案的比较

在给定IMyTable这样的引用对象类型的情况下，在重复或缺少元组项的情况下，这里提出的变体都考虑/触发编译错误。例如，声明一个数组类型为(keyof IMyTable)[]就不能捕获这些错误。

此外，它们不需要特定的库(最后一个变体使用ts-morph，我认为它是通用的编译器包装)，发出与对象相反的元组类型(只有第一个解决方案创建数组)或宽数组类型(与这些答案相比)，最后不需要类。

变体1:简单类型数组

// Record type ensures, we have no double or missing keys, values can be neglected
function createKeys(keyRecord: Record<keyof IMyTable, any>): (keyof IMyTable)[] {
  return Object.keys(keyRecord) as any
}

const keys = createKeys({ isDeleted: 1, createdAt: 1, title: 1, id: 1 })
// const keys: ("id" | "title" | "createdAt" | "isDeleted")[]

+最简单+-手动自动补全-数组，没有元组

操场上

如果您不喜欢创建记录，可以看看这个具有Set和断言类型的替代方法。

---

变体2:带有helper函数的元组

function createKeys<T extends readonly (keyof IMyTable)[] | [keyof IMyTable]>(
    t: T & CheckMissing<T, IMyTable> & CheckDuplicate<T>): T {
    return t
}

+ tuple +-手动自动补全+-更高级，更复杂的类型

操场上

解释

createKeys通过将函数参数类型与附加断言类型合并来进行编译时检查，这些断言类型会在不合适的输入时发出错误。(keyof IMyTable)[] | [keyof IMyTable]是一种“黑魔法”方式，从被调用方强制推断一个元组而不是一个数组。或者，你可以从调用方使用const断言/作为const。

CheckMissing检查，如果T错过了U的键:

type CheckMissing<T extends readonly any[], U extends Record<string, any>> = {
    [K in keyof U]: K extends T[number] ? never : K
}[keyof U] extends never ? T : T & "Error: missing keys"

type T1 = CheckMissing<["p1"], {p1:any, p2:any}> //["p1"] & "Error: missing keys"
type T2 = CheckMissing<["p1", "p2"], { p1: any, p2: any }> // ["p1", "p2"]

注意:T和“错误:缺少键”只是IDE错误。你也可以写成never。checkduplicate检查双元组项:

type CheckDuplicate<T extends readonly any[]> = {
    [P1 in keyof T]: "_flag_" extends
    { [P2 in keyof T]: P2 extends P1 ? never :
        T[P2] extends T[P1] ? "_flag_" : never }[keyof T] ?
    [T[P1], "Error: duplicate"] : T[P1]
}

type T3 = CheckDuplicate<[1, 2, 3]> // [1, 2, 3]
type T4 = CheckDuplicate<[1, 2, 1]> 
// [[1, "Error: duplicate"], 2, [1, "Error: duplicate"]]

注意:关于元组中唯一项检查的更多信息在这篇文章中。在TS 4.1中，我们还可以在错误字符串中命名缺失的键-看看这个Playground。

---

变体3:递归类型

在4.1版中，TypeScript正式支持条件递归类型，这里也可以使用它。然而，由于组合的复杂性，类型计算是昂贵的——超过5-6个项目的性能会大幅下降。为了完整起见，我列出了这个替代方案(Playground):

type Prepend<T, U extends any[]> = [T, ...U] // TS 4.0 variadic tuples

type Keys<T extends Record<string, any>> = Keys_<T, []>
type Keys_<T extends Record<string, any>, U extends PropertyKey[]> =
  {
    [P in keyof T]: {} extends Omit<T, P> ? [P] : Prepend<P, Keys_<Omit<T, P>, U>>
  }[keyof T]

const t1: Keys<IMyTable> = ["createdAt", "isDeleted", "id", "title"] // ✔

+ tuple +-手动自动补全+无辅助功能——性能

---

变体4:代码生成器/ TS编译器API

这里选择TS -morph，因为它是原始TS编译器API的简单包装器替代品。当然，也可以直接使用编译器API。让我们看看生成器代码:

// ./src/mybuildstep.ts
import {Project, VariableDeclarationKind, InterfaceDeclaration } from "ts-morph";

const project = new Project();
// source file with IMyTable interface
const sourceFile = project.addSourceFileAtPath("./src/IMyTable.ts"); 
// target file to write the keys string array to
const destFile = project.createSourceFile("./src/generated/IMyTable-keys.ts", "", {
  overwrite: true // overwrite if exists
}); 

function createKeys(node: InterfaceDeclaration) {
  const allKeys = node.getProperties().map(p => p.getName());
  destFile.addVariableStatement({
    declarationKind: VariableDeclarationKind.Const,
    declarations: [{
        name: "keys",
        initializer: writer =>
          writer.write(`${JSON.stringify(allKeys)} as const`)
    }]
  });
}

createKeys(sourceFile.getInterface("IMyTable")!);
destFile.saveSync(); // flush all changes and write to disk

在我们用tsc && node dist/mybuildstep.js编译并运行这个文件之后，一个文件./src/generated/IMyTable-keys。生成内容如下的Ts:

// ./src/generated/IMyTable-keys.ts
const keys = ["id","title","createdAt","isDeleted"] as const;

+自动生成解决方案+可扩展的多个属性+无辅助功能+元组-额外的构建步骤-需要熟悉编译器API

我也遇到过类似的问题:我有一个巨大的属性列表，我既想将其作为接口(编译时)，也想将其作为对象(运行时)。

注意:我不想写(用键盘输入)两次属性!干了。

---

这里需要注意的一点是，接口是在编译时强制执行的类型，而对象主要是在运行时强制执行的类型。(源)

正如@derek在另一个回答中提到的，接口和对象的共同点可以是同时服务于类型和值的类。

因此，TL;DR，下面的一段代码应该可以满足需求:

class MyTableClass {
    // list the propeties here, ONLY WRITTEN ONCE
    id = "";
    title = "";
    isDeleted = false;
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// This is the pure interface version, to be used/exported
interface IMyTable extends MyTableClass { };

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// Props type as an array, to be exported
type MyTablePropsArray = Array<keyof IMyTable>;

// Props array itself!
const propsArray: MyTablePropsArray =
    Object.keys(new MyTableClass()) as MyTablePropsArray;

console.log(propsArray); // prints out  ["id", "title", "isDeleted"]


// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// Example of creating a pure instance as an object
const tableInstance: MyTableClass = { // works properly!
    id: "3",
    title: "hi",
    isDeleted: false,
};

(这里是上面的Typescript Playground代码，可以玩更多)

PS.如果你不想给类中的属性赋初始值，而保持类型，你可以使用构造函数技巧:

class MyTableClass {
    // list the propeties here, ONLY WRITTEN ONCE
    constructor(
        readonly id?: string,
        readonly title?: string,
        readonly isDeleted?: boolean,
    ) {}
}

console.log(Object.keys(new MyTableClass()));  // prints out  ["id", "title", "isDeleted"] 

TypeScript游乐场中的构造函数技巧。

这应该可以

var IMyTable: Array<keyof IMyTable> = ["id", "title", "createdAt", "isDeleted"];

or

var IMyTable: (keyof IMyTable)[] = ["id", "title", "createdAt", "isDeleted"];

// declarations.d.ts
export interface IMyTable {
      id: number;
      title: string;
      createdAt: Date;
      isDeleted: boolean
}
declare var Tes: IMyTable;
// call in annother page
console.log(Tes.id);