Tengo muchas tablas en Lovefield y sus respectivas interfaces para las columnas que tienen.
Ejemplo:

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

Me gustaría tener los nombres de propiedad de esta interfaz en una matriz como esta:

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

no puedo crear un objeto / matriz basado en la interfaz IMyTabledirectamente, lo que debería funcionar porque obtendría los nombres de la interfaz de las tablas de forma dinámica. Por lo tanto, necesito iterar sobre estas propiedades en la interfaz y obtener una matriz.

¿Cómo consigo este resultado?

A partir de TypeScript 2.3 (o debería decir 2.4 , ya que en 2.3 esta función contiene un error que se ha corregido en typescript@2.4-dev ), puede crear un transformador personalizado para lograr lo que desea hacer.

En realidad, ya he creado un transformador personalizado de este tipo, que permite lo siguiente.

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

Desafortunadamente, los transformadores personalizados actualmente no son tan fáciles de usar. Debe usarlos con la API de transformación de TypeScript en lugar de ejecutar el comando tsc. Existe un problema al solicitar un complemento de soporte para transformadores personalizados.

Lo siguiente requiere que enumere las claves por su cuenta, pero al menos TypeScript se aplicará IUserProfiley IUserProfileKeystendrá exactamente las mismas claves ( Required<T>se agregó en 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,
};

Tuve un problema similar: tenía una lista gigante de propiedades para las que quería tener una interfaz y un objeto fuera de ella.

NOTA: ¡No quería escribir (escribir con el teclado) las propiedades dos veces! Solo SECO.

Una cosa a tener en cuenta aquí es que las interfaces son tipos obligatorios en tiempo de compilación, mientras que los objetos son principalmente en tiempo de ejecución. ( Fuente )

Como @derek mencionó en otra respuesta , el denominador común de interfaz y objeto puede ser una clase que sirve tanto para un tipo como para un valor .

Entonces, TL; DR, el siguiente fragmento de código debería satisfacer las necesidades:

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

( Aquí está el código anterior en Typecript Playground para jugar más)

PD. Si no desea asignar valores iniciales a las propiedades en la clase y permanecer con el tipo, puede hacer el truco del constructor:

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

Truco de constructor en TypeScript Playground .

Esto debería funcionar

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

o

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

Tal vez sea demasiado tarde, pero en la versión 2.1 de mecanografiado puede usar key ofasí:

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

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

En lugar de definir IMyTablecomo en interfaz, intente definirlo como una clase. En mecanografiado puedes usar una clase como una interfaz.

Entonces, para su ejemplo, defina / genere su clase de esta manera:

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

Úselo como interfaz:

export class SomeTable implements IMyTable {
    ...
}

Obtener claves:

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

Necesitará crear una clase que implemente su interfaz, instanciarla y luego usarla Object.keys(yourObject)para obtener las propiedades.

export class YourClass implements IMyTable {
    ...
}

luego

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

No existe una forma sencilla de crear una matriz de claves desde una interfaz. Los tipos se borran en tiempo de ejecución y los tipos de objetos (sin ordenar, con nombre) no se pueden convertir a tipos de tupla (ordenados, sin nombre) sin algún tipo de truco.

Opción 1: Aproximación manual

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

(+) tipo de retorno de matriz simple (-), sin tupla (+ -) escritura manual con autocompletado

Extensión: Podríamos intentar ser elegantes y usar tipos recursivos para generar una tupla. Esto solo funcionó para mí para un par de accesorios (~ 5,6) hasta que el rendimiento se degradó enormemente. El tipo recursivo profundamente anidado tampoco es compatible oficialmente con TS: enumero este ejemplo aquí para completarlo.

Opción 2: generador de código basado en la API del compilador de 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

Después de compilar y ejecutar este archivo con tsc && node dist/mybuildstep.js, ./src/generated/IMyTable-keys.tsse genera un archivo con el siguiente contenido:

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

(+) solución automática (+) tipo de tupla exacta (-) requiere paso de compilación

PD: He elegido ts-morph, ya que es una alternativa simple a la API del compilador TS original.

Hipocresía. Las interfaces no existen en tiempo de ejecución.

solución alterna

Crea una variable del tipo y Object.keysúsala 🌹

No puedes hacerlo. Las interfaces no existen en tiempo de ejecución (como dijo @basarat ).

Ahora, estoy trabajando con lo siguiente:

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