स्ट्रिंग की सरणी के रूप में टाइपस्क्रिप्ट इंटरफ़ेस की कुंजी प्राप्त करें

Question 1

मैंने लवफील्ड और उनके संबंधित इंटरफेस में बहुत सी तालिकाएँ रखी हैं कि उनके पास क्या कॉलम हैं।
उदाहरण:

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

मुझे इस इंटरफ़ेस के गुण नामों को इस तरह से सरणी में रखना चाहिए :

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

मैं इंटरफ़ेस के आधार पर IMyTableसीधे ऑब्जेक्ट / सरणी नहीं बना सकता, जो कि चाल करना चाहिए क्योंकि मुझे गतिशील रूप से तालिकाओं के इंटरफ़ेस नाम मिलेंगे। इसलिए मुझे इंटरफ़ेस में इन गुणों पर पुनरावृति करने और इसके लिए एक सरणी प्राप्त करने की आवश्यकता है।

मैं इस परिणाम को कैसे प्राप्त करूं?

Question 2

टाइपस्क्रिप्ट 2.3 के रूप में (या मुझे 2.4 कहना चाहिए , क्योंकि 2.3 में इस सुविधा में एक बग है जो टाइपस्क्रिप्ट@2.4-dev में तय किया गया है ), आप जो करना चाहते हैं उसे प्राप्त करने के लिए एक कस्टम ट्रांसफार्मर बना सकते हैं।

वास्तव में, मैंने पहले से ही इस तरह के एक कस्टम ट्रांसफार्मर बनाया है, जो निम्नलिखित को सक्षम करता है।

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

दुर्भाग्य से, कस्टम ट्रांसफार्मर वर्तमान में उपयोग करना इतना आसान नहीं है। आपको उन्हें tsc कमांड को निष्पादित करने के बजाय टाइपस्क्रिप्ट ट्रांसफॉर्मेशन एपीआई के साथ उपयोग करना होगा । नहीं है एक मुद्दा कस्टम ट्रांसफार्मर के लिए एक प्लगइन सहायता का अनुरोध।

Question 3

निम्नलिखित को आपको अपने दम पर कुंजियों को सूचीबद्ध करने की आवश्यकता होती है, लेकिन कम से कम टाइपस्क्रिप्ट लागू होंगे IUserProfileऔर IUserProfileKeysठीक उसी कुंजी होंगे ( Required<T>टाइपस्क्रिप्ट 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,
};

Question 4

मेरे पास एक समान समस्या थी कि मेरे पास गुणों की एक विशाल सूची थी जिसे मैं एक इंटरफ़ेस और इसके बाहर एक ऑब्जेक्ट दोनों के लिए चाहता था।

नोट: मैं दो बार (कीबोर्ड के साथ टाइप) गुणों को लिखना नहीं चाहता था! बस DRY।

यहाँ एक बात ध्यान देने वाली है, संकलन-समय पर इंटरफेस को लागू किया जाता है, जबकि ऑब्जेक्ट ज्यादातर रन-टाइम होते हैं। ( स्रोत )

जैसा कि @derek ने एक अन्य उत्तर में उल्लेख किया है , इंटरफ़ेस और ऑब्जेक्ट का सामान्य भाजक एक ऐसा वर्ग हो सकता है जो एक प्रकार और एक मूल्य दोनों परोसता है ।

तो, टीएल; डीआर, कोड का निम्नलिखित टुकड़ा जरूरतों को पूरा करना चाहिए:

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

( यहाँ टाइपस्क्रिप्ट गेम ग्राउंड में उपरोक्त कोड अधिक खेलने के लिए है)

पुनश्च। यदि आप वर्ग में गुणों के लिए प्रारंभिक मान निर्दिष्ट नहीं करना चाहते हैं, और प्रकार के साथ रहना चाहते हैं, तो आप कंस्ट्रक्टर ट्रिक कर सकते हैं:

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

टाइपस्क्रिप्ट गेम ग्राउंड में कंस्ट्रक्टर ट्रिक ।

Question 5

यह काम करना चाहिए

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

या

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

Question 6

IMyTableइंटरफ़ेस में परिभाषित करने के बजाय , इसे एक वर्ग के रूप में परिभाषित करने का प्रयास करें। टाइपस्क्रिप्ट में आप एक इंटरफ़ेस की तरह एक वर्ग का उपयोग कर सकते हैं।

अपने उदाहरण के लिए, अपनी कक्षा को इस तरह परिभाषित / उत्पन्न करें:

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

इंटरफ़ेस के रूप में इसका उपयोग करें:

export class SomeTable implements IMyTable {
    ...
}

कुंजी प्राप्त करें:

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

Question 7

शायद यह बहुत देर हो चुकी है, लेकिन टाइपस्क्रिप्ट 2.1 के संस्करण में आप 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

Question 8

आपको एक वर्ग बनाने की आवश्यकता होगी जो आपके इंटरफ़ेस को लागू करता है, इसे तुरंत करता है और फिर Object.keys(yourObject)गुण प्राप्त करने के लिए उपयोग करता है।

export class YourClass implements IMyTable {
    ...
}

फिर

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

Question 9

नहीं कर सकते। रनटाइम पर इंटरफेस मौजूद नहीं हैं।

वैकल्पिक हल

प्रकार का एक वैरिएबल बनाएं और Object.keysउस पर उपयोग करें type

Question 10

इंटरफ़ेस से कुंजियाँ सरणी बनाने का कोई आसान तरीका नहीं है। प्रकार रन-टाइम पर मिटा दिए जाते हैं और ऑब्जेक्ट प्रकार (अनियंत्रित, नाम) को कुछ प्रकार की हैक के बिना टुपल प्रकार (ऑर्डर किए गए, अनाम) में परिवर्तित नहीं किया जा सकता है।

विकल्प 1: मैनुअल दृष्टिकोण

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

(+) सरल (-) ऐरर रिटर्न टाइप, नो टपल (+ -) मैन्युअल लेखन ऑटो-कम्प्लीट करने के साथ

विस्तार: हम कल्पना करने की कोशिश कर सकते हैं और टपल उत्पन्न करने के लिए पुनरावर्ती प्रकारों का उपयोग कर सकते हैं। यह केवल मेरे लिए प्रॉप्स के एक जोड़े (~ 5,6) के लिए काम करता था जब तक कि प्रदर्शन में बड़े पैमाने पर गिरावट नहीं हुई। डीप नेस्टेड रिकर्सिव टाइप भी आधिकारिक तौर पर टीएस द्वारा समर्थित नहीं हैं - मैं इस उदाहरण को पूर्णता के लिए यहां सूचीबद्ध करता हूं ।

विकल्प 2: टीएस कंपाइलर एपीआई ( 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

इस फ़ाइल को हम संकलित करने और चलाने के बाद tsc && node dist/mybuildstep.js, ./src/generated/IMyTable-keys.tsनिम्न सामग्री वाली एक फ़ाइल उत्पन्न होती है:

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

(+) स्वचालित समाधान (+) सटीक टपल प्रकार (-) के लिए बिल्ड-स्टेप की आवश्यकता होती है

पुनश्च: मैंने चुना है ts-morph, क्योंकि यह मूल टीएस कंपाइलर एपीआई का एक सरल विकल्प है।

Question 11

आप ऐसा नहीं कर सकते। अंतराल रनटाइम पर मौजूद नहीं है (जैसे @basarat ने कहा)।

अब, मैं निम्नलिखित के साथ काम कर रहा हूं:

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

Question 12

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