Ich habe viele Tabellen in Lovefield und ihre jeweiligen Schnittstellen für die Spalten, die sie haben.
Beispiel:

export interface IMyTable {
  id: number;
  title: string;
  createdAt: Date;
  isDeleted: boolean;
}

Ich möchte die Eigenschaftsnamen dieser Schnittstelle in einem Array wie diesem haben:

const IMyTable = ["id", "title", "createdAt", "isDeleted"];

Ich kann kein Objekt / Array basierend auf der Schnittstelle IMyTabledirekt erstellen, was den Trick tun sollte, da ich die Schnittstellennamen der Tabellen dynamisch erhalten würde. Daher muss ich diese Eigenschaften in der Schnittstelle durchlaufen und ein Array daraus erstellen.

Wie erreiche ich dieses Ergebnis?

Ab TypeScript 2.3 (oder sollte ich 2.4 sagen , da diese Funktion in 2.3 einen Fehler enthält, der in [email protected] behoben wurde ) können Sie einen benutzerdefinierten Transformator erstellen, um das zu erreichen, was Sie tun möchten.

Eigentlich habe ich schon einen solchen kundenspezifischen Transformator erstellt, der Folgendes ermöglicht.

https://github.com/kimamula/ts-transformer-keys

import { keys } from 'ts-transformer-keys';

interface Props {
  id: string;
  name: string;
  age: number;
}
const keysOfProps = keys<Props>();

console.log(keysOfProps); // ['id', 'name', 'age']

Leider sind kundenspezifische Transformatoren derzeit nicht so einfach zu bedienen. Sie müssen sie mit der TypeScript- Transformations-API verwenden, anstatt den Befehl tsc auszuführen. Es gibt ein Problem , bei dem eine Plugin-Unterstützung für benutzerdefinierte Transformatoren angefordert wird.

Im Folgenden müssen Sie die Schlüssel selbst auflisten, aber mindestens TypeScript erzwingt IUserProfileund verfügt IUserProfileKeysüber genau dieselben Schlüssel ( Required<T>wurde in TypeScript 2.8 hinzugefügt ):

export interface IUserProfile  {
  id: string;
  name: string;
};
type KeysEnum<T> = { [P in keyof Required<T>]: true };
const IUserProfileKeys: KeysEnum<IUserProfile> = {
  id: true,
  name: true,
};

Ich hatte ein ähnliches Problem, dass ich eine riesige Liste von Eigenschaften hatte, für die ich sowohl eine Schnittstelle als auch ein Objekt haben wollte.

HINWEIS: Ich wollte die Eigenschaften nicht zweimal schreiben (mit Tastatur eingeben)! Einfach trocken.

Hierbei ist zu beachten, dass Schnittstellen zur Kompilierungszeit erzwungene Typen sind, während Objekte meistens zur Laufzeit ausgeführt werden. ( Quelle )

Wie @derek in einer anderen Antwort erwähnt hat , kann der gemeinsame Nenner von Schnittstelle und Objekt eine Klasse sein, die sowohl einem Typ als auch einem Wert dient .

Also, TL; DR, der folgende Code sollte die Anforderungen erfüllen:

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,
};

( Hier ist der obige Code in Typescript Playground, um mehr zu spielen)

PS. Wenn Sie den Eigenschaften in der Klasse keine Anfangswerte zuweisen und beim Typ bleiben möchten, können Sie den Konstruktortrick ausführen:

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"] 

Konstruktor-Trick auf dem TypeScript-Spielplatz .

Das sollte funktionieren

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

oder

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

IMyTableVersuchen Sie, es als Klasse zu definieren, anstatt es wie in der Schnittstelle zu definieren. In Typoskript können Sie eine Klasse wie eine Schnittstelle verwenden.

Definieren / generieren Sie Ihre Klasse für Ihr Beispiel folgendermaßen:

export class IMyTable {
    constructor(
        public id = '',
        public title = '',
        public createdAt: Date = null,
        public isDeleted = false
    )
}

Verwenden Sie es als Schnittstelle:

export class SomeTable implements IMyTable {
    ...
}

Schlüssel erhalten:

const keys = Object.keys(new IMyTable());

Sie müssen eine Klasse erstellen, die Ihre Schnittstelle implementiert, instanziieren und dann verwenden Object.keys(yourObject), um die Eigenschaften abzurufen.

export class YourClass implements IMyTable {
    ...
}

dann

let yourObject:YourClass = new YourClass();
Object.keys(yourObject).forEach((...) => { ... });

Kippen. Schnittstellen existieren zur Laufzeit nicht.

Problemumgehung

Erstellen Sie eine Variable des Typs und verwenden Sie Object.keyssie 🌹

Vielleicht ist es zu spät, aber in Version 2.1 des Typoskripts können Sie Folgendes verwenden key of:

interface Person {
    name: string;
    age: number;
    location: string;
}

type K1 = keyof Person; // "name" | "age" | "location"
type K2 = keyof Person[];  // "length" | "push" | "pop" | "concat" | ...
type K3 = keyof { [x: string]: Person };  // string

Doc: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-1.html#keyof-and-lookup-types

Es gibt keine einfache Möglichkeit, ein Schlüsselarray über eine Schnittstelle zu erstellen. Typen werden zur Laufzeit gelöscht und Objekttypen (ungeordnet, benannt) können nicht ohne irgendeine Art von Hack in Tupeltypen (geordnet, unbenannt) konvertiert werden.

Option 1: Manueller Ansatz

// 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")[]

(+) einfacher (-) Array-Rückgabetyp, kein Tupel (+ -) manuelles Schreiben mit automatischer Vervollständigung

Erweiterung: Wir könnten versuchen, ausgefallen zu sein und rekursive Typen zu verwenden, um ein Tupel zu generieren. Dies funktionierte nur für ein paar Requisiten (~ 5,6), bis sich die Leistung massiv verschlechterte. Tief verschachtelte rekursive Typen werden von TS auch nicht offiziell unterstützt . Der Vollständigkeit halber liste ich dieses Beispiel hier auf.

Option 2: Codegenerator basierend auf der TS-Compiler-API ( ts-morph )

// ./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

Nachdem wir diese Datei kompiliert und ausgeführt haben tsc && node dist/mybuildstep.js, wird eine Datei ./src/generated/IMyTable-keys.tsmit folgendem Inhalt generiert:

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

(+) automatische Lösung (+) exakter Tupeltyp (-) erfordert Build-Schritt

PS: Ich habe mich entschieden ts-morph, da es eine einfache Alternative zur ursprünglichen TS-Compiler-API ist.

Du kannst es nicht tun. Zur Laufzeit gibt es keine Schnittstellen (wie @basarat sagte).

Jetzt arbeite ich mit Folgendem:

const IMyTable_id = 'id';
const IMyTable_title = 'title';
const IMyTable_createdAt = 'createdAt';
const IMyTable_isDeleted = 'isDeleted';

export const IMyTable_keys = [
  IMyTable_id,
  IMyTable_title,
  IMyTable_createdAt,
  IMyTable_isDeleted,
];

export interface IMyTable {
  [IMyTable_id]: number;
  [IMyTable_title]: string;
  [IMyTable_createdAt]: Date;
  [IMyTable_isDeleted]: boolean;
}

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