Ho molte tabelle in Lovefield e le rispettive interfacce per le colonne che hanno.
Esempio:

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

Mi piacerebbe avere i nomi delle proprietà di questa interfaccia in un array come questo:

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

non posso creare un oggetto / array basato IMyTabledirettamente sull'interfaccia che dovrebbe fare il trucco perché otterrei dinamicamente i nomi dell'interfaccia delle tabelle. Quindi ho bisogno di iterare su queste proprietà nell'interfaccia e ricavarne un array.

Come ottengo questo risultato?

A partire da TypeScript 2.3 (o dovrei dire 2.4 , poiché in 2.3 questa funzione contiene un bug che è stato corretto in typescript@2.4-dev ), puoi creare un trasformatore personalizzato per ottenere ciò che vuoi fare.

In realtà, ho già creato un trasformatore personalizzato, che consente quanto segue.

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

Sfortunatamente, i trasformatori personalizzati attualmente non sono così facili da usare. Devi usarli con l' API di trasformazione TypeScript invece di eseguire il comando tsc. Si è verificato un problema durante la richiesta di un supporto plug-in per trasformatori personalizzati.

Quanto segue richiede di elencare le chiavi da solo, ma almeno TypeScript applicherà IUserProfilee IUserProfileKeysavrà le stesse identiche chiavi (è Required<T>stato aggiunto in 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,
};

Ho avuto un problema simile che avevo un enorme elenco di proprietà che volevo avere sia un'interfaccia che un oggetto da essa.

NOTA: non volevo scrivere (digitare con la tastiera) le proprietà due volte! Solo ASCIUTTO.

Una cosa da notare qui è che le interfacce sono tipi applicati in fase di compilazione, mentre gli oggetti sono per lo più in fase di esecuzione. ( Fonte )

Come @derek ha menzionato in un'altra risposta , il denominatore comune di interfaccia e oggetto può essere una classe che serve sia un tipo che un valore .

Quindi, TL; DR, il seguente pezzo di codice dovrebbe soddisfare le esigenze:

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

( Ecco il codice sopra in Typescript Playground per giocare di più)

PS. Se non vuoi assegnare valori iniziali alle proprietà nella classe e rimanere con il tipo, puoi eseguire il trucco del costruttore:

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

Trucco del costruttore in TypeScript Playground .

Questo dovrebbe funzionare

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

o

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

Forse è troppo tardi, ma nella versione 2.1 del dattiloscritto puoi usare in key ofquesto modo:

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

Invece di definire IMyTablecome interfaccia, prova a definirlo come una classe. Nel dattiloscritto puoi usare una classe come un'interfaccia.

Quindi, per il tuo esempio, definisci / genera la tua classe in questo modo:

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

Usalo come interfaccia:

export class SomeTable implements IMyTable {
    ...
}

Ottieni chiavi:

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

Dovrai creare una classe che implementa la tua interfaccia, istanziarla e quindi usarla Object.keys(yourObject)per ottenere le proprietà.

export class YourClass implements IMyTable {
    ...
}

poi

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

Non esiste un modo semplice per creare un array di chiavi da un'interfaccia. I tipi vengono cancellati in fase di esecuzione e i tipi di oggetto (non ordinati, denominati) non possono essere convertiti in tipi di tupla (ordinati, senza nome) senza una sorta di hack.

Opzione 1: approccio manuale

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

(+) semplice (-) tipo restituito da array, nessuna scrittura manuale di tupla (+ -) con completamento automatico

Estensione: potremmo provare a essere fantasiosi e utilizzare tipi ricorsivi per generare una tupla. Questo ha funzionato per me solo per un paio di oggetti di scena (~ 5,6) fino a quando le prestazioni non si sono degradate in modo massiccio. Anche il tipo ricorsivo profondamente annidato non è ufficialmente supportato da TS: elenco questo esempio qui per completezza.

Opzione 2: generatore di codice basato sull'API del compilatore 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

Dopo aver compilato ed eseguito questo file con tsc && node dist/mybuildstep.js, ./src/generated/IMyTable-keys.tsviene generato un file con il seguente contenuto:

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

(+) soluzione automatica (+) il tipo esatto di tupla (-) richiede build-step

PS: ho scelto ts-morph, in quanto è una semplice alternativa all'API del compilatore TS originale.

Non posso. Le interfacce non esistono in fase di esecuzione.

soluzione alternativa

Crea una variabile del tipo e Object.keysusala 🌹

Non puoi farlo. Le interfacce non esistono in fase di esecuzione (come @basarat detto ).

Ora sto lavorando con quanto segue:

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