Typescript: कंपाइलर गलत तरीके से पैरामीटर / कॉल टारगेट सिग्नेचर मिसमैच की रिपोर्ट करता है जब प्रसार ऑपरेटर का उपयोग करता है

और ऐसा ही तब है जब args any -प्रकार का हो

function foo(x: number, y: number, z: number) { }

function bar(...args) {
    foo(...args); // Supplied parameters do not match any signature of call target.
}

यह वर्तमान में डिज़ाइन के अनुसार है। लेकिन हमें इस पर पुनर्विचार करना चाहिए।

@smashdevcode , @tjoskar , मैं इस सुविधा के कुछ वास्तविक दुनिया उपयोगों के लिए देख रहा हूँ। विशेष रूप से, क्या आप सरणियों या ट्यूपल्स (या दोनों शायद) के प्रसार की उम्मीद करते हैं? यहाँ खिलौने के कुछ उदाहरण हैं:

//// arrays ////
var a1: number[] = [1,2];
var a2: number[] = [1,2,3];
var a3: number[] = [];
function twoNumbersOrSo(n?: number, m?: number) {
  return (n || -1) * (m || -1);
}
function howManyNumbersLessOne(n?: number, ...ns: number[]) {
    return ns.length;
}

//// tuples ////
var t1: [number, string] = [1, "foo"];
var t2: [number, string, string] = [1, "foo", "bar"];
function veryTraditional(n: number, s: string) {
    for (let i = 0; i < n; i++) {
        console.log(s);
    }
}
function moreInteresting(n: number, s: string, ...rest: string[]) {
    veryTraditional(n, s);
    console.log(rest);
}

अब a1,a2,a3 को पहले दो कार्यों पर लागू किया जा सकता है, और t1,t2 किसी भी दूसरे दो पर लागू किया जा सकता है।

ध्यान दें कि सरणियों के साथ:

1. एक ही प्रकार है, इसलिए सभी मापदंडों को एक ही प्रकार का होना चाहिए। (मुझे लगता है कि यह any ।)
2. सरणियों की लंबाई संकलन समय पर ज्ञात नहीं है, इसलिए मापदंडों को वैकल्पिक होना चाहिए। और प्रसार तर्क को अंतिम (जैसे आज) होना है।

टुपल्स के साथ:

1. मान को किसी बिंदु पर एक प्रकार का एनोटेशन करना होगा। अन्यथा यह एक सरणी के रूप में व्याख्या की जाएगी (जैसे (number | string)[] न [number, number, string] )। खिलौना कोड में यह संक्षिप्तता में किसी भी बचत को मिटा देता है, लेकिन यह वास्तविक परियोजना में ठीक हो सकता है जो पहले से ही बहुत सारे इंटरफेस को परिभाषित करता है।
2. लंबाई समय से पहले जानी जाती है, इसलिए किसी भी प्रकार की पैरामीटर सूची में एक टपल को लागू किया जा सकता है।

हाय @sandersn ,

देर से प्रतिक्रिया व्यक्त करने के लिए क्षमा करें। मैं आपके जवाब से पूरी तरह चूक गया।
मैं केवल एक डेटाटाइप के साथ सरणियों का उपयोग करता हूं, इसलिए टपल-संस्करण मेरे लिए बहुत दिलचस्प नहीं है।
हालाँकि मुझे लगता है कि फंक्शन कॉल्स में फैला हुआ ऑपरेशन किसी भी चलने योग्य वस्तु को स्वीकार करना चाहिए। तो यह उदाहरण के साथ काम करना चाहिए। map और set , और इन मामलों में हमें एक इंटरफ़ेस बनाने की आवश्यकता होगी जो प्रसार ऑपरेटर के साथ काम करता है, भले ही डेटा में कई डेटाटाइप्स हों (जैसे। नया सेट () जोड़ें (1)। .add ( 'स्ट्रिंग'))। लेकिन वह शायद एक और टिकट है?

Set और प्रसार ऑपरेशन (Chrome 46 में काम करता है) के साथ उदाहरण

function foo(...args) {
    console.log(...args);
}
var bar = new Set().add(1).add(2);

foo(...bar); // 1, 2

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

क्या आप एक निश्चित संख्या में तर्कों के साथ अपने सजातीय सरणियों / सेटों को बाकी मापदंडों या कार्यों के साथ पारित करना चाहते हैं? मैं उस चीज़ पर अधिक विस्तार चाहूंगा जिसे आप कॉल कर रहे हैं।

सबसे पहले, मैं आज सुबह प्रसार ऑपरेटर के साथ खेल रहा हूं और मेरे उपयोग के अधिकांश मामले टाइपस्क्रिप्ट [email protected] और http://www.typescriptlang.org/Playground पर नवीनतम संस्करण में ठीक काम करते हैं

तथापि,
मैं सभी मापदंडों को वैकल्पिक बनाने के लिए विचार करना पसंद नहीं करता
प्रसार ऑपरेटर लेकिन मैं समस्या को समझता हूं; सरणियों की लंबाई संकलन समय पर ज्ञात नहीं है
संकलन समय पर मापदंडों की जांच करना असंभव है।

हालाँकि, मुझे लगता है कि यह अच्छा होगा अगर मापदंडों को वैकल्पिक होने की जरूरत नहीं है और यह संकलक है
केवल जांचें कि "स्प्रेड-वैरिएबल" सही प्रकार का है। संख्या []

function fun1(x: number, y: number, z: number) {
    return x+y+z;
}

let arr1 = [1, 2, 3];
let arr2 = [1, 2];

fun1(...arr1);
fun1(...arr2); // OK since `arr2` is number[]
fun1(1, 2); // Should cause an error

क्या यह संभव है?

निम्न कोड टाइपस्क्रिप्ट के वर्तमान संस्करण में काम करता है, जिसे इस मुद्दे को संबोधित करते समय ऐसा नहीं किया गया था।

function fun1(...num) {
    return Math.max(...num);
}

function fun2(a1, ...num) {
    return Math.max(...num);
}

function fun3(a1, ...num) {
    return fun1(...num);
}

let arr = [1, 2, 3];

if (Math.random() < .5) {
    arr.push(1);
}

fun1(...arr);
fun2('first param', ...arr);
fun3('first param', ...arr);

शायद एक अधिक यथार्थवादी उदाहरण (जो आजकल भी काम करता है):

const doSomeWork = ({title, genre, runtime}) => { console.log(title, genre, runtime); };

function fun1(...num) {
    num.forEach(doSomeWork);
}

const data = [{
    title: 'title',
    genre: ['action', 'drama'],
    runtime: 100
}];

fun1(...data);

: +1: एक ही समस्या होने पर, Date निर्माता के विशिष्ट उपयोग के मामले में:

let dateNumberArray: Array<number> = [2015,11,11];
let myNewDate = new Date(...dateNumberArray);

हमारे लिए हम उपयोगकर्ताओं को अपने स्वयं के सहायकों के निर्माण की आवश्यकता के बिना आधार ऐप में argv आवश्यकताओं को कॉन्फ़िगर करने की अनुमति देने के लिए स्प्रेड का उपयोग करते हैं। उदाहरण के लिए:

{
  "yargv": [
    [
      "path",
      {
        "demand": true,
        "describe": "Source",
        "default": ".",
        "alias": "p"
      }
    ]
  ]
}

get appArgs() : { yargv: Array<Array<any>>, chdir: Array<boolean | string> } {
  return require(
    "../args.json"
  )
}

argv() : Promise<{}> {
  return new Promise((resolve) => {
    this.appArgs.yargv.forEach(v => yargs.option(...v))
    return resolve(yargs.usage("$0 [args]").help("h").
      alias("h", "help").argv)
  })
}

एक वास्तविक दुनिया उदाहरण https://github.com/ReactiveX/rxjs के कम्बाइंड फ़ंक्शन का उपयोग करते हुए जहां मैं this मूल्य को संरक्षित करना चाहता हूं, जब एक तीर फ़ंक्शन का उपयोग करके projectFn कॉल करता है और बाकी मापदंडों का उपयोग करता है तर्कों का प्रचार करें।

getCombination() {
    return this.firstObservable
      .combineLatest(this.secondObservable, (...args) => this.projectFn(...args)));
  }

वर्तमान में मुझे करना है

getCombination() {
    return this.firstObservable
      .combineLatest(this.secondObservable, (...args) => this.projectFn.apply(this, args)));
  }

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

import { merge } from 'lodash';

...
return merge(...arrayOfObjects);

यहाँ एक और वास्तविक दुनिया का उपयोग मामला है; हम इस तरह लगने वाले कोड को रिफलेक्टर करने की कोशिश कर रहे हैं:

return Observable
      .forkJoin(a, b)
      .map(([current, past]) => this.mergeData(current, past));

थोड़ा और अधिक सुरुचिपूर्ण में:

return Observable
      .forkJoin(a, b)
      .map(data => this.mergeData(...data));

लेकिन प्रसार ऑपरेटर का उपयोग हस्ताक्षर बेमेल त्रुटि को ट्रिगर करता है।

एक और उदाहरण

class Parent {
    constructor(a, b, c){

    }
}

class Child extends Parent {
    constructor(d, ...args) {
        super(...args);
    }
}

TS2346: मान लिया गया पैरामीटर कॉल लक्ष्य के किसी भी हस्ताक्षर से मेल नहीं खाता है।

अधिभार विधियों के साथ एक ही मुद्दा:

listen(port: number, hostname?: string, backlog?: number, listeningListener?: Function): Server;
listen(port: number, hostname?: string, listeningListener?: Function): Server;
listen(port: number, backlog?: number, listeningListener?: Function): Server;
listen(port: number, listeningListener?: Function): Server;
listen(path: string, backlog?: number, listeningListener?: Function): Server;
listen(path: string, listeningListener?: Function): Server;
listen(options: ListenOptions, listeningListener?: Function): Server;
listen(handle: any, backlog?: number, listeningListener?: Function): Server;
listen(handle: any, listeningListener?: Function): Server;

जबकि कहा जाता है

myListen(...args) {
    listen(...args);
}

तब: _ [ts] मान लिया गया मानदंड कॉल लक्ष्य के किसी भी हस्ताक्षर से मेल नहीं खाता है ।_

तो अभी के लिए ऐसा करना असंभव है:

export type DateProp = Date | (string|number)[];

const setDate = (value: DateProp): Date => (
    isDate(value) ? value : new Date(...value)
);

जैसा कि यह त्रुटि पैदा कर रहा है:

माना जाता है कि मानदंड कॉल लक्ष्य के किसी भी हस्ताक्षर से मेल नहीं खाते हैं।

भले ही मान में सही डेट कॉन्ट्रैक्टर पैरामीटर मान

भले ही मान में सही डेट कॉन्ट्रैक्टर पैरामीटर मान

यह सही है, यह वही है जो इस मुद्दे को ट्रैक कर रहा है।

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

मैं वास्तव में इस मुद्दे के साथ मारा गया था जब मैं एक नया नाम दिया .js करने के लिए फ़ाइल .ts । किसी भी तरह, "सभी वैध जेएस वैध टीएस नहीं है" का एक उदाहरण।

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

import {css} from 'styled-components';

export const Breakpoints = {
    tablet: 580,
    desktop: 800,
};

export type BreakpointLabels = keyof typeof Breakpoints;

export const media = Object.keys(Breakpoints).reduce((mediaQueries, label: BreakpointLabels) => (
    {
        ...mediaQueries,
        [label]: (...args: any[]) =>
            css`
                <strong i="7">@media</strong> (max-width: ${Breakpoints[label]}px) {
                    ${css(...args)}
                      ^^^^^^^^^^^^ Supplied parameters do not match any signature of call target.
                }
            `
    }
), {});

मेरा वर्कअराउंड css.call , जो कम से कम any[] -typed args के साथ काम करता है:

import {css} from 'styled-components';

export const Breakpoints = {
    tablet: 580,
    desktop: 800,
};

export type BreakpointLabels = keyof typeof Breakpoints;

export const media = Object.keys(Breakpoints).reduce((mediaQueries, label: BreakpointLabels) => (
    {
        ...mediaQueries,
        [label]: (...args: any[]) =>
            css`
                <strong i="13">@media</strong> (max-width: ${Breakpoints[label]}px) {
                    ${css.call(this, ...args)}
                }
            `
    }
), {});

एक ही समस्या, मेरा उदाहरण मूल विलय कार्य है:

merge(target: T, ...sources: T[])

क्या कोई त्रुटि है कि इस त्रुटि को कम से कम प्रति फ़ाइल कैसे म्यूट किया जाए?

वास्तव में, मैं उन कारणों को देखना चाहता हूं कि क्यों इस ES6 संभावना को डिज़ाइन या किसी भी योजना से तोड़ा जाता है जब इसे पुनर्विचार किया जा सकता है। @mhegazy कृपया कमेंट करे

हमने हाल ही में कॉल अभिव्यक्तियों में फैलने की अनुमति देने के लिए एक बदलाव किया है यदि लक्ष्य सभी वैकल्पिक है (देखें https://github.com/Microsoft/TypeScript/pull/15849)। परिवर्तन एक वैकल्पिक आउटपुट को वैकल्पिक तर्कों के अनंत सेट के रूप में मानकर काम करता है।

इस परिवर्तन के साथ, यहाँ उदाहरणों में वर्तमान स्थिति है:

declare var args: number[];

function foo(x?: number, y?: number, z?: number) { }
foo(...args);     // OK
foo(2, ...args);  // OK

function bar(...args: number[]) { }
bar(...args);     // OK
bar(2, ...args);  // OK

function baz(x: number, y: number, z: number) { }
baz(...args);     // still not allowed

पिछले उदाहरण में, संकलक के पास यह पुष्टि करने का कोई तरीका नहीं है कि args आवश्यक baz संतुष्ट करें, क्योंकि args की लंबाई को वैधानिक रूप से मान्य नहीं किया जा सकता है।

इस क्षेत्र में जो कुछ बचा है वह एक ही लंबाई के आवश्यक तर्कों के साथ कार्यों को संतुष्ट करने के लिए ज्ञात आकार के साथ ट्यूपल्स को अनुमति देने के लिए है .. लेकिन यह उतना सरल नहीं है जितना कि यह ध्वनि हो सकता है। उदाहरण के लिए:

function baz(x: number, y: number, z: number) { }
var tuple: [number, number, number] = [1, 2, 3];
baz(...tuple);     // should be allowed

मुझे @devrelm जैसी ही समस्या है

मुझे अभी भी इससे समस्या हो रही है, क्या गलत है?

class A {
    constructor(message: string, test?: any) {
        console.log('A constructor called');
    }
}

class B extends A {
    constructor(...spread) {
        super('a', ...spread);
    }
}

यह टाइपस्क्रिप्ट खेल के मैदान पर एक त्रुटि देता है

@owlcode यह टीएस 2.4 में है, लेकिन खेल का मैदान 2.4 रिलीज के बाद टीएस 2.3 पर है।

यह टीएस 2.4 में तय किया गया प्रतीत होता है,

export function log(...args: any[]) {
    console.log(...join(args.map(formatDevTools),' '));
}

हालाँकि, TS 2.4 में एक नया बग दिखाई देता है:

TS2461: टाइप करें 'Iterable'कोई सरणी प्रकार नहीं है।

तब होता है जब आप एक चलने योग्य ( [...obj] ) फैलाने की कोशिश करते हैं।

और अभी तक 2.4.1-insiders.20170615 में एक अलग बग (मुझे लगता है) जिसे मैं अभी तक समझ नहीं पाया हूं।

मैं नहीं जानता कि यह कैसे हो सकता है। हमारे सरणियों को any[] से मदद नहीं मिलेगी।

कोई बात नहीं, हम Console की परिभाषा को ठीक कर सकते हैं,

interface _Console {
    assert(test?: boolean, message?: string, ...optionalParams: any[]): void;
    clear(): void;
    count(countTitle?: string): void;
    debug(...optionalParams: any[]): void;
    dir(value?: any, ...optionalParams: any[]): void;
    dirxml(value: any): void;
    error(...optionalParams: any[]): void;
    exception(message?: string, ...optionalParams: any[]): void;
    group(groupTitle?: string): void;
    groupCollapsed(groupTitle?: string): void;
    groupEnd(): void;
    info(...optionalParams: any[]): void;
    log(...optionalParams: any[]): void;
    msIsIndependentlyComposed(element: Element): boolean;
    profile(reportName?: string): void;
    profileEnd(): void;
    select(element: Element): void;
    table(...data: any[]): void;
    time(timerName?: string): void;
    timeEnd(timerName?: string): void;
    trace(...optionalParams: any[]): void;
    warn(...optionalParams: any[]): void;
}

और फिर console ऑब्जेक्ट डालें:

export function log(...args: any[]) {
    (console as _Console).log(...join(args.map(formatDevTools),' '));
}

वह अब के लिए करना होगा।

मैंने इसके लिए # 18004 पर एक PR खोला।

अभी के लिए, मुझे अपने tsconfig में "noStrictGenericChecks" को सक्षम करना होगा।

अभी के लिए, मुझे अपने tsconfig में "noStrictGenericChecks" को सक्षम करना होगा।

मुझे यकीन नहीं है कि मैं देख रहा हूँ कि यह कैसे इस बग से संबंधित है ...

मुझे यकीन नहीं है कि मैं देखता हूं कि यह इस बग से कैसे संबंधित है।

@mhegazy यह सेटिंग सभी फ़ंक्शन हस्ताक्षरों को निष्क्रिय कर देती है, इसलिए मैं तर्कों की मात्रा का मिलान किए बिना प्रसार ऑपरेटर का उपयोग करके तर्क पारित कर सकता हूं (कम से कम सांख्यिकीय रूप से नहीं)

यह --noStrictGenericChecks क्या नहीं है। कृपया https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#stricter -checking-for-generic-functions देखें

मैं बस इस पार भागा।

जबकि मैं समझ सकता हूं कि यह मुश्किल है, कम से कम "अधिक" तर्क को पहचानने में सक्षम होना चाहिए।

एक वास्तविक दुनिया के नजरिए से @sandersn हम एक एपीआई का foo(value, ...otherValues) तरह कुछ कर रहे थे, उन्हें त्रुटियों के रूप में पहचाना नहीं जा रहा था। विशेष रूप से यह वास्तव में खतरनाक लगता

declare const foo: (value: string) => string;

foo('bar', 'qat'); // Expected 1 arguments, but got 2.

foo('bar', ...['qat']); // No error

@kitsonk क्या आप इसके लिए एक अलग बग खोल सकते हैं? अलगाव में विचार करना आसान होगा, और संभवतः मौजूदा नियमों के लिए एक जटिल बदलाव के बजाय एक छोटा सा मोड़ है।

यहां तक ​​कि अगर मैं लंबाई की जांच करता हूं, तब भी मुझे यह त्रुटि मिलती है:

function myFunc(...args: any[]) {
  if(args.length > 0) {
    otherFunc(...args)
  }
}

संपादित करें:

भ्रम को दूर करने के लिए, मुझे यहां से पुनर्निर्देशित किया गया था, जो बताता है:

2 तर्क की उम्मीद है, लेकिन कम से कम 0 मिला है

उस मुद्दे को इस मुद्दे की नकल माना जाता था।

मेरे मामले में, मैं इस तरह के इनिशियलाइज़र में से एक के रूप में function otherFunc() जोड़कर विधि को पारित करने के लिए कुछ भी करने की अनुमति देकर अपनी त्रुटि (एक फिक्स से अधिक एक हैक की तरह) को ठीक करने में सक्षम था:

function otherFunc()
function otherFunc(arg1: string)
function otherFunc(arg1: string, arg2: number)
function otherFunc(...args: any[]) {
  // Do stuff
}

यह वर्कअराउंड 2.7 पर टूट जाता है

यह अभी भी एक मुद्दा कैसे है? फैले ऑपरेटरों जेएस में काम करने के लिए एक पूरी तरह से आज्ञाकारी तरीका है, इसलिए टीएस को इसके लिए ठीक से खाता होना चाहिए।

@ jpike88 मुझे पता है कि आप अच्छी तरह से मतलब है, लेकिन आप इस तरह के बयानों का एहसास नहीं कर सकते हैं जैसे काउंटर उत्पादक हैं। मुद्दा उनके TODO मील के पत्थर 2.7 या 2.8 के लिए है यह जैसा दिखता है। यह ठीक करने के लिए एक स्पष्ट बात की तरह लग सकता है, लेकिन जब आपके पास ठीक करने के लिए हजारों स्पष्ट चीजें हैं तो आप संभवतः उन सभी को एक ही समय में ठीक नहीं कर सकते हैं, और उन अन्य चीजों में सुधार करना जारी रख सकते हैं जो उनसे अपेक्षित हैं। अपने वोट को आवाज़ देने का सबसे अच्छा तरीका मूल पोस्ट को शीर्ष पर your प्रतिक्रिया देना है। यह सब के बाद मुफ्त सॉफ्टवेयर है और वे हमें कुछ भी देना नहीं है। उस ने कहा, यह सिर्फ मेरा लेना है, एक और उपयोगकर्ता
की तरह आप 🕺

एक और अच्छा टेस्टकेस (वास्तव में टीएस 2.7 का एक प्रतिगमन) यह है:

class NonEmptyArray<T> extends Array<T> {
        0: T;
}

function c(firstArg: string, ... plainValues: string[]): string;
function c(): undefined;
function c(...values: string[]): string | undefined {
        if (!values.length) {
                return undefined;
        }
        return "";
}


function d(): NonEmptyArray<string> {
        return [""];
}

function y(): string | undefined {
        return c(...d());
}

यह उत्तपन करता है

test.ts (20,9): त्रुटि TS2557: कम से कम 0 तर्क की उम्मीद है, लेकिन 0 या अधिक मिला है।

प्रसार ऑपरेटर के संबंध में एक और मुद्दा मेरे सामने आया:

const get = (id?: string = '1231254', bar?: Bar, baz?: Baz) => {...}
const foo: [undefined, Bar, Baz] = [undefined, bar, baz]

get(...foo) // [ts] Argument of type 'Bar | Baz' is not assignable to parameter  
of type 'string'.
Type 'Baz' is not assignable to type 'string'

बेशक, ईएस 6 में मुझे तर्क के रूप में अपरिभाषित के साथ सरणी फैलाने की कोई समस्या नहीं है और undefined ठीक से पास करते हैं, लेकिन ऐसा लगता है जैसे टीएस ने undefined मूल्यों को अनदेखा किया जब वह उन्हें फैलाता है।

एक और वास्तविक दुनिया उदाहरण, जिसमें फ़ंक्शन कॉल में प्रसार ऑपरेटर की सही हैंडलिंग बहुत मदद करेगी:
मेरे पास NSwagStudio द्वारा उत्पन्न फ़ंक्शन हैं - C # WebApi के लिए API जनरेटर, जिनके समान पैरामीटर हैं (GET पैरामीटर संरचना में परिभाषित हैं)

उत्पन्न फ़ंक्शन निम्न जैसा दिखता है:

export interface ITableApiClient {
    getTableInfo(objnam: string | null, objsch: string | null | undefined, dbnam: string | null, conid: number | undefined): Promise<FileResponse | null>;
    otherFunction(objnam: string | null, objsch: string | null | undefined, dbnam: string | null, conid: number | undefined): Promise<string | null>;
}

मैं इसे सिंटेक्स के साथ कॉल करना चाहता हूं

   get tableIdentification() {
       return [this.name, this.schema, this.databaseName, this.serverConnectionId];
   }
...
   return apiClient.getTableInfo(...this.tableIdentification);

   // this doesn't help, still compile-time error
   // return apiClient.getTableInfo(...(this.tableIdentification as any));

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

@smashdevcode मेरे लिए समाधान @ ts-

function foo(x: number, y: number, z: number) { }
var args = [0, 1, 2];
// @ts-ignore
foo(...args);

यहाँ उदाहरण: https://stackblitz.com/edit/typescript-ecymei?embed=1&file=exex.ts

@ darekf77 , या यदि आप कहते हैं कि args टपल है:

function foo(x: number, y: number, z: number) { }
const args: [number, number, number] = [0, 1, 2];
foo(...args);

TS-खेल का मैदान

@ darekf77 , या यदि आप कहते हैं कि args टपल है:

function foo(x: number, y: number, z: number) { }
const args: [number, number, number] = [0, 1, 2];
foo(...args);

यह मेरे लिए तब काम करता है जब मैं कमांड लाइन में टाइपस्क्रिप्ट को संकलित करता हूं, लेकिन तब नहीं जब विजुअल स्टूडियो कोड टाइप करते समय टाइपस्क्रिप्ट को मान्य करता है। मुझे यकीन नहीं है कि डिस्कनेक्ट यहां क्या है।

मुझे लगता है कि यह एक साल से अधिक हो गया है क्योंकि jayphelps ने उल्लेख किया है कि यह आगामी रिलीज में तय किया जाएगा, लेकिन यह समस्या अभी भी होती है। क्या इस पर कोई अपडेट है? मुझे पता है कि मैं @ ts-ign का उपयोग कर सकता हूं लेकिन यह फ़ंक्शन के लिए सभी टाइपस्क्रिप्ट संदेशों को हटा देता है इसलिए यह वास्तव में एक उपयुक्त समाधान नहीं है।

@TidyIQ जैसा कि टुपल के रूप में टाइप करें।

सरणी निश्चित-लंबाई नहीं है, इसलिए यह काम नहीं करेगा।

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

(यह प्रश्न संभवतः अतिप्रवाह (या समान) को ढेर करने के लिए स्थानांतरित किया जाना चाहिए)

@TidyIQ , यदि सरणी की लंबाई ठीक नहीं है, तो संकलक यह नहीं बता सकता है कि सरणी उपयुक्त है या नहीं।

function foo(x: number, y: number, z: number) { }
const args = arrayOfSomeLength;
foo(...args); // Error: The compiler do not know if there is 3 or 2 or 1 or 50 elements in the array. 

तो अगर सरणी गतिशील लंबाई की है, तो तर्क यह होना चाहिए कि:

function foo(...args: number[]) { }
const args = arrayOfSomeLength;
foo(...args);

खेल का मैदान

दुर्भाग्य से यह मेरे कुछ args के रूप में काम नहीं करेगा निश्चित लंबाई है।

शायद अगर मैं सिर्फ कोड पोस्ट करता हूं तो आपको समस्या दिखाई दे सकती है।

interface IF_Object {
  [key: string]: object;
}
//  VALUE SHOULD BE REQUIRED BUT MADE OPTIONAL TO BYPASS TYPESCRIPT ERROR
interface IF_SetKV {
  (key: string, value?: any): Function;
}
//  VALUE SHOULD BE REQUIRED BUT MADE OPTIONAL TO BYPASS TYPESCRIPT ERROR
interface IF_CreateState {
  (key: string, value?: any, ...more: string[]): Function;
}

const setKV: IF_SetKV = (key, value) => (object: IF_Object = {}) => ({
  ...object,
  [key]: value
});

const createState: IF_CreateState = (key, value, ...more) => (
  object: IF_Object = {}
) =>
  more.length === 0
    ? setKV(key, value)(object)
    : setKV(key, createState(value, ...more)(object[key]))(object);

// TYPESCRIPT ERROR OCCURS HERE. CAN ONLY BE REMOVED WITH TS<strong i="7">@IGNORE</strong>
const newState = createState(...stateList, action.payload.value)(reduced);

@TidyIQ , मुझे यकीन नहीं है कि मैं अनुसरण करता हूं। यदि stateList खाली सरणी है तो क्या होगा? उस मामले में action.payload.value को key रूप में पारित किया जाएगा?

क्या यह काम नहीं करना चाहिए:

const createState = (...args: string[]) => (object: IF_Object = {}) => {
  const [key, value, ...rest] = args;
  if (rest.length === 0) {
    setKV(key, value)(object)
  } else {
    setKV(key, createState(value, ...rest)(object[key]))(object);
  }
}

उस फ़ंक्शन के ParameterType के रूप में मूल्य फैलाने के लिए कास्ट करें जिसमें आप तर्क दे रहे हैं।

const add = (a: number, b: number) => a + b

const values = {
  a: 1,
  b: 2,
}

type AddParams = Parameters<typeof add>

add(...(values) as AddParams)

@ mateja176 यह भी काम करने लगता है और बेहतर हो सकता है कि कुछ उपयोग मामलों के लिए उपयुक्त हो।

add(...(values as [number,number]))

या

add(...(values as [any,any]))

मैं स्पष्ट रूप से टाइप करने के लिए बिना मनमानी सरणियों को संभालने के लिए इसके लिए एक सहायक प्रकार का उपयोग करता हूं:

type NonEmptyArray<T extends any[]> = T extends (infer U)[]
  ? [U, ...U[]]
  : never

इसका उपयोग इस तरह किया जा सकता है:

add(...values as NonEmptyArray<typeof values>)

NonEmptyArray प्रकार के निम्नलिखित विच्छेदन बताते हैं कि यह विस्तार से कैसे काम करता है:

# # भाग | व्याख्या
- | - | -
(१) | type NonEmptyArray | सहायक प्रकार का नाम
(२) | <T | सहायक प्रकार एक सामान्य प्रकार के पैरामीटर T लेता है।
(३) | extends any[]> | प्रकार चेकर द्वारा स्वीकार किए जाने के लिए, उस प्रकार का पैरामीटर T कुछ सरणी प्रकार होना चाहिए।
(४) | T extends (infer U)[] ? | हमारा सहायक प्रकार एक सशर्त प्रकार है जो जाँचता है कि क्या T वास्तव में एक सरणी प्रकार है।
हमने (3) में एक सरणी प्रकार के रूप में T घोषणा की है, इसलिए यह स्थिति हमेशा गुजरती है, लेकिन सशर्त का उपयोग करके हमें टाइपस्क्रिप्ट infer टाइप करने की अनुमति देता है कि T सरणी से बना है और हम उस प्रकार को U ।
(५) | [U, ...U[]] | अब हम परिणामस्वरूप प्रकार को इकट्ठा कर सकते हैं: एक सरणी जहां पहली प्रविष्टि U और शेष (0 या अधिक) प्रविष्टियां भी U ।
इस विशिष्ट की वजह से टपल अंकन, टाइपप्रति अवगत कम से कम एक आइटम है कि वहाँ है।
(६) | : never | यह सिर्फ सशर्त रूप से पूरा करने के लिए आवश्यक है। याद रखें: सशर्त सिर्फ U प्रकार निकालने के लिए एक चाल है, और यह हमेशा गुजरता है। इसलिए, हम never उपज देकर "और" शाखा को सुरक्षित रूप से अनदेखा कर सकते हैं।

अब अगर हम ऐसा करते हैं ...

ts const values = [1,2,3] add(...values as NonEmptyArray<typeof values>)

... निम्नलिखित होगा:

• typeof values वह प्रकार है जो टाइपस्क्रिप्ट values सरणी के लिए अनुमानित है, जो संख्याओं की एक सरणी है: number[] ।
• इसका मतलब है, हम number[] को T । (2/3)
• T वास्तव में एक सरणी प्रकार है, इसलिए, हम इसमें से U अनुमान लगा सकते हैं, जो number । (4)
• अब जब हम U number जानते हैं, तो हम [number, ...number[]] टाइप करते हैं। (5)
  

@tjoskar अपने कोड को बदल दें

function foo(x: number, y: number, z: number, f: number) { }
const args: [number, number, number] = [0, 1, 2];
foo(...args, 3);

( खेल का मैदान )
और त्रुटि वापस।

हैरानी की बात है, अगर आप अंतिम पंक्ति को foo(3, ...args); बदलना चाहते थे - तो कोई त्रुटि नहीं होगी।

मुझे लगता है कि यह अभी भी काम नहीं कर रहा है। यहाँ मेरा उदाहरण है

onSetValue={(...args: Parameters<typeof props.onSetValue>) => {
    setLanguage(null);
    props.onSetValue(...args); // Expected 2 arguments, but got 0 or more.
  }}

यह वास्तव में कोई फर्क नहीं पड़ता कि props.onSetValue का प्रकार क्या है, क्योंकि मैं बस पैरामीटर प्रकार लेता हूं और इसे उस फ़ंक्शन को पास करता हूं जिसे मुझे टाइप किया गया है और यह अभी भी Expected 2 arguments, but got 0 or more. त्रुटि देता है ।

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

यहाँ @ Haaxor1689 का एक छोटा रूप है उदाहरण:
खेल का मैदान लिंक

मैं अभी भी इसे काम नहीं कर सकता

यह मेरा अस्थायी समाधान है

class Board {
  private events: Events

  public on(...args: Parameters<this['events']['on']>) {
    this.events.on.call(this.events, ...args)
  }
}