J'ai beaucoup de tables dans Lovefield et leurs interfaces respectives pour les colonnes qu'elles ont.
Exemple:

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

J'aimerais avoir les noms de propriété de cette interface dans un tableau comme celui-ci:

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

je ne peux pas créer un objet / tableau basé IMyTabledirectement sur l'interface, ce qui devrait faire l'affaire car j'obtiendrais les noms d'interface des tables de manière dynamique. Par conséquent, je dois parcourir ces propriétés dans l'interface et en extraire un tableau.

Comment obtenir ce résultat?

À partir de TypeScript 2.3 (ou devrais-je dire 2.4 , comme dans 2.3 cette fonctionnalité contient un bogue qui a été corrigé dans typescript@2.4-dev ), vous pouvez créer un transformateur personnalisé pour réaliser ce que vous voulez faire.

En fait, j'ai déjà créé un tel transformateur personnalisé, qui permet ce qui suit.

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

Malheureusement, les transformateurs personnalisés ne sont actuellement pas si faciles à utiliser. Vous devez les utiliser avec l' API de transformation TypeScript au lieu d'exécuter la commande tsc. Il y a un problème concernant la prise en charge d'un plugin pour les transformateurs personnalisés.

Ce qui suit vous oblige à lister les clés vous-même, mais au moins TypeScript appliquera IUserProfileet IUserProfileKeysaura exactement les mêmes clés (a Required<T>été ajouté dans TypeScript 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,
};

J'ai eu un problème similaire: j'avais une liste géante de propriétés que je voulais avoir à la fois une interface et un objet en dehors.

REMARQUE: je ne voulais pas écrire (taper avec le clavier) les propriétés deux fois! Juste SEC.

Une chose à noter ici est que les interfaces sont des types imposés au moment de la compilation, tandis que les objets sont principalement exécutés. ( Source )

Comme @derek l'a mentionné dans une autre réponse , le dénominateur commun de l' interface et de l' objet peut être une classe qui sert à la fois un type et une valeur .

Donc, TL; DR, le morceau de code suivant devrait satisfaire les besoins:

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

( Voici le code ci-dessus dans Typescript Playground pour jouer plus)

PS. Si vous ne voulez pas affecter de valeurs initiales aux propriétés de la classe et rester avec le type, vous pouvez faire l'astuce du constructeur:

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

Constructor Trick dans TypeScript Playground .

Cela devrait fonctionner

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

ou

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

Il est peut-être trop tard, mais dans la version 2.1 de dactylographié, vous pouvez utiliser key ofcomme ceci:

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

Au lieu de définir IMyTablecomme dans l'interface, essayez de le définir comme une classe. En typographie, vous pouvez utiliser une classe comme une interface.

Donc, pour votre exemple, définissez / générez votre classe comme ceci:

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

Utilisez-le comme interface:

export class SomeTable implements IMyTable {
    ...
}

Obtenez les clés:

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

Vous devrez créer une classe qui implémente votre interface, l'instancier puis utiliser Object.keys(yourObject) pour obtenir les propriétés.

export class YourClass implements IMyTable {
    ...
}

puis

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

Il n'y a pas de moyen simple de créer un tableau de clés à partir d'une interface. Les types sont effacés au moment de l'exécution et les types d'objets (non ordonnés, nommés) ne peuvent pas être convertis en types tuple (ordonnés, sans nom) sans une sorte de piratage.

Option 1: approche manuelle

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

(+) type de retour de tableau simple (-), pas d'écriture manuelle de tuple (+ -) avec auto-complétion

Extension: Nous pourrions essayer d'être sophistiqués et utiliser des types récursifs pour générer un tuple. Cela n'a fonctionné pour moi que pour quelques accessoires (~ 5,6) jusqu'à ce que les performances se dégradent massivement. Les types récursifs profondément imbriqués ne sont pas non plus officiellement pris en charge par TS - je liste cet exemple ici par souci d'exhaustivité.

Option 2: Générateur de code basé sur l'API du compilateur TS ( 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

Après avoir compilé et exécuté ce fichier avec tsc && node dist/mybuildstep.js, un fichier ./src/generated/IMyTable-keys.tsavec le contenu suivant est généré:

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

(+) solution automatique (+) type de tuple exact (-) nécessite une étape de construction

PS: J'ai choisi ts-morph, car c'est une alternative simple à l'API du compilateur TS d'origine.

Je ne peux pas. Les interfaces n'existent pas au moment de l'exécution.

solution de contournement

Créez une variable du type et utilisez Object.keys-la 🌹

Vous ne pouvez pas le faire. Les interfaces n'existent pas au moment de l'exécution (comme @basarat l'a dit).

Maintenant, je travaille avec:

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