Lovefield'da ve hangi sütunlara sahip olduklarına ilişkin kendi Arayüzlerinde birçok tablo var.
Misal:

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

Bu arayüzün özellik adlarının şöyle bir dizide olmasını istiyorum: Doğrudan

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

arayüzü temel alan bir nesne / dizi IMyTableoluşturamıyorum ki bu hile yapması gereken, çünkü tabloların arayüz adlarını dinamik olarak alacağım. Bu yüzden arayüzde bu özellikleri yinelemem ve ondan bir dizi almam gerekiyor.

Bu sonuca nasıl ulaşırım?

İtibariyle typescript 2.3 (veya demeliyim 2.4 olduğu gibi, 2.3 bu özellik içeren bir hatayı giderilmiştir typescript@2.4-dev ), size ne yapmak istediğinizi elde etmek için özel bir trafo oluşturabilirsiniz.

Aslında, aşağıdakileri mümkün kılan böyle özel bir transformatör yarattım.

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

Ne yazık ki, özel transformatörlerin kullanımı şu anda o kadar kolay değil. Tsc komutunu çalıştırmak yerine bunları TypeScript dönüştürme API'si ile kullanmanız gerekir . Özel transformatörler için eklenti desteği talep eden bir sorun var .

Aşağıdakiler, anahtarları kendi başınıza listelemenizi gerektirir, ancak en azından TypeScript uygulayacak IUserProfileve IUserProfileKeysaynı anahtarlara sahip olacaktır ( Required<T>TypeScript 2.8'de eklenmiştir ):

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

Benzer bir problemim vardı, hem bir arayüze hem de bir nesneye sahip olmak istediğim dev bir özellikler listesine sahiptim.

NOT: Özellikleri iki kez yazmak (klavye ile yazmak) istemedim! Sadece KURU.

Burada dikkat edilmesi gereken bir nokta, arabirimler derleme zamanında zorlanan türlerdir, ancak nesneler çoğunlukla çalışma zamanıdır. ( Kaynak )

@Derek'in başka bir cevapta bahsettiği gibi , arayüz ve nesnenin ortak paydası, hem bir türe hem de bir değere hizmet eden bir sınıf olabilir .

Dolayısıyla TL; DR, aşağıdaki kod parçası ihtiyaçları karşılamalıdır:

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

( İşte daha fazla oynamak için Typescript Playground'daki yukarıdaki kod.)

PS. Sınıftaki özelliklere başlangıç ​​değerleri atamak ve türe bağlı kalmak istemiyorsanız, yapıcı hilesini yapabilirsiniz:

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

TypeScript Playground'da Yapıcı Trick .

Belki çok geç, ancak typcript'in 2.1 sürümünde şu şekilde kullanabilirsiniz key of:

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

Bu çalışmalı

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

veya

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

Güvenli varyantlar

Güvenlik derleme zamanı kontrolleriyle bir arabirimden bir anahtar dizisi veya demeti oluşturmak biraz yaratıcılık gerektirir. Türler çalışma zamanında silinir ve nesne türleri (sırasız, adlandırılmış) desteklenmeyen tekniklere başvurulmadan tuple türlerine (sıralı, adsız) dönüştürülemez .

Diğer cevaplarla karşılaştırma

Burada önerilen varyantların tümü, gibi bir referans nesne türü verilen yinelenen veya eksik tuple öğeleri olması durumunda bir derleme hatasını dikkate alır / tetikler IMyTable. Örneğin bir dizi türü bildirmek (keyof IMyTable)[]bu hataları yakalayamaz.

Ek olarak, belirli bir kitaplık gerektirmezler ( ts-morphgenel bir derleyici sarmalayıcısı olarak düşüneceğim son varyant kullanımları ), bir nesnenin aksine bir tuple türü yayınlarlar (yalnızca ilk çözüm bir dizi oluşturur) veya geniş dizi türü (ile karşılaştırıldığında bu cevaplar ) ve son olarak derslere ihtiyaç duymaz .

Varyant 1: Basit tipli dizi

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

++-otomatik tamamlama -dizisi ile en kolay kılavuz , tuple yok

Oyun alanı

Bir kayıt oluşturmayı sevmiyorsanız, bu alternatife Setve onaylama türlerine bir göz atın .

Varyant 2: Yardımcı işlevli Tuple

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

++-Otomatik tamamlama +-daha gelişmiş, karmaşık türlerle demet kılavuzu

Oyun alanı

Açıklama

createKeysuygun olmayan girdi için bir hata veren fonksiyon parametre tipini ek onaylama tipleriyle birleştirerek derleme zamanı kontrolleri yapar . (keyof IMyTable)[] | [keyof IMyTable]bu , aranan taraftaki bir dizi yerine bir dizinin çıkarımını zorlamanın "kara büyü" yoludur . Alternatif olarak, sabit iddiaları /as const arayan tarafından kullanabilirsiniz.

CheckMissingkontroller, Tanahtarları kaçırırsa 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"]

Not: T & "Error: missing keys"sadece güzel IDE hataları içindir. Sen de yazabilirsin never. CheckDuplicatesçift ​​tuple öğelerini kontrol eder:

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

Not: Tuplelardaki benzersiz öğe kontrolleri hakkında daha fazla bilgi bu yayında . İle TS 4.1 , biz de hata dizesi eksik tuşları adlandırabilirsiniz - bakmak bu Oyun .

Varyant 3: Özyinelemeli tür

TypeScript 4.1 sürümüyle birlikte, potansiyel olarak burada da kullanılabilecek koşullu özyinelemeli türleri resmi olarak destekler . Tür hesaplaması, kombinasyon karmaşıklığı nedeniyle pahalıdır - performans 5-6'dan fazla öğe için büyük ölçüde azalır. Bu alternatifi eksiksizlik için listeliyorum ( 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"] // ✔

++-otomatik tamamlama ile tuple kılavuzu +yardımcı fonksiyon --performansı yok

Varyant 4: Kod oluşturucu / TS derleyici API'si

ts-morph , orijinal TS derleyici API'sine biraz daha basit bir sarmalayıcı alternatifi olduğundan burada seçilmiştir . Elbette, derleyici API'sini doğrudan da kullanabilirsiniz. Jeneratör koduna bakalım:

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

Bu dosyayı derleyip çalıştırdıktan sonra aşağıdaki içeriğe sahip tsc && node dist/mybuildstep.jsbir dosya ./src/generated/IMyTable-keys.tsoluşturulur:

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

+otomatik olarak oluşturma solüsyonu +birden çok özellik için ölçeklenebilir +bir yardımcı işlev +demet -ilave yapı adım -derleyici API ile benzerlik ihtiyacı

IMyTableArayüzde olduğu gibi tanımlamak yerine, onu bir sınıf olarak tanımlamayı deneyin. Daktilo yazısında arayüz gibi bir sınıfı kullanabilirsiniz.

Yani örneğiniz için, sınıfınızı şu şekilde tanımlayın / oluşturun:

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

Arayüz olarak kullanın:

export class SomeTable implements IMyTable {
    ...
}

Anahtarları alın:

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

Arayüzünüzü uygulayan bir sınıf oluşturmanız, onu başlatmanız ve ardından Object.keys(yourObject)özellikleri almak için kullanmanız gerekecektir.

export class YourClass implements IMyTable {
    ...
}

sonra

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

Yapamam. Çalışma zamanında arayüzler mevcut değil.

geçici çözüm

Object.keysTüründe bir değişken oluşturun ve üzerinde kullanın 🌹

Bu zordu! Yardımlarınız için herkese teşekkür ederim.

Benim ihtiyacım mocha / chai komut dosyasını basitleştirmek için bir dizi dizge olarak bir arayüzün anahtarlarını almaktı. Uygulamada kullanmakla ilgilenmiyorum (henüz), bu nedenle ts dosyalarının oluşturulması gerekmiyordu. Yardım için ford04 sayesinde , yukarıdaki çözümü çok yardımcı oldu ve mükemmel çalışıyor, HİÇBİR derleyici hackleri. İşte değiştirilen kod:

Seçenek 2: TS derleyici API'sine (ts-morph) dayalı kod oluşturucu

Düğüm Modülü

npm install --save-dev ts-morph

keys.ts

NOT : Bu, tüm ts dosyalarının ./src'nin kök dizininde bulunduğunu ve alt klasör olmadığını varsayar, buna göre ayarlayın

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;

kullanım

import keys from "./keys";

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

console.log(myKeys)

Yapamazsın. Çalışma zamanında arayüzler yoktur ( @ basarat'ın söylediği gibi ).

Şimdi aşağıdakilerle çalışıyorum:

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