Typescript: प्रतीकों के साथ अनुक्रमण की अनुमति दें

यह ES6 प्रतीक का एक हिस्सा है जिसका समर्थन हम @JsonFreeman पर कर रहे हैं। अगले रिलीज में आपके कोड नमूने का समर्थन किया जाना चाहिए।

@ वेयरमीप , # १ ९ request request के अनुरोध के साथ, यह कानूनी हो जाना चाहिए, और obj[theAnswer] any टाइप होगा। क्या आप जो खोज रहे हैं, उसके लिए यह पर्याप्त है या आपको मजबूत टाइपिंग की आवश्यकता है?

क्या प्रतीकों द्वारा अनुक्रमित गुणों के प्रकार को निर्दिष्ट करना संभव होगा? कुछ इस तरह है:

var theAnswer = Symbol('secret');
interface DeepThought {
   [theAnswer]: number;
}

उस पीआर में टिप्पणियों के आधार पर, नहीं:

_ यह प्रतीक इंडेक्सर्स को कवर नहीं करता है, जो एक ऑब्जेक्ट को मनमाने ढंग से प्रतीक कुंजी_ के साथ नक्शे के रूप में कार्य करने की अनुमति देता है

मुझे लगता है कि @werepie @danquirk से ज्यादा मजबूत टाइपिंग की बात कर रहा है। यहाँ समर्थन के 3 स्तर हैं। सबसे मूल स्तर मेरे पीआर द्वारा प्रदान किया गया है, लेकिन यह सिर्फ उन प्रतीकों के लिए है जो वैश्विक प्रतीक वस्तु के गुण हैं, न कि उपयोगकर्ता परिभाषित प्रतीक। इसलिए,

var theAnswer = Symbol('secret');
interface DeepThought {
    [Symbol.toStringTag](): string; // Allowed
    [theAnswer]: number; // not allowed
}

समर्थन का अगला स्तर प्रतीक सूचक को अनुमति देने के लिए होगा:

var theAnswer = Symbol('secret');
interface DeepThought {
   [s: symbol]: number;
}
var d: DeepThought;
d[theAnswer] = 42; // Typed as number

यह हमारे रडार पर है, और इसे आसानी से लागू किया जा सकता है।

सबसे मजबूत स्तर वह है जो आप पूछ रहे हैं, जो कुछ इस तरह है:

var theAnswer = Symbol('secret');
var theQuestion = Symbol('secret');
interface DeepThought {
   [theQuestion]: string;
   [theAnswer]: number;
}
var d: DeepThought;
d[theQuesiton] = "why";
d[theAnswer] = 42;

यह वास्तव में अच्छा होगा, लेकिन अभी तक हम इसके लिए एक समझदार डिजाइन नहीं लाए हैं। यह अंततः इन प्रतीकों के रनटाइम मूल्य पर निर्भर प्रकार बनाने पर टिका लगता है। हम इसके बारे में सोचते रहेंगे, क्योंकि यह स्पष्ट रूप से एक उपयोगी चीज है।

मेरे पीआर के साथ, आपको कम से कम किसी वस्तु के मूल्य _out_ को खींचने के लिए एक प्रतीक का उपयोग करने में सक्षम होना चाहिए। यह any , लेकिन अब आपको कोई त्रुटि नहीं मिलेगी।

@ स्वप्नमेव मैंने # 2012 में थोड़ा लेखन किया था जिसमें आपकी रुचि हो सकती है।

मैंने # 1978 में अनुरोध को मर्ज कर दिया है, लेकिन मैं इस बग को खुला छोड़ दूंगा, क्योंकि ऐसा लगता है कि मैंने उस परिवर्तन के साथ प्रदान किए गए से अधिक के लिए पूछ रहा है। हालांकि, मेरे परिवर्तन के साथ, मूल त्रुटि चली जाएगी।

@ वेयरमी क्या आप एक अपडेट पोस्ट कर सकते हैं कि आप यहां और क्या देखना चाहेंगे? तुरंत मेरे लिए स्पष्ट नहीं था कि हमने क्या लागू किया है जो आपने पोस्ट किया है

किसी भी विचार जब symbol एक अनुक्रमणिका के रूप में मान्य होगा? क्या यह कुछ ऐसा है जो सामुदायिक पीआर के रूप में किया जा सकता है?

हम इसके लिए एक पीआर लेंगे। @JsonFreeman आपके द्वारा चलाए जा

मुझे लगता है कि वास्तव में एक प्रतीक सूचकांक को जोड़ना बहुत सीधा होगा। यह केवल संख्या और स्ट्रिंग की तरह काम करेगा, सिवाय इसके कि यह उनमें से किसी के साथ कार्य करने में उपयुक्त नहीं होगा, प्रकार तर्क निष्कर्ष, आदि। मुख्य चुनौती सिर्फ यह सुनिश्चित कर रही है कि आप सभी उपयुक्त स्थानों में तर्क जोड़ना याद रखें।

@RyanCavanaugh , अंततः https://github.com/Microsoft/TypeScript/issues/1863#issuecomment -73668456 टाइपसेक में अंतिम उदाहरण देना अच्छा होगा। लेकिन अगर आप चाहें तो इस मुद्दे को कई छोटे मुद्दों में विभाजित कर सकते हैं जो एक-दूसरे के ऊपर बनते हैं।

क्या इस मोर्चे पर कोई अपडेट था? AFAIU संकलक का नवीनतम संस्करण https://github.com/Microsoft/TypeScript/issues/1863#issuecomment -73668456 में वर्णित केवल प्रथम स्तर का समर्थन करता है।

हमें इस बदलाव के लिए पीआर स्वीकार करने में खुशी होगी।

यह दो स्तरों को दो अलग-अलग मुद्दों के रूप में ट्रैक करने के लायक हो सकता है। अनुक्रमणिका काफी सीधी लगती हैं, लेकिन उपयोगिता स्पष्ट नहीं है। निरंतर ट्रैकिंग के साथ पूर्ण समर्थन काफी मुश्किल लगता है, लेकिन शायद अधिक उपयोगी है।

लगातार ट्रैकिंग को https://github.com/Microsoft/TypeScript/issues/5579 में ट्रैक किया गया है

समझ गया, समझ में आता है।

@JsonFreeman @mhegazy एक इश्यू # 12932 पर उपलब्ध है

बस सोचा था कि मैं अपने उपयोग के मामले को रिंग में फेंक दूंगा। मैं एक उपकरण लिख रहा हूँ जिससे प्रश्नों को वर्णित करने के लिए सादे पाठ कुंजियों को निर्दिष्ट करने के लिए मनमाने ढंग से वस्तु गुणों के विरुद्ध मिलान करके, और मिलान ऑपरेटरों को निर्दिष्ट करने के लिए प्रतीकों की अनुमति मिलती है। जाने-माने ऑपरेटरों के लिए प्रतीकों का उपयोग करके, मैं एक ऑपरेटर बनाम एक फ़ील्ड से मेल खाने की अस्पष्टता से बचता हूं जिसकी कुंजी प्रसिद्ध ऑपरेटर के समान है।

क्योंकि प्रतीकों को इंडेक्स कुंजियों के रूप में निर्दिष्ट नहीं किया जा सकता है, जबकि जावास्क्रिप्ट स्पष्ट रूप से अनुमति देता है, इसके विपरीत, मुझे कई स्थानों पर <any> डालने के लिए मजबूर किया जाता है, जो कोड की गुणवत्ता को नीचा दिखाता है।

interface Query {
  [key: string|symbol]: any;
}

const Q = {
  startsWith: Symbol('startsWith'),
  gte: Symbol('gte'),
  lte: Symbol('lte')
}

const sample: Query = {
  name: {
    [Q.startsWith]: 'M',
    length: {
      [Q.lte]: 25
    }
  },
  age: {
    [Q.gte]: 18
  }
};

"अयोग्य" पहले वर्णों का उपयोग जैसे कि $ वर्ण उपयुक्त समझौता नहीं है, यह देखते हुए कि क्वेरी इंजन को निरीक्षण करने की आवश्यकता हो सकती है।

हाय दोस्तों। क्या इसमें कोई हलचल है? मुझे इसकी आवश्यकता है इसलिए मुझे आवश्यक परिवर्तनों में योगदान करने में खुशी होगी। हालांकि इससे पहले टीएस में योगदान नहीं दिया गया था।

@mhegazy @RyanCavanaugh मुझे पता है कि आप लोग अविश्वसनीय रूप से व्यस्त हैं, लेकिन क्या आपको मौका मिलने पर वजन हो सकता है? पुस्तकालयों और रूपरेखाओं के निर्माण के लिए प्रतीक वास्तव में एक महत्वपूर्ण उपकरण हैं, और इंटरफेस में उनका उपयोग करने की क्षमता की कमी एक निश्चित दर्द बिंदु है।

मैं पूछ रहा हूं कि क्या कुछ प्रगति पर है? पूरी उम्मीद है कि इस सुविधा का समर्थन किया जाएगा।

https://github.com/Microsoft/TypeScript/pull/15473 संबंधित दिखता है।

हाँ आज भी इसकी तलाश है, यही मैं वेबस्टॉर्म में देख रहा हूँ:

जो वास्तव में काम करता है

var test: symbol = Symbol();

const x = {
    [test]: 1
};

x[test];

console.log(x[test]);

console.log(x['test']);

लेकिन x का प्रकार सही नहीं है, जैसा कि अनुमान लगाया जा रहा है

{
  [key: string]: number
}

हाँ आज भी इसकी तलाश है, यही मैं वेबस्टॉर्म में देख रहा हूँ:

कृपया ध्यान दें कि JetBrains की अपनी भाषा सेवा जो WebStorm, intelliJ IDEA इत्यादि में डिफ़ॉल्ट रूप से सक्षम है।

यह TS 2.7 में काम करता है

const key = Symbol('key')
const a: { [key]?: number } = {}
a[key] = 5

इस पर किसी भी अद्यतन?

मेरी समस्या:

export interface Dict<T> {
  [index: string]: T;

  [index: number]: T;
}

const keyMap: Dict<number> = {};

function set<T extends object>(index: keyof T) {
  keyMap[index] = 1; // Error Type 'keyof T' cannot be used to index type 'Dict<number>'
}

लेकिन यह भी काम नहीं करता है, क्योंकि प्रतीक सूचकांक प्रकार नहीं हो सकता है।

export interface Dict<T> {
  [index: string]: T;
  [index: symbol]: T; // Error: An index signature parameter type must be 'string' or 'number'
  [index: number]: T;
}

अपेक्षित् व्यवहार:
symbol एक वैध सूचकांक प्रकार होना चाहिए

वास्तविक व्यवहार:
symbol एक वैध सूचकांक प्रकार नहीं है

as string | number कास्टिंग के साथ वर्कअराउंड का उपयोग करना मेरे लिए बहुत बुरा लगता है।

TypeScript में util.promisify.custom उपयोग कैसे किया जाता है? ऐसा लगता है कि निरंतर प्रतीकों का उपयोग अब समर्थित है, लेकिन केवल अगर उन्हें स्पष्ट रूप से परिभाषित किया गया है। तो यह मान्य टाइपस्क्रिप्ट है ( f से शुरू नहीं किया जा रहा है):
typescript const custom = Symbol() interface PromisifyCustom<T, TResult> extends Function { [custom](param: T): Promise<TResult> } const f: PromisifyCustom<string, void> f[custom] = str => Promise.resolve()
लेकिन यदि promisify.custom का उपयोग custom बजाय किया जाता है, तो f[promisify.custom] Element implicitly has an 'any' type because type 'PromisifyCustom<string, void>' has no index signature.
typescript import {promisify} from 'util' interface PromisifyCustom<T, TResult> extends Function { [promisify.custom](param: T): Promise<TResult> } const f: PromisifyCustom<string, void> f[promisify.custom] = str => Promise.resolve()
मैं एक फ़ंक्शन के promisify.custom फ़ील्ड को असाइन करना चाहूंगा, लेकिन ऐसा लगता है (ऊपर वर्णित व्यवहार को देखते हुए) ऐसा करने का एकमात्र तरीका फ़ंक्शन को any प्रकार में डालना है।

मुझे समझ में नहीं आ रहा है कि प्रतीक को प्रमुख सूचकांक के रूप में अनुमति क्यों नहीं दी जाती है, नीचे दिए गए कोड को काम करना चाहिए और टाइपस्क्रिप्ट 2.8 द्वारा स्वीकार किया जाना चाहिए लेकिन इसे टाइपसी 2.9 द्वारा अनुमति नहीं है

/**
 * Key can only be number, string or symbol
 * */
export class SimpleMapMap<K extends PropertyKey, V> {
  private o: { [k: string ]: V } = {};

  public has (k: K): boolean {
    return k in this.o;
  }

  public get (k: K): V {
    return this.o[k as PropertyKey];
  }

  public set (k: K, v: V) {
    this.o[k as PropertyKey] = v;
  }

  public getMap (k: K): V {
    if (k in this.o) {
      return this.o[k as PropertyKey];
    }
    const res = new SimpleMapMap<K, V>();
    this.o[k as PropertyKey] = res as any as V;
    return res as any as V;
  }

  public clear () {
    this.o = {};
  }
}

मैंने नीचे कोशिश की, जो मेरे लिए अधिक 'सही' है, लेकिन इसे टाइपस्क्रिप्ट कंपाइलर के दोनों संस्करण द्वारा स्वीकार नहीं किया गया है

/**
 * Key can only be number, string or symbol
 * */
export class SimpleMapMap<K extends PropertyKey, V> {
  private o: { [k: K ]: V } = {};

  public has (k: K): boolean {
    return k in this.o;
  }

  public get (k: K): V {
    return this.o[k];
  }

  public set (k: K, v: V) {
    this.o[k] = v;
  }

  public getMap (k: K): V {
    if (k in this.o) {
      return this.o[k];
    }
    const res = new SimpleMapMap<K, V>();
    this.o[k as PropertyKey] = res as any as V;
    return res as any as V;
  }

  public clear () {
    this.o = {};
  }
}

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

@beenotung हालांकि यह एक आदर्श समाधान नहीं है, यह मानते हुए कि आपके द्वारा पोस्ट किया गया वर्ग एकमात्र ऐसा स्थान है जहां आपको इस तरह के व्यवहार की आवश्यकता होती है, आप वर्ग के अंदर असुरक्षित कास्ट कर सकते हैं, लेकिन वर्ग और विधियों को एक समान रखते हुए , ताकि उपभोक्ता वर्ग यह नहीं देखेगा कि:

/**
 * Key can only be number, string or symbol
 * */
export class SimpleMapMap<K extends PropertyKey, V> {
  private o: { [k: string]: V } = {};

  public has(k: K): boolean {
    return k in this.o;
  }

  public get(k: K): V {
    return this.o[k as any];
  }

  public set(k: K, v: V) {
    this.o[k as any] = v;
  }

  public getMap(k: K): V {
    if (k in this.o) {
    return this.o[k as any];
    }

    const res = new SimpleMapMap<K, V>();
    this.o[k as any] = res as any as V;
    return res as any as V;
  }

  public clear() {
    this.o = {};
  }
}

क्योंकि हस्ताक्षर समान हैं, जब भी आप इस वर्ग का उपयोग करते हैं, तो आपके पास सही प्रकार से लागू किया गया सत्यापन होगा, और, जब यह समस्या हल हो जाएगी, तो आपको बस इस वर्ग को बदलना होगा (यह उपभोक्ताओं के लिए पारदर्शी होगा)।

एक उपभोक्ता का एक उदाहरण bellow की तरह है (जब यह समस्या ठीक हो जाती है तो कोड को किसी भी बदलाव की आवश्यकता नहीं होगी):

const s1 = Symbol(1);
const s2 = Symbol(2);

let m = new SimpleMapMap<symbol, number>()
m.set(s1, 1);
m.set(s2, 2);
m.get(s1);
m.get(1); //error

टाइपस्क्रिप्ट 3.0.1, इससे काट लिया गया।
मैं एक ऐसा रिकॉर्ड चाहता हूँ जो symbol स्वीकार करे लेकिन TS मुझे नहीं देगा।

इस मुद्दे को खोले हुए 3.5 साल हो गए हैं, क्या हमारे पास अब प्रतीक हो सकते हैं, कृपया this

विडंबना यह है कि टीएस खुद विरोधाभासी है।
TS keyof any = number | string | symbol ।

लेकिन तब जब आप record[symbol] TS को मना करते हैं
_Type 'प्रतीक' को indexer_ के रूप में उपयोग नहीं किया जा सकता है।

हाँ, मैं इस दुख से थोड़ी देर के लिए पीड़ित हूं, इस विषय के बारे में मेरा नवीनतम प्रश्न:

https://stackoverflow.com/questions/53404675/ts2538-type-unique-symbol-cannot-be-used-as-an-index-type

@RyanCavanaugh @DanielRosenwasser @mhegazy कोई अपडेट? यह मुद्दा अपने चौथे जन्मदिन के करीब है।

अगर कोई मुझे सही दिशा में ले जा सकता है, तो मैं इसे दे सकता हूं। अगर मैच के लिए और भी बेहतर है।

@ झपट्टा # 26797 पर एक पीआर है (नोट - प्रसिद्ध प्रतीकों के बारे में चेतावनी)। # 28581 में इसके बारे में हालिया डिज़ाइन मीटिंग नोट्स हैं (लेकिन वहां कोई रिज़ॉल्यूशन रिकॉर्ड नहीं किया गया है)। इस बारे में थोड़ा और अधिक प्रतिक्रिया है कि पीआर को यहां क्यों रखा गया

साभार @yortus मैंने बस रयान से पूछा है कि क्या पीआर अभी भी 3.2 के लिए योजनाबद्ध है, जो कि मील के पत्थर से संकेत मिलता है। उम्मीद है कि यह मामला है, और यह हल हो जाएगा!

@Yortus द्वारा इंगित पीआर एक बहुत बड़ा बदलाव लगता है,
इस बग के लिए ठीक नहीं होना चाहिए बहुत मामूली? जैसे हालत की जाँच में एक बयान या जोड़ना।
(मैंने अभी तक जगह बदलने के लिए स्थित नहीं किया है।)

यहाँ अस्थायी समाधान https://github.com/Microsoft/TypeScript/issues/24587#issuecomment -412287117, थोड़े बदसूरत लेकिन काम हो जाता है

const DEFAULT_LEVEL: string = Symbol("__default__") as any;

एक और https://github.com/Microsoft/TypeScript/issues/24587#issuecomment -460650063, चूंकि लिंटर्स h8 any

const ItemId: string = Symbol('Item.Id') as unknown as string;
type Item = Record<string, string>;
const shoes: Item = {
  name: 'whatever',
}
shoes[ItemId] = 'randomlygeneratedstring'; // no error

{ name: 'whatever', [Symbol(Item.Id)]: 'randomlygeneratedstring' }

मुझे लगता है कि एक प्रतीक है जो मैंने प्रतीकों का उपयोग करने में देखा है, हालांकि यदि आपके पास चाइल्ड_प्रोसेस मॉड्यूल शामिल है, तो हाँ आप दोनों प्रक्रियाओं के बीच प्रकार / enums / इंटरफेस साझा कर सकते हैं लेकिन कभी भी प्रतीक नहीं।

यह वास्तव में बहुत अच्छा है, हालांकि यह हल किया गया है, प्रतीक वास्तव में अपनी कुंजियों को प्रदूषित किए बिना वस्तुओं पर नज़र रखने में बहुत बढ़िया हैं और नक्शे / सेटों का उपयोग करने के लिए आवश्यक हैं, इसके शीर्ष पर हाल के वर्षों में बेंचमार्क बताते हैं कि प्रतीकों तक पहुंच बस स्ट्रिंग तक पहुंच के रूप में तेज़ है / नंबर कुंजी

संपादित करें: यह दृष्टिकोण केवल Record<X,Y> साथ काम करता है, लेकिन Interfaces । अभी के लिए // @ts-ignore का उपयोग करने के बाद से यह अभी भी एक सिंटैक्टिक रूप से सही है और अभी भी जेएस के लिए अच्छी तरह से इसे संकलित करना चाहिए।

ध्यान देने वाली बात यह है कि प्रतीकों में शामिल लाइनों पर // @ts-ignore का उपयोग करते समय, यह वास्तव में उस प्रतीक के प्रकार को मैन्युअल रूप से निर्दिष्ट करने में (और मदद करता है) है। VSCode अभी भी इस पर उठाता है।

const id = Symbol('ID');

interface User {
  name: string;
  age: number;
}

const alice: User = {
  name: 'alice',
  age: 25,
};

// @ts-ignore
alice[id] = 'maybeSomeUUIDv4String';

// ...

// then somewhere, when you need this User's id

// @ts-ignore
const id: string = alice[id];

console.log(id); // here you can hover on id and it will say it's a string

पता नहीं, अगर किसी ने इसे ठीक करने के लिए कुछ शुरू किया है, लेकिन यदि नहीं, तो मेरे पास अब है।

मेरा समय सीमित है, हालांकि और मुझे टाइपस्क्रिप्ट स्रोतों के बारे में शून्य ज्ञान है। मैंने एक कांटा बनाया है (https://github.com/Neonit/TypeScript), लेकिन कोई पुल अनुरोध नहीं, फिर भी, क्योंकि मैं अधूरे (?) परिवर्तनों के साथ देवों से छेड़छाड़ नहीं करना चाहता। मैं हर किसी को योगदान देने के लिए कहूंगा कि वे मेरे कांटे पर क्या कर सकते हैं। मैं आखिरकार एक पीआर जारी करूंगा।

अब तक मुझे इंटरफ़ेस इंडेक्स टाइप प्रतिबंध को ठीक करने का एक तरीका मिल गया है। मुझे नहीं पता, अगर इसमें कुछ और है। मैं बिना किसी सुधार के TS 3.4 में एक प्रतीक के साथ किसी वस्तु को अनुक्रमित करने में सक्षम था। ( https://www.typescriptlang.org/play/#src = const% 20o% 20% 3D% 20% 7B% 7D% 3B% 0D% 0Aconst% 20s% 20% 3D% 20Symbol ('s')% 3B % 0 d% 0A% 0 d% 0Ao% 5BS% 5D% 20% 3 डी% 20123% 3 बी)

मैंने जो पाया, उसे देखने के लिए मेरी प्रतिबद्धताओं पर एक नज़र डालें: https://github.com/Neonit/TypeScript-SymbolKeys/commit/11cb7c13c2494ff32cdec2d4f826730bc825dc3

लापता:

• टेस्ट: मेरे पास यह देखने का समय नहीं है कि टीएस में परीक्षण कैसे व्यवस्थित और संरचित हैं।
• स्थानीयकरण: नैदानिक ​​संदेश केवल अंग्रेजी संस्करण के लिए अद्यतन किया गया है। हो सकता है कि अन्य भाषाओं को अभी भी पुराना संदेश मिले मुझे नहीं पता। मैं वैसे भी केवल एक जर्मन अनुवाद प्रदान कर सकता था।

मुझे उम्मीद है कि वर्षों के इंतजार के बाद यह चीजें शुरू हो जाएंगी।

फिक्स अच्छा लग रहा है। टाइपस्क्रिप्ट देव इस पर एक नज़र डाल सकते हैं?

हैलो, इसके लिए कोई प्रगति?

बस इसके बारे में एक SO थ्रेड खोला: https://stackoverflow.com/questions/59118271/use-symbol-as-object-key-type-in-typescript

ऐसा क्यों संभव नहीं है? क्या symbol एक और आदिम प्रकार number - इसलिए अंतर क्यों है?

हैलो, इसके लिए कोई प्रगति?

पाँच साल हो गए!

आपको यह विश्वास नहीं होगा कि क्लोजर पाने में C ++ को कितना समय लगा

योग्य निष्पक्ष, लेकिन C ++ अपने आप को उस भाषा के सुपरसेट के रूप में विपणन नहीं करता है जिसमें क्लोजर है :-p

@ljharb उस घोड़े को मरोड़ रहा है

उन लोगों के लिए जो नए रनटाइम्स को लक्षित कर रहे हैं, Map उपयोग क्यों नहीं करते ? मैंने पाया है कि बहुत सारे डेवलपर्स Map s मौजूद नहीं हैं, इसलिए मैं उत्सुक हूं कि क्या कोई और परिदृश्य है जो मुझे याद आ रहा है।

let m = new Map<symbol, number>();
let s = Symbol("arbitrary symbol!");

m.set(s, 1000);
let a = m.get(s);

मानचित्र और वस्तुओं के उपयोग के मामले अलग-अलग हैं।

@DanielRosenwasser प्रसिद्ध प्रतीकों को प्रोटोकॉल के रूप में उपयोग किया जाता है; उदाहरण के लिए, Symbol.match एक मानचित्र कुंजी, ऑब्जेक्ट को RegExp-like नहीं बनाएगी (और कोई भी वस्तु Symbol.iterable कुंजी को स्पष्ट रूप से TS बिल्ट-इन का उपयोग किए बिना इसे चलने योग्य बनाने के लिए बना सकती है। निष्क्रिय प्रकार)।

लगभग 5 साल (

कृपया, इस सुविधा को लागू करें, मैं सामान्य रूप से कोड नहीं लिख सकता हूँ।

क्या प्रतिभागी अपने उपयोग के मामलों में वास्तविक उदाहरण दे सकते हैं?

मैं प्रोटोकॉल उदाहरण को नहीं समझता और आज यह क्यों संभव नहीं है।

यहाँ StringConvertible उदाहरण दिया गया है

const intoString = Symbol("intoString")

/**
 * Something that can be converted into a string.
 */
interface StringConvertible {
    [intoString](): string;
}

/**
 * Something that is adorable.
 */
class Dog implements StringConvertible {
    [intoString](): string {
        return "RUFF RUFF";
    }
}

/**
 * <strong i="9">@see</strong> {https://twitter.com/drosenwasser/status/1102337805336768513}
 */
class FontDog implements StringConvertible {
    [intoString](): string {
        return "WOFF WOFF";
    }
}

console.log(new Dog()[intoString]())
console.log(new FontDog()[intoString]())

यहाँ Mappable या Functor का उदाहरण दिया गया है (उच्च-क्रम के प्रकार के निर्माणकर्ताओं की कमी):

const map = Symbol("map")

interface Mappable<T> {
    [map]<U>(f: (x: T) => U): Mappable<U>
}

class MyCoolArray<T> extends Array<T> implements Mappable<T> {
    [map]<U>(f: (x: T) => U) {
        return this.map(f) as MyCoolArray<U>;
    }
}

@DanielRosenwasser ऐसा लगता है जैसे आप मान रहे हैं कि सभी वस्तुओं में एक इंटरफ़ेस है या एक वर्ग उदाहरण है या अग्रिम में ज्ञात हैं; आपके अंतिम उदाहरण का उपयोग करते हुए, मुझे किसी भी जावास्क्रिप्ट ऑब्जेक्ट पर map , कहने में सक्षम होना चाहिए (या कम से कम, एक ऐसी वस्तु जिसका प्रकार किसी भी प्रतीक को इसमें जोड़े जाने की अनुमति देता है), जो तब इसे मैपेबल बनाता है।

तथ्य के बाद एक वस्तु पर एक संपत्ति (प्रतीक या नहीं) स्थापित करना एक अलग सुविधा अनुरोध (जिसे अक्सर "एक्सपेंडो गुण" या "एक्सपेंडो प्रकार" कहा जाता है) का हिस्सा होता है।

उस प्रकार की कमी, जिस प्रकार के लिए आपको प्रतीक इंडेक्स हस्ताक्षर की आवश्यकता होगी वह टाइपस्क्रिप्ट उपयोगकर्ता के रूप में बहुत कम प्रदान करेगा, है ना? अगर मैं सही तरीके से समझूं, तो टाइप को unknown या सिर्फ any कुछ उपयोगी होने की आवश्यकता होगी।

interface SymbolIndexable {
   [prop: symbol]: any; // ?
}

प्रोटोकॉल के मामले में, यह आमतौर पर एक कार्य है, लेकिन निश्चित रूप से, यह unknown ।

मुझे जिस चीज़ की आवश्यकता है वह type O = { [k: string]: unknown } के प्रतीक (और bigint) के बराबर है, इसलिए मैं प्रकार प्रणाली के साथ एक वास्तविक JS ऑब्जेक्ट (किसी भी प्रकार की कुंजी हो सकती है) का प्रतिनिधित्व कर सकता हूं। मैं बाद में आवश्यकतानुसार इसे संकीर्ण कर सकता हूं, लेकिन जेएस ऑब्जेक्ट के लिए आधार प्रकार { [k: string | bigint | symbol | number]: unknown } , अनिवार्य रूप से होगा।

आह मुझे लगता है कि मैं @DanielRosenwasser बिंदु देखता

export interface Environment<T> {
    [Default](tag: string): Intrinsic<T>;
    [Text]?(text: string): string;
    [tag: string]: Intrinsic<T>;
    // TODO: allow symbol index parameters when typescript gets its shit together
    // [tag: symbol]: Intrinsic<T>;
}

जहां Intrinsic<T> एक फ़ंक्शन प्रकार है, और मैं देवों को स्ट्रिंग्स के समान वातावरण पर अपने स्वयं के प्रतीक गुणों को परिभाषित करने की अनुमति देना चाहता हूं, लेकिन जैसा कि आप [Symbol.iterator] , [Symbol.species] जोड़ सकते हैं किसी भी इंटरफ़ेस के लिए कस्टम प्रतीक गुण, प्रतीकों के साथ सूचकांक हस्ताक्षर इन गुणों को लागू करने वाले किसी भी ऑब्जेक्ट को गलत तरीके से प्रतिबंधित करेगा।

तो क्या आप कह रहे हैं कि आप any से अधिक विशिष्ट किसी भी प्रतीक द्वारा अनुक्रमण के मूल्य प्रकार को नहीं बना सकते हैं? क्या हम किसी भी तरह से unique symbol बनाम symbol उपयोग कर सकते हैं? जैसे हम इंडेक्स सिग्नेचर को नियमित प्रतीकों के लिए डिफ़ॉल्ट बना सकते हैं और अद्वितीय / प्रसिद्ध प्रतीकों को इंडेक्स प्रकार को ओवरराइड करने की अनुमति दे सकते हैं? यहां तक ​​कि अगर यह टाइपकास्ट नहीं था, तो मनमाने ढंग से प्रतीक अनुक्रमित द्वारा गुण प्राप्त / सेट किया जा सकता है।

विकल्प यह होगा कि उपयोगकर्ता अपने प्रतीक गुणों के साथ स्वयं पर्यावरण इंटरफ़ेस का विस्तार करें, लेकिन इससे कोई अतिरिक्त प्रकार का सुरक्षा बीमा नहीं मिलता है क्योंकि उपयोगकर्ता सिंबल को ऑब्जेक्ट पर रख सकते हैं।

@DanielRosenwasser यहाँ मेरे उत्पादन कोड

वैसे भी वर्तमान व्यवहार ईएस मानक के साथ असंगत है जो गलत है।

एक अतिरिक्त देर रात सोचा कि मैं प्रतीक प्रकारों के बारे में था। यह एक त्रुटि क्यों नहीं है?

const foo = {
  [Symbol.iterator]: 1,
}

जेएस को उम्मीद है कि सभी Symbol.iterator प्रॉपर्टीज एक ऐसा फंक्शन होगा जो एक पुनरावर्तक लौटाता है, और यह ऑब्जेक्ट बहुत सारे कोड को तोड़ देगा यदि इसे विभिन्न स्थानों में पारित किया गया था। यदि सभी वस्तुओं के लिए विश्व स्तर पर प्रतीक गुणों को परिभाषित करने का एक तरीका था, तो हम वैश्विक प्रतीकों की अनुमति देते हुए विशिष्ट प्रतीक सूचकांक हस्ताक्षरों की अनुमति दे सकते हैं। यह सही होगा?

मैं यह भी नहीं समझ पा रहा हूं कि यहां एक उपयोग के मामले की आवश्यकता क्यों होगी। यह ईएस 6 असंगतता है, जो ईएस 6 को लपेटने वाली भाषा में मौजूद नहीं होना चाहिए।

अतीत में मैंने अपने निष्कर्षों को इस धागे में यहां कैसे तय किया जा सकता है पर पोस्ट किया है और यदि इस कोड में महत्वपूर्ण जांच या सुविधाओं की कमी नहीं है, तो मुझे संदेह है कि इस चर्चा को जारी रखने की तुलना में इसे कोडबेस में एकीकृत करने में अधिक समय लगता है।

मैंने सिर्फ एक पुल अनुरोध नहीं किया है, क्योंकि मुझे टाइपस्क्रिप्ट के परीक्षण ढांचे या आवश्यकताओं के बारे में नहीं पता है और क्योंकि मुझे नहीं पता है कि सभी मामलों में इस काम को करने के लिए अलग-अलग फ़ाइलों में परिवर्तन आवश्यक होगा या नहीं।

यहां पढ़ने और लिखने के लिए निवेश करने का समय जारी रखने से पहले, कृपया जांच लें कि क्या सुविधा को जोड़ने में कम समय लगेगा। मुझे संदेह है कि कोई भी इसे टाइपस्क्रिप्ट में होने की शिकायत करेगा।

इन सबके अलावा सामान्य उपयोग का मामला है यदि आप मनमाने प्रतीकों पर मूल्यों को मैप करना चाहते हैं। या गैर-टाइप किए गए ES6 कोड के साथ संगतता के लिए।

यहाँ एक जगह का एक उदाहरण है जो मुझे लगता है कि यह मददगार होगा: https://github.com/choojs/nanobus/pull/40/files। व्यवहार में, eventName s प्रतीक या तार हो सकते हैं, इसलिए मैं कहना चाहूंगा

type EventsConfiguration = { [eventName: string | Symbol]: (...args: any[]) => void }

पहली पंक्ति पर।

लेकिन मुझे कुछ गलतफहमी हो सकती है कि मुझे यह कैसे करना चाहिए।

दर्द के बिना सरल प्रयोग नहीं किया जा सकता है:

type Dict<T> = {
    [key in PropertyKey]: T;
};

function dict<T>() {
    return Object.create(null) as Dict<T>;
}

const has: <T>(dict: Dict<T>, key: PropertyKey) => boolean = Function.prototype.call.bind(Object.prototype.hasOwnProperty);

function forEach<T>(dict: Dict<T>, callbackfn: (value: T, key: string | symbol, dict: Dict<T>) => void, thisArg?: any) {
    for (const key in dict)
        if (has(dict, key))
            callbackfn.call(thisArg, dict[key], key, dict);
    const symbols = Object.getOwnPropertySymbols(dict);
    for (let i = 0; i < symbols.length; i++) {
        const sym = symbols[i];
        callbackfn.call(thisArg, dict[sym], sym, dict); // err
    }
}

const d = dict<boolean>();
const sym = Symbol('sym');
const bi = 9007199254740991n;

d[1] = true;
d['x'] = true;
d[sym] = false; // definitely PITA
d[bi] = false; // another PITA

forEach(d, (value, key) => console.log(key, value));

मैं यह भी नहीं समझ पा रहा हूं कि यहां एक उपयोग के मामले की आवश्यकता क्यों होगी।

@neonit इसको संबोधित करने के लिए इसलिए -

ऐसा लगता है कि वास्तव में, अधिकांश लोगों के उपयोग किए गए मामलों को आसानी से हल नहीं किया जाएगा क्योंकि वे कल्पना करते हैं (देखें @brainkim की प्रतिक्रिया यहां https://github.com/microsoft/TypeScript/issues/1863#issuecomment-574555587) या वे प्रतीक गुणों (https://github.com/microsoft/TypeScript/issues/1863#issuecomment-574538121) या मैप्स (https://github.com/microsoft/TypeScript/issues/1863) के माध्यम से समान रूप से अच्छी तरह से हल कर रहे हैं # issuecomment-572,733,050)।

मुझे लगता है कि @ टायलर-मर्फी ने यहां सबसे अच्छा उदाहरण दिया है कि आप बाधाओं को नहीं लिख सकते हैं, जो एक प्रकार की सुरक्षित घटना एमिटर के लिए बहुत उपयोगी हो सकता है जो प्रतीकों का समर्थन करता है।

यहां पढ़ने और लिखने के लिए निवेश करने का समय जारी रखने से पहले, कृपया जांच लें कि क्या सुविधा को जोड़ने में कम समय लगेगा। मुझे संदेह है कि कोई भी इसे टाइपस्क्रिप्ट में होने की शिकायत करेगा।

यह कहना हमेशा आसान होता है जब आपको परियोजना को बनाए रखने की आवश्यकता नहीं होती है! This मैं समझता हूं कि यह आपके लिए कुछ उपयोगी है, लेकिन मुझे आशा है कि आप इसका सम्मान करेंगे।

यह एक ES6 असंगति है

ऐसे बहुत सारे निर्माण हैं जो टाइपस्क्रिप्ट आसानी से टाइप नहीं कर सकते क्योंकि यह अनम्य होगा। मैं यह नहीं कह रहा हूं कि यह असंभव है, लेकिन मुझे विश्वास नहीं है कि यह इस मुद्दे को फ्रेम करने का एक उपयुक्त तरीका है।

तो यह प्रतीक कुंजियों को जोड़ने में असमर्थता की तरह लगता है क्योंकि सूचकांक हस्ताक्षर इस तथ्य से आते हैं कि वैश्विक प्रसिद्ध प्रतीक हैं जिन्हें अपने स्वयं के टाइपिंग की आवश्यकता होती है, जो प्रतीक सूचकांक प्रकार अनिवार्य रूप से संघर्ष करेंगे। समाधान के रूप में, क्या होगा यदि हमारे पास एक वैश्विक मॉड्यूल / इंटरफ़ेस था जो सभी ज्ञात प्रतीकों का प्रतिनिधित्व करता था?

const Answerable = Symbol.for("Answerable");
declare global {
  interface KnownSymbols {
    [Answerable](): string  | number;
  }
}

interface MyObject {
  [name: symbol]: boolean;
}

const MySymbol = Symbol.for("MySymbol");
const obj: MyObject = {
  [MySymbol]: true,
};

obj[Answerable] = () => "42";

वैश्विक KnownSymbols इंटरफ़ेस पर अतिरिक्त गुणों की घोषणा करके, आप सभी वस्तुओं को उस प्रतीक द्वारा अनुक्रमित करने की अनुमति देते हैं और संपत्ति के मूल्य को अपरिभाषित / आपके मूल्य प्रकार तक सीमित करते हैं। यह तुरंत ES6 द्वारा प्रदान किए गए प्रसिद्ध प्रतीकों के लिए टाइपिंग प्रदान करने के लिए टाइपस्क्रिप्ट की अनुमति देकर मूल्य प्रदान करेगा। किसी ऑब्जेक्ट में Symbol.iterator प्रॉपर्टी जोड़ना जो एक फ़ंक्शन नहीं है जो पुनरावृत्ति करने वाले को स्पष्ट रूप से त्रुटि होना चाहिए, लेकिन यह वर्तमान में टाइपस्क्रिप्ट में एक नहीं है। और यह पहले से मौजूद वस्तुओं के लिए बहुत आसान प्रतीक गुणों को जोड़ना आसान बना देगा।

एक वैश्विक मॉड्यूल का यह उपयोग प्रतीक को मनमानी कुंजी के रूप में भी उपयोग करने की अनुमति देगा, और इसलिए सूचकांक में हस्ताक्षर। आप स्थानीय सूचकांक चिह्न प्रकार पर वैश्विक ज्ञात प्रतीक गुणों को पूर्वता प्रदान करेंगे।

क्या इस प्रस्ताव को लागू करने से सूचकांक हस्ताक्षर प्रकारों को आगे बढ़ने की अनुमति मिलेगी?

व्यक्तिगत उपयोग के मामले अप्रासंगिक हैं। यदि यह cromulent JavaScript है, तो इसे TS परिभाषाओं में व्यक्त करने की आवश्यकता है।

लेकिन मेरी समझ यह है कि सूक्ष्म मुद्दे बाकी प्रकार की प्रणाली के साथ कैसे बातचीत करते हैं, इसके साथ सूक्ष्म मुद्दे हैं

"रिफ्लेक्टर्स जैसे कि इंडेक्स सिग्नेचर कैसे आंतरिक रूप से पूरी तरह से काम करते हैं, यह एक डरावना बड़ा बदलाव है और इंडेक्स सिग्नेचर कैसे होते हैं या क्रॉमुलेट प्रश्न उठाते हैं कि मैप्ड प्रकारों से भिन्न होना चाहिए जो सटीक होने के लिए टेम्प्लेट चर का उपयोग नहीं करते हैं"।

इसने ज्यादातर इस बात पर चर्चा की कि हम कैसे बंद प्रकार बनाम खुले प्रकारों को पहचानने में विफल हैं। इस संदर्भ में, एक "बंद" प्रकार कुंजी के सीमित सेट के साथ एक प्रकार होगा जिसका मान बढ़ाया नहीं जा सकता है। एक प्रकार की सटीक प्रकार की चाबियाँ, यदि आप करेंगे। इस बीच इस संदर्भ में एक "खुला" प्रकार एक प्रकार है, जिसे उपप्रकारित करते समय, अधिक कुंजियों को जोड़ने के लिए खुला होता है (जो, हमारे वर्तमान उप-नियम के तहत, सॉर्टा सभी प्रकार ज्यादातर कभी-कभी होते हैं, केवल इंडेक्स हस्ताक्षर वाले प्रकारों को छोड़कर, जो बहुत स्पष्ट रूप से हैं) । सूचकांक हस्ताक्षर एक खुले प्रकार का निर्माण करते हैं, जबकि मैप किए गए प्रकार काफी हद तक संबंधित होते हैं, हालांकि वे बंद प्रकारों पर काम कर रहे हैं। यह _usually_ काफी अच्छी तरह से काम करता है क्योंकि अधिकांश कोड, व्यवहार में, बंद ऑब्जेक्ट प्रकारों के साथ संगत संरचना के साथ लिखा जाता है। यही कारण है कि flow (जिसमें बंद बनाम खुली वस्तु प्रकारों के लिए स्पष्ट वाक्यविन्यास है) बंद वस्तु प्रकारों के लिए चूक। यह जेनेरिक इंडेक्स कीज़ के साथ सिर पर आता है; यदि मेरे पास T extends string , तो T का त्वरित और व्यापक प्रकार है ( "a" से "a" | "b" string ) तक, वस्तु जब तक हम "a" | "b" | ... (every other possible string) से string से अधिक स्वैप नहीं कर लेते, तब तक उत्पादन अधिक और विशिष्ट होता है। एक बार ऐसा होने के बाद, अचानक प्रकार बहुत खुला होता है, और जबकि प्रत्येक संपत्ति तक पहुंचने के लिए संभावित रूप से मौजूद हो सकता है, यह कानूनी हो जाता है, उदाहरण के लिए, इसे एक खाली वस्तु असाइन करें। संरचनात्मक रूप से यही होता है, लेकिन जब हम जेनरिक को मैप किए गए प्रकारों से संबंधित करते हैं, तो हम इस बात को अनदेखा कर देते हैं - जेनेरिक मैप्ड टाइप की पर एक string बाधा अनिवार्य रूप से संबंधित है क्योंकि यह सभी संभावित कुंजी मौजूद है। यह तार्किक रूप से कुंजी प्रकार के एक साधारण विचरण-आधारित दृष्टिकोण से अनुसरण करता है, लेकिन केवल सही है कि चाबियाँ एक _closed_ प्रकार से आती हैं (जो, inc, एक सूचकांक के साथ एक प्रकार वास्तव में कभी बंद नहीं होता है!)। तो, अगर हम पीछे की ओर संगत होना चाहता हूँ, हम इलाज _can't_ {[x: T]: U} के रूप में ही {[_ in T]: U} , जब तक, ऑप्टिकल फाइबर केबल, हम चाहते हैं कि, गैर सामान्य मामले में के बाद से {[_ in T]: U} {[x: T]: U} {[_ in T]: U} हो जाता है, समायोजित करें कि हम कैसे खुले प्रकार "बढ़त" के लिए ठीक से खाते के लिए मैप किए गए प्रकार की कुंजी के विचरण को संभालते हैं, जो अपने आप में एक दिलचस्प बदलाव है जो पारिस्थितिकी तंत्र के प्रभाव हो सकता है।

बहुत ज्यादा: क्योंकि यह मैप किए गए प्रकारों और सूचकांक हस्ताक्षरों को एक साथ बहुत करीब लाता है, इसने सवालों का एक गुच्छा उठाया कि हम दोनों को कैसे संभालते हैं कि हमारे पास अभी तक संतोषजनक या निर्णायक जवाब नहीं है।

व्यक्तिगत उपयोग के मामले अप्रासंगिक हैं।

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

हम इन सवालों को पूछकर यहां मुश्किल होने की कोशिश नहीं कर रहे हैं; हम सचमुच यह सुनिश्चित करने की कोशिश कर रहे हैं कि हम उन चीजों को लागू करें जो लोग पूछ रहे हैं। यह एक सच्ची शर्म की बात होगी अगर हमने कुछ सोचा जिसे हमने "प्रतीकों के साथ अनुक्रमणित किया", केवल इस धागे में बहुत ही लोगों को वापस आने के लिए कहा और कहा कि हमने इसे पूरी तरह से गलत किया क्योंकि यह उनके विशेष उपयोग के मामलों को संबोधित नहीं करता था।

आप हमें अंधा उड़ने के लिए कह रहे हैं। कृपया नहीं! कृपया हमें बताएं कि आप कहाँ जाना चाहते हैं!

मेरा बुरा, मैं स्पष्ट कर सकता था कि मेरा क्या मतलब है; यह मुझे ऐसा लगा कि लोगों को लगा कि उन्हें अपने वास्तविक कोड उपयोग के मामलों को सही ठहराना है, बजाय इसके कि वे टीएस के माध्यम से इसे और अधिक सटीक रूप से वर्णन कर सकें

इसलिए अगर मैं इसे सही तरीके से समझूं, तो यह मुख्य रूप से निम्नलिखित समस्या के बारे में है:

const sym = Symbol();
interface Foo
{
    [sym]: number;
    [s: symbol]: string; // just imagine this would be allowed
}

अब टाइपस्क्रिप्ट कंपाइलर इसे एक संघर्ष के रूप में देखेंगे, क्योंकि Foo[sym] में एक अस्पष्ट प्रकार है। हम पहले से ही तार के साथ एक ही मुद्दा है।

interface Foo
{
    ['str']: number; // <-- compiler error: not assignable to string index type 'string'
    [s: string]: string;
}

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

मुझे लगता है कि प्रतीकों के लिए यह एक सर्वव्यापी मुद्दा होगा, क्योंकि ECMA2015 Symbol.iterator जैसे मानक प्रतीकों को परिभाषित करता है, जिसका उपयोग किसी भी वस्तु पर किया जा सकता है और इस प्रकार एक डिफ़ॉल्ट टाइपिंग होनी चाहिए। वे अजीब तरह से स्पष्ट रूप से नहीं है। कम से कम खेल का मैदान मुझे एमडीएन से Symbol.iterator उदाहरण चलाने की अनुमति नहीं देता है।

यह मानते हुए कि पूर्वनिर्धारित प्रतीक टाइपिंग को जोड़ने की योजना है, यह हमेशा एक सामान्य [s: symbol]: SomeType परिभाषा को अमान्य बना देगा, क्योंकि पूर्वनिर्धारित प्रतीक सूचक में पहले से ही असंगत प्रकार होते हैं, इसलिए एक सामान्य सामान्य प्रकार मौजूद नहीं हो सकता है या इसके लिए इसकी आवश्यकता होगी function प्रकार हो, क्योंकि अधिकांश (/ सभी?) पूर्वनिर्धारित प्रतीक कुंजियाँ function प्रकार की हैं।

सामान्य और विशिष्ट सूचकांक प्रकारों के मिश्रण के साथ एक समस्या प्रकार निर्धारण है जब ऑब्जेक्ट को संकलित समय पर ज्ञात मूल्य के साथ अनुक्रमित किया जाता है। स्ट्रिंग सूचकांकों के साथ मेरे उपरोक्त उदाहरण की कल्पना करें कि मान्य होगा, तो निम्नलिखित संभव होगा:

const foo: Foo = {str: 42, a: 'one', b: 'two'};
const input: string = getUserInput();
const value = foo[input];

वही समस्या प्रतीक कुंजियों पर लागू होगी। संकलन-समय पर value का सटीक प्रकार निर्धारित करना असंभव है। यदि उपयोगकर्ता 'str' , तो यह number , अन्यथा यह string (कम से कम टाइपस्क्रिप्ट से यह string होने की उम्मीद होगी, जबकि यह संभावना undefined हो सकती है। क्या यही कारण है कि हमारे पास यह सुविधा नहीं है? कोई इसे value एक यूनियन प्रकार देकर परिभाषा में सभी संभावित प्रकारों को शामिल कर सकता है (इस मामले में number | string )।

@Neonit खैर, यह मुद्दा नहीं है कि एक कार्यान्वयन पर प्रगति रुकी है, लेकिन यह वास्तव में उन मुद्दों में से एक है जो मैं इंगित करने की कोशिश कर रहा हूं - कि आप जो करने की कोशिश कर रहे हैं, उसके आधार पर, प्रतीक इंडेक्सर्स का जवाब नहीं हो सकता है।

यदि यह सुविधा लागू किया गया था, ECMAScript निर्मित प्रतीक है होगा जरूरी नहीं कि सब कुछ बर्बाद क्योंकि नहीं हर प्रकार के उन प्रतीकों का उपयोग करता; लेकिन किसी भी प्रकार के एक प्रसिद्ध प्रतीक (या किसी भी प्रतीक है कि आप अपने आप को परिभाषित) के साथ एक संपत्ति को परिभाषित करता है कि संभावना प्रतीकों के लिए एक कम उपयोगी सूचकांक हस्ताक्षर करने के लिए सीमित किया जाएगा।

यह वास्तव में ध्यान में रखने वाली बात है - "मैं इसे एक मानचित्र के रूप में उपयोग करना चाहता हूं" और "मैं प्रोटोकॉल को लागू करने के लिए प्रतीकों का उपयोग करना चाहता हूं" उपयोग-मामले एक प्रकार-सिस्टम परिप्रेक्ष्य से असंगत हैं। तो अगर आपके मन में ऐसा कुछ था, तो प्रतीक सूचकांक हस्ताक्षर आपकी मदद नहीं कर सकते हैं, और आपको एक स्पष्ट प्रतीक गुणों या मानचित्रों के माध्यम से बेहतर सेवा दी जा सकती है।

क्या UserSymbol प्रकार के बारे में कुछ है जो सिर्फ symbol माइनस में निर्मित प्रतीक हैं? प्रतीकों की बहुत प्रकृति सुनिश्चित करती है कि कभी आकस्मिक टकराव नहीं होगा।

संपादित करें: इस अधिक के बारे में सोचते हुए, प्रसिद्ध प्रतीक केवल प्रहरी हैं जो Symbol का उपयोग करके कार्यान्वित करना चाहिए , क्योंकि उनका भाषा के लिए विशेष अर्थ है। उन्हें symbol प्रकार से हटाने से 'जेनेरिक' प्रतीकों का अधिक सुरक्षित उपयोग करने की संभावना (अधिकांश) कोड हो जाएगी।

@RyanCavanaugh यहाँ मेरी उड़ान योजना है।

मेरे पास एक प्रणाली है जिसमें मैं गुणों के लिए इस तरह के प्रतीकों का उपयोग करता हूं।

const X = Symbol.for(":ns/name")

const txMap = {
  [X]: "fly away with me!"
}

transact(txMap) // what's the index signature here?

इस मामले में मैं चाहता हूँ txMap के प्रकार के हस्ताक्षर फिट करने के लिए transact । लेकिन मेरी जानकारी के अनुसार मैं आज इसे व्यक्त नहीं कर सकता। मेरे मामले में, transact एक पुस्तकालय का हिस्सा है जो यह नहीं जानता कि क्या उम्मीद की जाए। गुणों के लिए मैं कुछ ऐसा करता हूं।

// please forgive my tardiness but in essence this is how I'm typing "TxMap" for objects
type TxMapNs = { [ns: string]: TxMapLocal }
type TxMapLocal = { [name: string]: string | TxMapNs } // leaf or non leaf

मैं स्कीमा से transact फिट करने वाले प्रकारों के सेट को उत्पन्न कर सकता हूं और इसका उपयोग कर सकता हूं। इसके लिए मैं ऐसा कुछ करूंगा और घोषणा के विलय पर निर्भर रहूंगा।

interface TxMap = {
  [DB_IDENT]: symbol // leaf
  [DB_VALUE_TYPE]?: TxMap // not leaf
  [DB_CARDINALITY]?: TxMap
}

लेकिन यह अच्छा होगा यदि मैं कम से कम प्रतीकों के लिए एक इंडेक्स सिग्नेचर के लिए कमबैक कर सकूं, मैं केवल transact सादे जावास्क्रिप्ट ऑब्जेक्ट्स को सौंपने की उम्मीद करता हूं, मैं केवल इस मामले में वैश्विक प्रतीक रजिस्ट्री से प्रतीकों का उपयोग करता हूं। मैं निजी प्रतीकों का उपयोग नहीं करता हूं।

मुझे यह जोड़ना चाहिए कि यह थोड़ा दर्द है।

const x = Symbol.for(":x");
const y = Symbol.for(":x");

type X = { [x]: string };
type Y = { [y]: string };

const a: X = { [x]: "foo" };
const b: Y = { [x]: "foo" }; // not legal
const c: X = { [y]: "foo" }; // not legal
const d: Y = { [y]: "foo" };

यह बहुत बढ़िया होगा यदि टाइपस्क्रिप्ट समझ सकता है कि Symbol.for फ़ंक्शन के माध्यम से बनाए गए प्रतीक वास्तव में समान हैं।

यह भी सुपर कष्टप्रद है।

function keyword(ns: string, name: string): unique symbol { // not possible, why?
  return Symbol.for(":" + ns + "/" + name)
}

const x: unique symbol = keyword("db", "id") // not possible, why?

type X = {
  [x]: string // not possible, why?
}

वह छोटी सी उपयोगिता समारोह मुझे अपने वैश्विक प्रतीक तालिका पर एक सम्मेलन लागू करने देता है। हालाँकि, मैं unique symbol वापस नहीं कर सकता, भले ही इसे Symbol.for फ़ंक्शन के माध्यम से बनाया गया हो। टाइपस्क्रिप्ट चीजों को करने के तरीके के कारण, यह मुझे कुछ समाधानों के लिए मजबूर कर रहा है। वे सिर्फ काम नहीं करते। और मुझे लगता है कि यह दुख की बात है।

मैं एक अन्य उपयोग के मामले में आया हूं, जहां एक इंडेक्सिंग मूल्य के रूप में symbol उपयोगी होगा, जब एक फैक्ट्री फ़ंक्शन बनाने के लिए ES प्रॉक्सी के साथ काम करना एक ऑब्जेक्ट को प्रॉक्सी के साथ लपेटता है।

इस उदाहरण को लें:

let original = {
    foo: 'a',
    bar: 'b',
    baz: 1
};

function makeProxy<T extends Object>(source: T) {
    return new Proxy(source, {
        get: function (target, prop, receiver) {
            return target[prop];
        }
    });
}

let proxied = makeProxy(original);

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

function makeProxy<T extends Object & { [key: string]: any}>(source: T) {

लेकिन अब यह एक त्रुटि उत्पन्न करेगा क्योंकि prop get का 2 तर्क ( prop get ProxyHandler PropertyKey का प्रकार है, जो ऐसा होता है PropertyKey ।

इसलिए मैं अनिश्चित हूं कि इस समस्या के प्रतिबंध के कारण टाइपस्क्रिप्ट के साथ ऐसा कैसे करें।

@ARonpowell आप किस समस्या का सामना कर रहे हैं? मैं देख रहा हूँ कि यह ठीक व्यवहार कर रहा है:

let original = {
    foo: 'a',
    bar: 'b',
    baz: 1
};

function makeProxy<T extends Object>(source: T) {
    return new Proxy(source, {
        get: function (target, prop, receiver) {
            return target[prop];
        }
    });
}

let proxied = makeProxy(original);

function assertString(s:string){}
function assertNumber(x:number){}

assertString(proxied.foo); // no problem as string
assertNumber(proxied.baz); // no problem as number
console.log(proxied.foobar); // fails as expected: error TS2339: Property 'foobar' does not exist on type '{ foo: string; bar: string; baz: number; }'.

tsconfig.json:

{
  "compilerOptions": {
    "module": "esnext",
    "moduleResolution": "node",
    "target": "es2015"
  }

package.json:

{
  "devDependencies": {
    "typescript": "~3.4.5"
  }
}

@beenotung मुझे खेल के मैदान में एक त्रुटि दिखाई देती है:

@ARonpowell त्रुटि तब दिखाई देती है जब आप tsconfig.json में 'कंपाइलर' में 'सख्त' ध्वज सक्षम करते हैं।

इसलिए टाइपस्क्रिप्ट कंपाइलर के वर्तमान संस्करण के तहत, आपको या तो सख्त मोड को बंद करना होगा या टारगेट को any में डालना होगा।

ज़रूर, लेकिन एक any कास्ट वास्तव में आदर्श नहीं है और सख्त मोड को अक्षम करना केवल प्रकार की सुरक्षा में प्रतिबंधों को ढीला करना है।

संदेशों को पढ़ना मुझे लगता है कि अगले "समाधान" शायद "टाइपस्क्रिप्ट को अक्षम करना" होगा।

हमें स्टॉपगैप समाधानों की खोज नहीं करनी चाहिए और न ही यह समझाने की आवश्यकता है कि हमें इसकी आवश्यकता क्यों है।

यह जावास्क्रिप्ट की एक मानक विशेषता है इसलिए हमें टाइपस्क्रिप्ट में इसकी आवश्यकता है।

@DanielRosenwasser मेरी उपयोग के मामले @aaronpowell के समान है - में एक प्रतीयमान बेमेल ProxyHandler इंटरफेस और टाइपप्रति के नियमों मुझे ठीक से प्रॉक्सी हैंडलर जाल टाइपिंग से रोकता है।

एक उबला हुआ उदाहरण इस मुद्दे को प्रदर्शित करता है:

const getValue = (target: object, prop: PropertyKey) => target[prop]; // Error

जहाँ तक मैं बता सकता हूँ, target लिए किसी भी प्रकार का शिल्प करना असंभव है जो कि त्रुटि को टाल देगा अभी तक केवल उन वस्तुओं को अनुमति देता है जिन्हें वैध रूप से PropertyKey तक पहुँचा जा सकता है।

मैं एक टाइपस्क्रिप्ट नौसिखिया हूं तो कृपया मुझे माफ कर दें अगर मुझे कुछ स्पष्ट याद आ रहा है।

एक अन्य उपयोग मामला: मैं कॉलर्स के लिए {[tag: symbol]: SomeSpecificType} एक प्रकार रखने की कोशिश कर रहा हूं ताकि एक विशिष्ट प्रकार के टैग किए गए मानों का नक्शा प्रदान किया जा सके जो वस्तु शाब्दिक वाक्य रचना की कॉम्पैक्टनेस से लाभान्वित करता है (जबकि अभी भी नाम के टकराव से बचा रहा है टैग के रूप में सादे तार का उपयोग करने के जोखिम)।

एक अन्य उपयोग मामला: मैं किसी वस्तु, प्रतीकों और तार दोनों के सभी गुणों को पुनरावृत्त करने की कोशिश कर रहा हूं। मेरा वर्तमान कोड कुछ इस तरह दिखता है (नाम अस्पष्ट):

type ContextKeyMap = Record<PropertyKey, ContextKeyValue>

function setFromObject(context: Context, object: ContextKeyMap) {
    for (const key in object) {
        if (hasOwn.call(object, key)) context.setKey(key, object[key])
    }

    for (const symbol of Object.getOwnPropertySymbols(object)) {
        if (propertyIsEnumerable.call(object, symbol)) {
            context.setKey(symbol, object[symbol as unknown as string])
        }
    }
}

मैं बहुत दृढ़ता से सिर्फ ऐसा करने में सक्षम होना पसंद करूंगा:

type ContextKeyMap = Record<PropertyKey, ContextKeyValue>

function setFromObject(context: Context, object: ContextKeyMap) {
    for (const key in object) {
        if (hasOwn.call(object, key)) context.setKey(key, object[key])
    }

    for (const symbol of Object.getOwnPropertySymbols(object)) {
        if (propertyIsEnumerable.call(object, symbol)) {
            context.setKey(symbol, object[symbol])
        }
    }
}

मैं प्रतीकों के साथ अनुक्रमण के साथ भी समस्या है। मेरा कोड इस प्रकार है:

const cacheProp = Symbol.for('[memoize]')

function ensureCache<T extends any>(target: T, reset = false): { [key in keyof T]?: Map<any, any> } {
  if (reset || !target[cacheProp]) {
    Object.defineProperty(target, cacheProp, {
      value: Object.create(null),
      configurable: true,
    })
  }
  return target[cacheProp]
}

मैंने @ARonpowell द्वारा समाधान का पालन किया और किसी तरह इसे हल करने में कामयाब रहा

const cacheProp = Symbol.for('[memoize]') as any

function ensureCache<T extends Object & { [key: string]: any}>(target: T, reset = false): { [key in keyof T]?: Map<any, any> } {
  if (reset || !target[cacheProp]) {
    Object.defineProperty(target, cacheProp, {
      value: Object.create(null),
      configurable: true,
    })
  }

  return target[cacheProp]
}

करने के लिए कास्टिंग any से symbol वास्तव में बहुत अच्छा नहीं है।

वास्तव में किसी भी अन्य समाधान के लिए सराहना की।

@ahnpnl उस उपयोग के मामले में, आप प्रतीकों की तुलना में WeakMap का उपयोग करके बेहतर होंगे, और इंजन उस बेहतर को ऑप्टिमाइज़ करेंगे - यह target प्रकार के मानचित्र को संशोधित नहीं करता है। आपको अभी भी इसे कास्ट करना पड़ सकता है, लेकिन आपका कास्ट रिटर्न वैल्यू में रहेगा।

मान को असाइन करने के लिए सामान्य फ़ंक्शन का उपयोग करने के लिए एक समाधान है ...

var theAnswer: symbol = Symbol('secret');
var obj = {} as Record<symbol, number>;
obj[theAnswer] = 42; // Currently error, but should be allowed

Object.assign(obj, {theAnswer: 42}) // allowed

मान को असाइन करने के लिए सामान्य फ़ंक्शन का उपयोग करने के लिए एक समाधान है ...

var theAnswer: symbol = Symbol('secret');
var obj = {} as Record<symbol, number>;
obj[theAnswer] = 42; // Currently error, but should be allowed

Object.assign(obj, {theAnswer: 42}) // allowed

में सहमत नहीं हूँ। ये तीन रेखाएँ एक-दूसरे के बराबर होती हैं:

Object.assign(obj, {theAnswer: 42});
Object.assign(obj, {'theAnswer': 42});
obj['theAnswer'] = 42;

@DanielRosenwasser
मेरे पास यह उपयोग मामला है, खेल के मैदान के लिंक में, मैंने इसे नक्शे का उपयोग करके भी हल किया है, लेकिन एक नज़र डालें, तो यह बदसूरत है।

const system = Symbol('system');
const SomeSytePlugin = Symbol('SomeSytePlugin')

/** I would prefer to have this working in TS */
interface Plugs {
    [key: symbol]: (...args: any) => unknown;
}
const plugins = {
    "user": {} as Plugs,
    [system]: {} as Plugs
}
plugins[system][SomeSytePlugin] = () => console.log('awsome')
plugins[system][SomeSytePlugin](); ....

खेल का मैदान लिंक

यहां प्रतीकों का उपयोग करना संभव आकस्मिक अधिलेखित नियमों का पालन करता है जो तार का उपयोग करते समय होता है। यह पूरे सिस्टम को अधिक मजबूत और बनाए रखने में आसान बनाता है।

यदि आपके पास एक वैकल्पिक समाधान है जो टीएस के साथ काम करता है और कोड में समान पठनीयता है, तो मैं सभी कान हूं।

इस मुद्दे के लिए कोई आधिकारिक व्याख्या?

मान को असाइन करने के लिए सामान्य फ़ंक्शन का उपयोग करने के लिए एक समाधान है ...

var theAnswer: symbol = Symbol('secret');
var obj = {} as Record<symbol, number>;
obj[theAnswer] = 42; // Currently error, but should be allowed

Object.assign(obj, {theAnswer: 42}) // allowed

आप देख रहे हैं

Objet.assign(obj, { [theAnswer]: 42 });

हालाँकि, x[theAnswer] कास्ट के बिना पढ़ने का कोई तरीका नहीं है AFAIK नीचे दो टिप्पणी देखें

भगवान के प्यार के लिए, कृपया इसे प्राथमिकता दें।

आप देख रहे हैं

Objet.assign(obj, { [theAnswer]: 42 });

हालाँकि x[theAnswer] एक कलाकार AFAIK के बिना पढ़ने का कोई तरीका नहीं है

जैसा कि मेलोनिस और मिंगवेईसमुएल द्वारा बताया गया है, जेनेरिक फ़ंक्शन का उपयोग करने वाले वर्कअराउंड हैं:

var theAnswer: symbol = Symbol("secret");
var obj = {} as Record<symbol, number>;

obj[theAnswer] = 42; // Not allowed, but should be allowed

Object.assign(obj, { [theAnswer]: 42 }); // allowed

function get<T, K extends keyof T>(object: T, key: K): T[K] {
  return object[key];
}

var value = obj[theAnswer]; // Not allowed, but should be allowed

var value = get(obj, theAnswer); // allowed

पांच साल और प्रतीक के रूप में अभी भी अनुमति नहीं है

इस मामले पर एक काम के आसपास मिला, यह सामान्य नहीं है, लेकिन कुछ मामलों में काम करते हैं:

const SYMKEY = Symbol.for('my-key');

interface MyObject {   // Original object interface
  key: string
}

interface MyObjectExtended extends MyObject {
  [SYMKEY]?: string
}

const myObj: MyObject = {
  'key': 'value'
}

// myObj[SYMKEY] = '???' // Not allowed

function getValue(obj: MyObjectExtended, key: keyof MyObjectExtended): any {
  return obj[key];
}

function setValue(obj: MyObjectExtended, key: keyof MyObjectExtended, value: any): void {
  obj[key] = value
}

setValue(myObj, SYMKEY, 'Hello world');
console.log(getValue(myObj, SYMKEY));

@ james4388 @beenotung से आपका उदाहरण कैसे अलग है?

FYI करें: https://github.com/microsoft/TypeScript/pull/26797

(बस यह पाया गया - मैं वास्तव में टीएस टीम का हिस्सा नहीं हूं।)