Eu tenho muitas tabelas no Lovefield e suas respectivas interfaces para as colunas que eles têm.
Exemplo:

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

Eu gostaria de ter os nomes das propriedades desta interface em uma matriz como esta:

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

Não posso fazer um objeto / matriz com base na interface IMyTablediretamente, o que deve funcionar porque estaria obtendo os nomes das interfaces das tabelas dinamicamente. Portanto, preciso iterar sobre essas propriedades na interface e obter uma matriz dela.

Como faço para alcançar esse resultado?

A partir do TypeScript 2.3 (ou devo dizer 2.4 , como no 2.3 esse recurso contém um bug que foi corrigido em [email protected] ), você pode criar um transformador personalizado para conseguir o que deseja fazer.

Na verdade, já criei esse transformador personalizado, que permite o seguinte.

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

Infelizmente, os transformadores personalizados atualmente não são tão fáceis de usar. Você deve usá-los com a API de transformação TypeScript em vez de executar o comando tsc. Há um problema ao solicitar um suporte de plug-in para transformadores personalizados.

O seguinte requer que você liste as chaves por conta própria, mas pelo menos o TypeScript aplicará IUserProfilee IUserProfileKeysterá exatamente as mesmas chaves ( Required<T>foi adicionado no 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,
};

Tive um problema semelhante, pois tinha uma lista gigante de propriedades das quais queria ter uma interface e um objeto fora dela.

NOTA: Eu não queria escrever (digitar com o teclado) as propriedades duas vezes! Apenas SECO.

Uma coisa a ser observada aqui é que as interfaces são tipos impostos em tempo de compilação, enquanto os objetos são em sua maioria em tempo de execução. ( Fonte )

Como @derek mencionou em outra resposta , o denominador comum de interface e objeto pode ser uma classe que serve tanto um tipo quanto um valor .

Portanto, TL; DR, o seguinte trecho de código deve satisfazer as necessidades:

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

( Aqui está o código acima no Playground Typescript para jogar mais)

PS. Se você não quiser atribuir valores iniciais às propriedades da classe e ficar com o tipo, pode fazer o truque do construtor:

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

Truque do construtor no Playground TypeScript .

Isso deve funcionar

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

ou

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

Talvez seja tarde demais, mas na versão 2.1 do texto datilografado você pode usar key ofassim:

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

Em vez de definir IMyTablecomo uma interface, tente defini-la como uma classe. No texto datilografado, você pode usar uma classe como uma interface.

Então, para seu exemplo, defina / gere sua classe assim:

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

Use-o como uma interface:

export class SomeTable implements IMyTable {
    ...
}

Obtenha as chaves:

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

Você precisará fazer uma classe que implemente sua interface, instanciá-la e usar Object.keys(yourObject)para obter as propriedades.

export class YourClass implements IMyTable {
    ...
}

então

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

Não posso. As interfaces não existem em tempo de execução.

Gambiarra

Crie uma variável do tipo e use Object.keysnela 🌹

Não existe uma maneira fácil de criar um array de chaves a partir de uma interface. Os tipos são apagados em tempo de execução e os tipos de objetos (não ordenados, nomeados) não podem ser convertidos em tipos de tupla (ordenados, não nomeados) sem algum tipo de hack.

Opção 1: abordagem 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 array simples (-), sem tupla (+ -) escrita manual com preenchimento automático

Extensão: podemos tentar ser extravagantes e usar tipos recursivos para gerar uma tupla. Isso só funcionou para mim por alguns adereços (~ 5,6) até o desempenho degradar enormemente. Tipos recursivos profundamente aninhados também não são oficialmente suportados pelo TS - listo este exemplo aqui para fins de completude.

Opção 2: gerador de código baseado na API do compilador 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

Depois de compilar e executar esse arquivo com tsc && node dist/mybuildstep.js, um arquivo ./src/generated/IMyTable-keys.tscom o seguinte conteúdo é gerado:

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

(+) solução automática (+) tipo de tupla exata (-) requer etapa de construção

PS: Eu escolhi ts-morph, pois é uma alternativa simples para a API do compilador TS original.

Você não pode fazer isso. As interfaces não existem em tempo de execução (como @basarat disse).

Agora, estou trabalhando com o seguinte:

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