typescript - टाइपस्क्रिप्ट में पैरामीटर के रूप में दृढ़ता से टाइप किए गए फ़ंक्शन हैं?




(3)

टाइपस्क्रिप्ट में मैं फ़ंक्शन के पैरामीटर को एक प्रकार के फ़ंक्शन के रूप में घोषित कर सकता हूं। क्या ऐसा करने का एक "प्रकार-सुरक्षित" तरीका है कि मुझे याद आ रही है? उदाहरण के लिए, इस पर विचार करें:

class Foo {
    save(callback: Function) : void {
        //Do the save
        var result : number = 42; //We get a number from the save operation
        //Can I at compile-time ensure the callback accepts a single parameter of type number somehow?
        callback(result);
    }
}

var foo = new Foo();
var callback = (result: string) : void => {
    alert(result);
}
foo.save(callback);

सेव कॉलबैक सुरक्षित नहीं है, मैं इसे एक कॉलबैक फ़ंक्शन दे रहा हूं जहां फ़ंक्शन का पैरामीटर स्ट्रिंग है लेकिन मैं इसे एक नंबर पास कर रहा हूं, और कोई त्रुटि नहीं है। क्या मैं एक प्रकार-सुरक्षित फ़ंक्शन सहेजने में परिणाम पैरामीटर बना सकता हूं?

टीएल; डॉ संस्करण: टाइपस्क्रिप्ट में .NET प्रतिनिधि के बराबर है?


ज़रूर:

class Foo {
    save(callback: (n: number) => any) : void {
        callback(42);
    }
}
var foo = new Foo();

var strCallback = (result: string) : void => {
    alert(result);
}
var numCallback = (result: number) : void => {
    alert(result.toString());
}

foo.save(strCallback); // not OK
foo.save(numCallback); // OK

यदि आप चाहते हैं, तो आप इसे एक प्रकार को परिभाषित करने के लिए परिभाषित कर सकते हैं:

type NumberCallback = (n: number) => any;

class Foo {
    // Equivalent
    save(callback: NumberCallback) : void {
        callback(42);
    }
}

मुझे एहसास है कि यह पोस्ट पुराना है, लेकिन एक और कॉम्पैक्ट दृष्टिकोण है जो पूछा गया था उससे थोड़ा अलग है, लेकिन यह एक बहुत उपयोगी विकल्प हो सकता है। विधि को कॉल करते समय आप अनिवार्य रूप से फ़ंक्शन इन-लाइन घोषित कर सकते हैं save() इस मामले में Foo 's save() )। यह ऐसा कुछ दिखाई देगा:

class Foo {
    save(callback: (n: number) => any) : void {
        callback(42)
    }

    multipleCallbacks(firstCallback: (s: string) => void, secondCallback: (b: boolean) => boolean): void {
        firstCallback("hello world")

        let result: boolean = secondCallback(true)
        console.log("Resulting boolean: " + result)
    }
}

var foo = new Foo()

// Single callback example.
// Just like with @RyanCavanaugh's approach, ensure the parameter(s) and return
// types match the declared types above in the `save()` method definition.
foo.save((newNumber: number) => {
    console.log("Some number: " + newNumber)

    // This is optional, since "any" is the declared return type.
    return newNumber
})

// Multiple callbacks example.
// Each call is on a separate line for clarity.
// Note that `firstCallback()` has a void return type, while the second is boolean.
foo.multipleCallbacks(
    (s: string) => {
         console.log("Some string: " + s)
    },
    (b: boolean) => {
        console.log("Some boolean: " + b)
        let result = b && false

        return result
    }
)

multipleCallback() दृष्टिकोण नेटवर्क कॉल जैसी चीजों के लिए बहुत उपयोगी है जो सफल या असफल हो सकते हैं। फिर नेटवर्क कॉल उदाहरण मानते हुए, जब multipleCallbacks() कहा जाता है, तो सफलता और विफलता दोनों के लिए व्यवहार एक स्थान पर परिभाषित किया जा सकता है, जो भविष्य में कोड पाठकों के लिए खुद को अधिक स्पष्टता देता है।

आम तौर पर, मेरे अनुभव में, यह दृष्टिकोण खुद को अधिक संक्षिप्त, कम अव्यवस्था, और समग्र रूप से अधिक स्पष्टता के रूप में उधार देता है।

अच्छा भाग्य सभी के लिए!


type FunctionName = (n: returnType) => any;

class ClassName {
    save(callback: FunctionName) : void {
        callback(data);
    }
}

यह निश्चित रूप से कार्यात्मक प्रोग्रामिंग प्रतिमान के साथ संरेखित करता है।





typescript