Typescript: 'यूनियनों के लिए इंडेक्स सिग्नेचर में क्विक फिक्स का उपयोग नहीं किया जा सकता है, इसके बजाय एक मैप्ड ऑब्जेक्ट प्रकार का उपयोग करें'

कोई भी नहीं जानता कि मैप किए गए ऑब्जेक्ट प्रकार क्या हैं, तो चलिए उन्हें एक त्वरित समाधान देते हैं

+1, सिर्फ यहां आया क्योंकि मैं उम्मीद कर रहा था कि 2.9 आपके उदाहरण कोड के अनुसार इंडेक्स हस्ताक्षर के रूप में यूनियनों का समर्थन करेंगे। मुझे लगता है कि यह एक लंबी वांछित विशेषता रही है: # 5683, # 16760, आदि।

तुम यह केर सकते हो:

type Foo = 'a' | 'b';
type Bar = {[key in Foo]: any};

हालांकि Bar का कोई इंडेक्स सिग्नेचर नहीं है (यानी, तब आप (obj as Bar)[value as Foo] नहीं कर सकते)।

संपादित करें: यद्यपि यदि आप चेतावनी को गैर-मुद्दा बना सकते हैं, तो मैं सदा आभारी रहूंगा!

मैं इस पर काम करना चाहूंगा: हँसना:

अन्य सदस्यों को एक अलग ऑब्जेक्ट प्रकार पर ले जाता है जो एक चौराहे प्रकार के साथ संयुक्त हो जाता है

यदि ऑब्जेक्ट प्रकार एक वर्ग है तो हमें क्या करना चाहिए?
मैं केवल कल्पना कर सकता हूं कि यह एक इंटरफ़ेस है

इसलिए क्विकफ़िक्स के बाद कोड का पालन क्या करना चाहिए?

type K = "1" | "2"

class SomeType {
    a = 1;
    [prop: K]: any;
}

इसलिए क्विकफ़िक्स के बाद कोड का पालन क्या करना चाहिए?

मैं कहूंगा कि यह निश्चित नहीं होना चाहिए ..

@mhegazy मैं 3.0.0-rc का उपयोग कर रहा हूं और अभी भी मूल रूप से पोस्ट की गई समान त्रुटि प्राप्त कर रहा हूं। क्या यह अपेक्षित है?

मैं 3.0.0-आरसी का उपयोग कर रहा हूं और अभी भी मूल रूप से पोस्ट की गई समान त्रुटि प्राप्त कर रहा हूं। क्या यह अपेक्षित है?

हाँ। त्रुटि सही है। यह समस्या इसके लिए एक त्वरित सुधार जोड़कर ट्रैक कर रही थी, जो कि त्रुटि संदेश के बगल में प्रकाश लुगदी है।

2.9.1 और vscode के साथ कोई कोड क्रिया उपलब्ध नहीं है

@ThaJay हम इस सुविधा का समर्थन नहीं करेंगे, एक नया संस्करण स्थापित करने का प्रयास करें।

जाहिर है। मुझे पहले समयरेखा की जांच नहीं करने के लिए खेद है, बस यह मान लिया कि यह काफी नया होगा। Ts में नया संस्करण 3 के साथ जाँच करेगा।

इसका वर्णन कैसे करें:

function createRequestTypes(base){
  return ['REQUEST', 'SUCCESS', 'FAILURE'].reduce((acc, type) => {
    acc[type] = `${base}_${type}`
    return acc
  }, {})
}

const user = createRequestTypes('USER')
console.log(user.REQUEST) // error
// just string? like:
interface IRequestType: {[key: string]: string}

मैंने नीचे कोशिश की, सब विफल रहा:

type requestStatus = 'REQUEST' | 'SUCCESS' | 'FAILURE'
type requestTypes = {
  [key in requestStatus]: string
}
// or
interface IRequestTypes {[key: keyType]: string}
// or even
type requestTypes = {
  FAILURE: string,
  SUCCESS: string,
  REQUEST: string
}

@maicWorkGithub यहां आप जाएं:

const user = createRequestTypes('USER')
console.log(user.REQUEST) 

function createRequestTypes(base:string):requestTypes {
  const result : requestTypes    = {}
  const arr    : requestStatus[] = ['REQUEST', 'SUCCESS', 'FAILURE']  

  return arr.reduce((acc, type) => {
    acc[type] = `${base}_${type}`
    return acc
  }, result)
}


type requestStatus = 'REQUEST' | 'SUCCESS' | 'FAILURE'
type requestTypes = { [key in requestStatus]?: string }

@ एहॉर्सकी धन्यवाद !!

बस उत्सुक क्यों type काम करता है, लेकिन interface नहीं करता है। कोई समझा सकता है, कृपया? interface ऐसी सीमा (या सुविधा?) का कारण क्या है।

type Foo = 'a' | 'b';
type Bar = {[key in Foo]: any}; // ok
interface Baz {[key in Foo]: any} // =>

// A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type.ts(1169)
// A computed property name must be of type 'string', 'number', 'symbol', or 'any'.ts(2464)
// 'Foo' only refers to a type, but is being used as a value here.ts(2693)

यह एक अद्भुत ऑटो-फिक्स की खोज थी। इसे लागू करने के लिए धन्यवाद! :)

कक्षाओं के लिए भी।

तुम यह केर सकते हो:

type Foo = 'a' | 'b';
type Bar = {[key in Foo]: any};

हालांकि Bar का कोई इंडेक्स सिग्नेचर नहीं है (यानी, तब आप (obj as Bar)[value as Foo] नहीं कर सकते)।

संपादित करें: यद्यपि यदि आप चेतावनी को गैर-मुद्दा बना सकते हैं, तो मैं सदा आभारी रहूंगा!

Record उपयोग करें!

type Foo = 'a' | 'b'
type Bar = Record<Foo, any>

एक वर्ग का उपयोग करके इसका एक और उदाहरण जोड़ने के लिए ...

class Foo {
   a: string;
   b: string;
}

type Bar = {[key in keyof Foo]: any};

कोई शब्द नहीं, बस मेम:
https://media1.tenor.com/images/23d9d746fc87b3a93298af43dae21f6a/tenor.gif

:)

आंशिक का उपयोग करते समय यह और भी बेहतर है

type A = 'x' | 'y' | 'z';
type M = Partial<{
    [key in A]: boolean
}>;

कोई भी नहीं जानता कि मैप किए गए ऑब्जेक्ट प्रकार क्या हैं, तो चलिए उन्हें एक त्वरित समाधान देते हैं

@DanielRosenwasser
त्रुटि संदेश का उत्तर क्यों नहीं दिया जा सकता है, उदाहरण के लिए मैप किए गए प्रकार का उपयोग करके एक त्वरित उदाहरण दिखाएं - यह केवल कोड की कुछ पंक्तियाँ होंगी जो टाइपस्क्रिप्ट त्रुटि संदेशों की औसत लंबाई के अनुरूप होंगी: ट्रोलफेस:

क्या किसी को पता है कि क्या यह कहना संभव है कि इंटरफ़ेस जो कुंजी के रूप में टाइप या एनम का उपयोग करता है, केवल एक संपत्ति को स्वीकार कर सकता है?

उदाहरण के लिए इस तरह एक हस्ताक्षर: { <field>: { <and|or|xor>: <int> } } mongo बिटवाइज़ ऑपरेटर से लिया गया।

export enum BitwiseOperator {
    and = "and",
    or = "or",
    xor = "xor",
}

export type BitwiseCondition = {
    [key in BitwiseOperator]?: number;
}

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

const query: BitwiseCondition = {
  and: 5,
  or: 6  // raise a ts error
};

@ b4dnewz आप इसे टाइपस्क्रिप्ट में नहीं कर सकते। वर्कअराउंड: https://github.com/Microsoft/TypeScript/issues/10575

@ b4dnewz , यदि आप केवल 1 संपत्ति चाहते हैं, तो इसे इस तरह से क्यों नहीं?

export enum BitwiseOperator {
  and = "and",
  or = "or",
  xor = "xor",
}

export type BitwiseCondition = {
  operator: BitwiseOperator;
  value: number;
}

@ वॉनविंडिंग दुर्भाग्य से लौटा हुआ आकार मोंगोडब की अपेक्षा से अलग है

सुझाव के लिए

मैं आम-संचालकों की परिभाषाओं को यथासंभव सरल रखने की कोशिश कर रहा हूं ताकि मुझे सिरदर्द से बचा जा सके in शायद भविष्य में एक उचित समर्थन जोड़ा गया है

@ b4dnewz मेला काफी,

शायद आप उपयोग करने में सक्षम एक सरल विकल्प है:

export type BitwiseCondition =
  | { or: number }
  | { xor: number }
  | { and: number }

यह निकटतम के बारे में है जो आपको बहुत अधिक दोहराव के बिना मिलेगा

@ b4dnewz मेला काफी,

शायद आप उपयोग करने में सक्षम एक सरल विकल्प है:

export type BitwiseCondition =
  | { or: number }
  | { xor: number }
  | { and: number }

यह निकटतम के बारे में है जो आपको बहुत अधिक दोहराव के बिना मिलेगा

यह इस उदाहरण में त्रुटि उत्पन्न नहीं करेगा:

const query: BitwiseCondition = {
  and: 5,
  or: 6  // raise a ts error
};

मुझे लगा कि यह पूरी बात है

@ खानसामा ,

यह इस उदाहरण में त्रुटि उत्पन्न नहीं करेगा:

export type BitwiseCondition =
  | { or: number }
  | { xor: number }
  | { and: number }

const query: BitwiseCondition = {
  and: 5,
  or: 6  // doesn't raise a ts error!
};

ओह! यह अजीब है: open_mouth: मुझे नहीं पता था कि!

ऐसा लगता है कि टाइपस्क्रिप्ट ऑब्जेक्ट के लिए पारस्परिक रूप से अनन्य प्रकारों का समर्थन नहीं करता है। यह यहां की भाषा के लिए भी प्रस्ताव था: https://github.com/microsoft/TypeScript/issues/14094

यह अभी भी तकनीकी रूप से संभव है ...

इस stackoverflow से सशर्त प्रकार (सबसे कठिन प्रकार) का उपयोग करके प्राप्त करना संभव है, लेकिन यह बहुत सुंदर है ...।

/*
 XOR boiler plate
*/
type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
type XOR<T, U> = T | U extends object
  ? (Without<T, U> & U) | (Without<U, T> & T)
  : T | U;
type XOR3<S, T, U> = XOR<S, XOR<T, U>>;

// Code start
export type BitwiseCondition = XOR3<
  { or: number },
  { xor: number },
  { and: number }
>;

const query1: BitwiseCondition = {
  and: 5
};

const query: BitwiseCondition = {
  and: 5,
  or: 6 // raise a ts error
};

अगर कोई भी इसे बेहतर या बेहतर बना सकता है, तो कृपया करें

@mvasin FWIW, यह _appears_ समान परिणाम प्राप्त करने के लिए है, लेकिन मैं पूरी तरह से सहमत हूं कि यह इंटरफेस की एक विशेषता होनी चाहिए, जैसे कि यह प्रकारों पर है।

type Foo = 'a' | 'b';

type Bar = {
  [key in Foo]: any
}

interface A extends Bar { }

class Wol implements A{
  a: any;
  b: any;
}

टाइपस्क्रिप्ट 3.5 के लिए, ऐसा लगता है जैसे मुझे यह करना है:

export interface DataTableState {
  columnStats: {[key in keyof DataTable]?:{}}
}

क्या यह ऐसा करने का सबसे अच्छा तरीका है?

वास्तव में एक इंडेक्स हस्ताक्षर एनम प्रकार का उपयोग क्यों नहीं कर सकता ? मैप किया हुआ प्रकार लगभग वही होता है जो मैं चाहता हूं, लेकिन फिर टाइपस्क्रिप्ट एक परिभाषित कुंजी के रूप में Enum से हर स्ट्रिंग की अपेक्षा करता है। मैं वास्तव में यह दावा नहीं करना चाहता कि हर कुंजी मौजूद है, और यदि कोई कुंजी मौजूद है, तो उन्हें एनम में रहना चाहिए।

प्रकार के लिए उदाहरण के लिए:

type MyType = {
  [Key: 'foo' | 'bar' | 'zip']: number;
};

यह संतुष्ट करना चाहिए:

const x: MyType = {
  foo: 1,
  zip: 2
};

जबकि मैं सिर्फ एक मैप किए गए प्रकार के लिए अन्य कुंजी को अपरिभाषित कर सकता था, मैं कुंजियों को वैकल्पिक बनाना पसंद करता हूं, लेकिन यदि वे मौजूद हैं, तो मूल्य अपरिभाषित नहीं हो सकता है। यदि मैं मैप किए गए प्रकार के मान को वैकल्पिक बनाता है तो कोड काम करता है लेकिन प्रकार कम मजबूत होते हैं।

आंशिक का उपयोग करते समय यह और भी बेहतर है

type A = 'x' | 'y' | 'z';
type M = Partial<{
    [key in A]: boolean
}>;

धन्यवाद!
उपयोगी जब आपको एक प्रकार को परिभाषित करने की आवश्यकता होती है जो आंशिक रूप से एक शब्दकोश से मेल खाती है

https://www.typescriptlang.org/docs/handbook/advanced-types.html#mapped -types

"आंशिक" का उपयोग रिकॉर्ड्स पर भी किया जा सकता है:

type Foo = 'a' | 'b';
let foo1: Record<Foo, number> = { a: 1, b: 2 };
let foo2: Partial<Record<Foo, number>> = { a: 1 };

मैं खुद को अनजाने में हर महीने या तो इस GitHub पृष्ठ पर जा रहा हूँ।

मेरा नवीनतम एक वास्तविक सरल है:

interface ObjectLiteral {
    [key: string | number]: any
}
export const mapToObjectLiteral = (map: Map<string|number, any>) =>
    Array.from(map).reduce((objLit, [key, value]) => {
        objLit[key] = value
        return objLit
    }, {} as ObjectLiteral)

मैं स्क्रॉल कर सकता हूं और वर्कअराउंड का पता लगा सकता हूं, लेकिन सिर्फ यह प्रतिक्रिया देना चाहता हूं कि यह मुद्दा दिन-प्रतिदिन के कामों में थोड़ा अलग परिदृश्य में होता है।

यहाँ एक उदाहरण है:

type MapKey = string | number;
type ObjectLiteral<T extends MapKey, V = any> = {
  [P in T extends number ? string : T]: V;
};

export const mapToObjectLiteral = <T extends MapKey, V>(map: Map<T, V>) =>
  Array.from(map).reduce((objLit, [key, value]) => {
    objLit[key as keyof ObjectLiteral<T>] = value;
    return objLit;
  }, {} as ObjectLiteral<T, V>);

// how to make a better type of map ?
const m = new Map<1 | "foo", "a" | "b">();
m.set(1, "a");
m.set("foo", "b");

const o = mapToObjectLiteral(new Map(m));

console.log(o[1], o.foo); // just got an union type of every member of 'o'

https://github.com/microsoft/TypeScript/issues/24220#issuecomment -504285702

एक वर्ग का उपयोग करके इसका एक और उदाहरण जोड़ने के लिए ...

class Foo {
   a: string;
   b: string;
}

type Bar = {[key in keyof Foo]: any};

बहुत उपयोगी। धन्यवाद! 🚀