टाइपस्क्रिप्ट: एक विधि पैरामीटर में उपयोग किए जाने वाले फ़ंक्शन कॉलबैक (किसी फ़ंक्शन प्रकार के रूप में, किसी भी सार्वभौमिक नहीं) के लिए प्रकार को कैसे परिभाषित किया जाए

Question

वर्तमान में मेरे पास टाइप परिभाषा है:

interface Param {
    title: string;
    callback: any;
}

मुझे कुछ इस तरह की आवश्यकता है:

interface Param {
    title: string;
    callback: function;
}

लेकिन दूसरे को स्वीकार नहीं किया जा रहा है।

Answer 1

वैश्विक प्रकार Functionइस उद्देश्य को पूरा करता है।

इसके अतिरिक्त, यदि आप इस कॉलबैक को 0 तर्कों के साथ लागू करने का इरादा रखते हैं और इसके रिटर्न मान को अनदेखा करेंगे, तो प्रकार () => voidसभी तर्कों से मेल खाता है।

Comments

यह बात बुनियादी प्रकारों

— योगेश

यह एक मूल प्रकार नहीं है क्योंकि आपको अपने तर्कों और वापसी मूल्यों को परिभाषित करना चाहिए। कॉलबैक जैसी कोई चीज़: (संख्या: संख्या) => शून्य; कॉलबैक की तुलना में टाइप चेकिंग के लिए बहुत अधिक उपयोगी है: फ़ंक्शन; होने वाला।

— kpup

@kpup स्पष्ट होने के लिए, क्या आप इस उत्तर की पहली पंक्ति में दिखाए गए अनुसार F का उपयोग नहीं करने के लिए कह रहे हैं Function, और दूसरा पैराग्राफ कह रहे हैं (उपयोग के प्रकार का () => voidया जो भी उपयोग मामले से मेल खाता है) को प्राथमिकता दी जाती है?

— रफिन

Fwiw, समारोह प्रकार पर डॉक्स उपलब्ध हैं यहाँ

— imjared

Answer 2

V1.4 से टाइपस्क्रिप्ट में एक typeकीवर्ड होता है जो एक प्रकार का उपनाम ( typedefसी / सी ++ में अनुरूप) घोषित करता है । आप अपने कॉलबैक प्रकार की घोषणा कर सकते हैं:

type CallbackFunction = () => void;

एक ऐसा समारोह घोषित करता है जिसमें कोई तर्क नहीं होता है और कुछ भी नहीं लौटता है। एक फ़ंक्शन जो किसी भी प्रकार के शून्य या अधिक तर्क लेता है और कुछ भी नहीं देता है:

type CallbackFunctionVariadic = (...args: any[]) => void;

फिर आप कह सकते हैं, उदाहरण के लिए,

let callback: CallbackFunctionVariadic = function(...args: any[]) {
  // do some stuff
};

यदि आप एक ऐसा कार्य चाहते हैं जो मनमानी संख्या लेता है और कुछ भी रिटर्न देता है (शून्य सहित):

type CallbackFunctionVariadicAnyReturn = (...args: any[]) => any;

आप कुछ अनिवार्य तर्कों को निर्दिष्ट कर सकते हैं और फिर अतिरिक्त तर्कों का एक सेट (जैसे कि एक स्ट्रिंग, एक संख्या और फिर अतिरिक्त आरों का एक सेट) आदि को पढ़ सकते हैं:

type CallbackFunctionSomeVariadic =
  (arg1: string, arg2: number, ...args: any[]) => void;

यह EventEmitter हैंडलर जैसी चीजों के लिए उपयोगी हो सकता है।

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

Comments

के बीच Functionऔर (...args: any[]) => anyक्या पसंद किया जाता है?

— Ahong

@ हाँग: व्यक्तिगत रूप से मैं बाद वाला पसंद करूंगा क्योंकि यह एक हस्ताक्षर प्रदान करता है ... सामान्य रूप से। ...args: any[]बहुत उपयोगी नहीं है।

— एड एस।

type CallbackFunctionSomeVariadic = (arg1: string, arg2: number, ...args: any[]) => void;मैं क्या देख रहा था, ty।

— अक्तीफांन

Answer 3

रयान के जवाब के बाद, मुझे लगता है कि आप जिस इंटरफ़ेस की तलाश कर रहे हैं वह इस प्रकार परिभाषित है:

interface Param {
    title: string;
    callback: () => void;
}

Answer 4

यहां एक फ़ंक्शन का एक उदाहरण है जो कॉलबैक स्वीकार करता है

const sqk = (x: number, callback: ((_: number) => number)): number => {
  // callback will receive a number and expected to return a number
  return callback (x * x);
}

// here our callback will receive a number
sqk(5, function(x) {
  console.log(x); // 25
  return x;       // we must return a number here
});

यदि आप कॉलबैक के रिटर्न मूल्यों के बारे में परवाह नहीं करते हैं (ज्यादातर लोग नहीं जानते कि उन्हें किसी भी प्रभावी तरीके से कैसे उपयोग किया जाए), तो आप उपयोग कर सकते हैं void

const sqk = (x: number, callback: ((_: number) => void)): void => {
  // callback will receive a number, we don't care what it returns
  callback (x * x);
}

// here our callback will receive a number
sqk(5, function(x) {
  console.log(x); // 25
  // void
});

ध्यान दें, मैं हस्ताक्षर callbackपैरामीटर के लिए इस्तेमाल किया ...

const sqk = (x: number, callback: ((_: number) => number)): number

मैं कहूंगा कि यह एक टाइपस्क्रिप्ट कमी है क्योंकि हमें कॉलबैक मापदंडों के लिए एक नाम प्रदान करने की उम्मीद है । इस मामले में मैंने उपयोग किया _क्योंकि यह sqkफ़ंक्शन के अंदर उपयोग करने योग्य नहीं है।

हालांकि, अगर आप ऐसा करते हैं

// danger!! don't do this
const sqk = (x: number, callback: ((number) => number)): number

यह मान्य टाइपस्क्रिप्ट है, लेकिन इसकी व्याख्या की जाएगी ...

// watch out! typescript will think it means ...
const sqk = (x: number, callback: ((number: any) => number)): number

यानी, टाइपस्क्रिप्ट को लगता है कि पैरामीटर नाम है numberऔर निहित प्रकार है any। यह स्पष्ट रूप से वह नहीं है जो हमने इरादा किया था, लेकिन अफसोस कि टाइपस्क्रिप्ट कैसे काम करता है।

तो अपने फ़ंक्शन मापदंडों को टाइप करते समय पैरामीटर नाम प्रदान करना न भूलें ... बेवकूफ जैसा कि यह प्रतीत हो सकता है।

Answer 5

आप इंटरफ़ेस में एक फ़ंक्शन प्रकार को विभिन्न तरीकों से परिभाषित कर सकते हैं,

1. सामान्य तरीका:

export interface IParam {
  title: string;
  callback(arg1: number, arg2: number): number;
}

2. यदि आप संपत्ति सिंटैक्स का उपयोग करना चाहते हैं तो,

export interface IParam {
  title: string;
  callback: (arg1: number, arg2: number) => number;
}

3. यदि आप पहले फ़ंक्शन प्रकार की घोषणा करते हैं, तो

type MyFnType = (arg1: number, arg2: number) => number;

export interface IParam {
  title: string;
  callback: MyFnType;
}

उपयोग करना बहुत सीधा है,

function callingFn(paramInfo: IParam):number {
    let needToCall = true;
    let result = 0;
   if(needToCall){
     result = paramInfo.callback(1,2);
    }

    return result;
}

4. आप एक फ़ंक्शन प्रकार को शाब्दिक भी घोषित कर सकते हैं, जिसका अर्थ है कि एक फ़ंक्शन किसी अन्य फ़ंक्शन को पैरामीटर के रूप में स्वीकार कर सकता है। पैरामीटराइज फंक्शन को कॉलबैक भी कहा जा सकता है।

export interface IParam{
  title: string;
  callback(lateCallFn?:
             (arg1:number,arg2:number)=>number):number;

}

Answer 6

चार सार फ़ंक्शन प्रकार हैं, आप उन्हें अलग से उपयोग कर सकते हैं जब आप जानते हैं कि आपका फ़ंक्शन एक तर्क लेगा या नहीं, डेटा वापस करेगा या नहीं।

export declare type fEmptyVoid = () => void;
export declare type fEmptyReturn = () => any;
export declare type fArgVoid = (...args: any[]) => void;
export declare type fArgReturn = (...args: any[]) => any;

इस तरह:

public isValid: fEmptyReturn = (): boolean => true;
public setStatus: fArgVoid = (status: boolean): void => this.status = status;

किसी भी प्रकार के फ़ंक्शन के रूप में केवल एक प्रकार के उपयोग के लिए हम सभी सार प्रकारों को एक साथ जोड़ सकते हैं, जैसे:

export declare type fFunction = fEmptyVoid | fEmptyReturn | fArgVoid | fArgReturn;

फिर इसका उपयोग करें जैसे:

public isValid: fFunction = (): boolean => true;
public setStatus: fFunction = (status: boolean): void => this.status = status;

ऊपर दिए गए उदाहरण में सब कुछ सही है। लेकिन bellow में उपयोग का उदाहरण अधिकांश कोड संपादकों के दृष्टिकोण से सही नहीं है।

// you can call this function with any type of function as argument
public callArgument(callback: fFunction) {

    // but you will get editor error if call callback argument like this
    callback();
}

संपादकों के लिए सही कॉल इस प्रकार है:

public callArgument(callback: fFunction) {

    // pay attention in this part, for fix editor(s) error
    (callback as fFunction)();
}

Answer 7

टाइपस्क्रिप्ट: विधि पैरामीटर में उपयोग किए जाने वाले फ़ंक्शन कॉलबैक के लिए प्रकार कैसे परिभाषित करें ?

आप कॉलबैक को 1) फ़ंक्शन प्रॉपर्टी या 2) विधि के रूप में घोषित कर सकते हैं :

interface ParamFnProp {
    callback: (a: Animal) => void; // function property
}

interface ParamMethod {
    callback(a: Animal): void; // method
}

TS 2.6 के बाद से एक महत्वपूर्ण टाइपिंग अंतर है :

जब कोई फ़ंक्शन प्रॉपर्टी घोषित की जाती है , तो आप ("ध्वनि") प्रकार --strictया --strictFunctionTypesमोड में मजबूत हो जाते हैं । आइए एक उदाहरण लेते हैं:

const animalCallback = (a: Animal): void => { } // Animal is the base type for Dog
const dogCallback = (d: Dog): void => { } 

// function property variant
const param11: ParamFnProp = { callback: dogCallback } // error: not assignable
const param12: ParamFnProp = { callback: animalCallback } // works

// method variant
const param2: ParamMethod = { callback: dogCallback } // now it works again ...

तकनीकी तौर पर बोली जाने वाली, तरीके हैं bivariant और समारोह गुण contravariant के तहत उनके तर्कों में strictFunctionTypes। तरीकों को अभी भी अधिक अनुमेय रूप से चेक किया जाता है (भले ही ध्वनि न हो) बिल्ट-इन प्रकारों के साथ संयोजन में थोड़ा अधिक व्यावहारिक होने के लिए Array।

सारांश

• फ़ंक्शन प्रॉपर्टी और विधि घोषणा के बीच एक प्रकार का अंतर है
• यदि संभव हो तो मजबूत प्रकारों के लिए एक फ़ंक्शन गुण चुनें

खेल का मैदान नमूना कोड