Mam wiele tabel w Lovefield i odpowiadających im interfejsów dla posiadanych kolumn.
Przykład:

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

Chciałbym mieć nazwy właściwości tego interfejsu w tablicy takiej jak ta:

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

nie mogę utworzyć obiektu / tablicy IMyTablebezpośrednio na podstawie interfejsu, co powinno załatwić sprawę, ponieważ dynamicznie otrzymywałbym nazwy interfejsów tabel. Dlatego muszę iterować te właściwości w interfejsie i uzyskać z niego tablicę.

Jak osiągnąć ten wynik?

Od TypeScript 2.3 (lub powinienem powiedzieć 2.4 , ponieważ w 2.3 ta funkcja zawiera błąd, który został naprawiony w typescript@2.4-dev ), możesz utworzyć niestandardowy transformator, aby osiągnąć to, co chcesz zrobić.

Właściwie już stworzyłem taki niestandardowy transformator, który umożliwia co następuje.

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

Niestety niestandardowe transformatory nie są obecnie tak łatwe w użyciu. Musisz ich używać z interfejsem API transformacji TypeScript zamiast wykonywać polecenie tsc. Wystąpił problem z żądaniem obsługi wtyczki dla niestandardowych transformatorów.

Poniższa wymaga notować klucze na własną rękę, ale przynajmniej maszynopis wymusi IUserProfilei IUserProfileKeysmają te same klucze ( Required<T>dodano w maszynopisie 2.8 ):

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

Miałem podobny problem, że miałem gigantyczną listę właściwości, które chciałem mieć zarówno interfejs, jak i obiekt z niego.

UWAGA: Nie chciałem pisać (wpisywać za pomocą klawiatury) właściwości dwa razy! Po prostu SUCHY.

Należy tu zauważyć, że interfejsy są wymuszonymi typami w czasie kompilacji, podczas gdy obiekty są głównie w czasie wykonywania. ( Źródło )

Jak @derek wspomniał w innej odpowiedzi , wspólnym mianownikiem interfejsu i obiektu może być klasa, która obsługuje zarówno typ, jak i wartość .

Tak więc, TL; DR, następujący fragment kodu powinien zaspokoić potrzeby:

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

( Oto powyższy kod w Typescript Playground, aby odtworzyć więcej)

PS. Jeśli nie chcesz przypisywać początkowych wartości właściwościom w klasie i pozostać przy typie, możesz zrobić sztuczkę konstruktora:

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

Sztuczka konstruktora w zabawie TypeScript .

Może jest już za późno, ale w wersji 2.1 maszynopisu możesz użyć w key often sposób:

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

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

To powinno działać

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

lub

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

Bezpieczne warianty

Tworzenie tablicy lub krotki kluczy z poziomu interfejsu z kontrolą bezpieczeństwa w czasie kompilacji wymaga trochę kreatywności. Typy są usuwane w czasie wykonywania, a typy obiektów (nieuporządkowane, nazwane) nie mogą być konwertowane na typy krotek (uporządkowane, bez nazw) bez uciekania się do nieobsługiwanych technik .

Porównanie z innymi odpowiedziami

Wszystkie proponowane warianty uwzględniają / wywołują błąd kompilacji w przypadku zduplikowanych lub brakujących elementów krotki, biorąc pod uwagę typ obiektu odniesienia, taki jak IMyTable. Na przykład zadeklarowanie typu tablicy (keyof IMyTable)[]nie może wychwycić tych błędów.

Ponadto nie wymagają konkretnej biblioteki (ostatnie zastosowania wariantu ts-morph, które rozważałbym jako ogólny wrapper kompilatora), emitują typ krotki w przeciwieństwie do obiektu (tylko pierwsze rozwiązanie tworzy tablicę) lub typ szerokiej tablicy (w porównaniu do te odpowiedzi ) i wreszcie nie potrzebują zajęć .

Wariant 1: prosta tablica typu

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

+najłatwiejszy +-podręcznik z -tablicą autouzupełniania , bez krotki

Plac zabaw

Jeśli nie lubisz tworzyć rekordów, spójrz na tę alternatywę z Settypami asercji i .

Wariant 2: krotka z funkcją pomocniczą

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

++-instrukcja krotki z automatycznym uzupełnianiem, +-bardziej zaawansowane, złożone typy

Plac zabaw

Wyjaśnienie

createKeyswykonuje kontrole w czasie kompilacji, łącząc typ parametru funkcji z dodatkowymi typami asercji, które generują błąd dla nieodpowiednich danych wejściowych. (keyof IMyTable)[] | [keyof IMyTable]jest "czarną magią" sposobem na wymuszenie wnioskowania krotki zamiast tablicy po stronie wywoływanej. Alternatywnie możesz użyć potwierdzenia const /as const po stronie wywołującego.

CheckMissingsprawdza, jeśli Tbrakuje kluczy z 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"]

Uwaga: T & "Error: missing keys"dotyczy tylko ładnych błędów IDE. Możesz też pisać never. CheckDuplicatessprawdza elementy z podwójną krotką:

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

Uwaga: Więcej informacji na temat sprawdzania unikalnych przedmiotów w krotkach znajduje się w tym poście . Dzięki TS 4.1 możemy również nazwać brakujące klucze w ciągu błędu - spójrz na ten Playground .

Wariant 3: typ rekurencyjny

W wersji 4.1 TypeScript oficjalnie obsługuje warunkowe typy rekurencyjne , które mogą być tutaj również potencjalnie użyte. Chociaż obliczenia typu są kosztowne ze względu na złożoność kombinacyjną - wydajność znacznie spada dla więcej niż 5-6 pozycji. Podaję tę alternatywę dla kompletności ( 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"] // ✔

++-instrukcja krotki z automatycznym uzupełnianiem +brak --działania funkcji pomocniczej

Wariant 4: Generator kodu / API kompilatora TS

Tutaj wybrano ts-morph , ponieważ jest to odrobinę prostsza alternatywa opakowania dla oryginalnego API kompilatora TS . Oczywiście możesz również bezpośrednio użyć interfejsu API kompilatora. Spójrzmy na kod generatora:

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

Po skompilowaniu i uruchomieniu tego pliku tsc && node dist/mybuildstep.js, ./src/generated/IMyTable-keys.tsgenerowany jest plik o następującej zawartości:

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

+rozwiązanie automatycznie generujące +skalowalne dla wielu właściwości +żadna funkcja pomocnicza +krotka -dodatkowy krok kompilacji -wymaga znajomości interfejsu API kompilatora

Zamiast definiować IMyTablejak w interfejsie, spróbuj zdefiniować go jako klasę. W maszynopisie możesz użyć klasy takiej jak interfejs.

Na przykład zdefiniuj / wygeneruj swoją klasę w następujący sposób:

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

Użyj go jako interfejsu:

export class SomeTable implements IMyTable {
    ...
}

Zdobądź klucze:

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

Będziesz musiał utworzyć klasę, która implementuje twój interfejs, utworzyć jej instancję, a następnie użyć jej Object.keys(yourObject)do pobrania właściwości.

export class YourClass implements IMyTable {
    ...
}

następnie

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

Żargon. Interfejsy nie istnieją w czasie wykonywania.

obejście

Utwórz zmienną tego typu i użyj Object.keysna niej 🌹

To było trudne! Dziękuję wszystkim za pomoc.

Moją potrzebą było uzyskanie kluczy interfejsu jako tablicy ciągów w celu uproszczenia skryptów mocha / chai. Nie martwię się o używanie w aplikacji (jeszcze), więc nie trzeba było tworzyć plików ts. Dzięki ford04 za pomoc, jego rozwiązanie powyżej było ogromną pomocą i działa idealnie, BEZ hacków kompilatora. Oto zmodyfikowany kod:

Opcja 2: Generator kodu oparty na API kompilatora TS (ts-morph)

Moduł węzła

npm install --save-dev ts-morph

keys.ts

UWAGA : zakłada się, że wszystkie pliki ts znajdują się w katalogu głównym ./src i nie ma podfolderów, dostosuj odpowiednio

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;

stosowanie

import keys from "./keys";

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

console.log(myKeys)

Nie możesz tego zrobić. Interfejsy nie istnieją w czasie wykonywania (jak powiedział @basarat ).

Teraz pracuję z następującymi elementami:

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