ฟังก์ชั่นที่พิมพ์อย่างรุนแรงเป็นพารามิเตอร์ที่เป็นไปได้ใน TypeScript?

ใน TypeScript ฉันสามารถประกาศพารามิเตอร์ของฟังก์ชั่นเป็นฟังก์ชั่นประเภท มีวิธี "ชนิดปลอดภัย" ในการทำสิ่งนี้ที่ฉันหายไปหรือไม่? ตัวอย่างเช่นพิจารณาสิ่งนี้:

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);

บันทึกการโทรกลับไม่ปลอดภัยพิมพ์ฉันให้มันฟังก์ชั่นการโทรกลับที่พารามิเตอร์ของฟังก์ชั่นเป็นสตริง แต่ฉันผ่านมันจำนวนและรวบรวมโดยไม่มีข้อผิดพลาด ฉันสามารถสร้างพารามิเตอร์ผลลัพธ์ในการบันทึกฟังก์ชั่นประเภทปลอดภัยหรือไม่

TL; DR version: มีผู้แทน. NET ที่เทียบเท่าใน TypeScript หรือไม่

แน่ใจ ประเภทของฟังก์ชั่นประกอบด้วยประเภทของการโต้แย้งและประเภทผลตอบแทน ที่นี่เราระบุว่าcallbackประเภทของพารามิเตอร์จะต้อง "ฟังก์ชั่นที่รับตัวเลขและผลตอบแทนประเภทany":

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);
    }
}

นี่คือเทียบเท่า TypeScript ของผู้แทน. NET ทั่วไปบางคน:

interface Action<T>
{
    (item: T): void;
}

interface Func<T,TResult>
{
    (item: T): TResult;
}

ฉันรู้ว่าโพสต์นี้เก่า แต่มีวิธีการกระชับมากกว่าที่ถามเล็กน้อย แต่อาจเป็นทางเลือกที่มีประโยชน์มาก คุณเป็นหลักสามารถประกาศฟังก์ชั่นในบรรทัดเมื่อโทรวิธีการ ( 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: inputType) => any;

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

นี้สอดคล้องกับกระบวนทัศน์การเขียนโปรแกรมการทำงาน

ใน TS เราสามารถพิมพ์ฟังก์ชั่นในลักษณะต่อไปนี้:

ฟังก์ชั่นประเภท / ลายเซ็น

สิ่งนี้ใช้สำหรับการนำไปใช้จริงของฟังก์ชัน / เมธอดซึ่งมีไวยากรณ์ต่อไปนี้:

(arg1: Arg1type, arg2: Arg2type) : ReturnType

ตัวอย่าง:

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

class Date {
  setTime(time: number): number {
   // ...
  }

}

ตัวอักษรประเภทฟังก์ชั่น

ตัวอักษรประเภทฟังก์ชั่นเป็นอีกวิธีในการประกาศประเภทของฟังก์ชั่น พวกเขามักจะใช้ในลายเซ็นฟังก์ชั่นของฟังก์ชั่นที่สูงกว่า ฟังก์ชันลำดับสูงกว่าคือฟังก์ชันที่ยอมรับฟังก์ชันเป็นพารามิเตอร์หรือส่งคืนฟังก์ชัน มันมีไวยากรณ์ต่อไปนี้:

(arg1: Arg1type, arg2: Arg2type) => ReturnType

ตัวอย่าง:

type FunctionType1 = (x: string, y: number) => number;

class Foo {
    save(callback: (str: string) => void) {
       // ...
    }

    doStuff(callback: FunctionType1) {
       // ...
    }

}

หากคุณกำหนดประเภทฟังก์ชั่นก่อนแล้วมันจะดูเหมือน

type Callback = (n: number) => void;

class Foo {
    save(callback: Callback) : void {        
        callback(42);
    }
}

var foo = new Foo();
var stringCallback = (result: string) : void => {
    console.log(result);
}

var numberCallback = (result: number) : void => {
    console.log(result);
}

foo.save(stringCallback); //--will be showing error
foo.save(numberCallback);

หากไม่มีฟังก์ชั่นประเภทโดยใช้ไวยากรณ์คุณสมบัติธรรมดามันจะเป็น:

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

var foo = new Foo();
var stringCallback = (result: string) : void => {
    console.log(result);
}

var numberCallback = (result: number) : void => {
    console.log(result);
}

foo.save(stringCallback); //--will be showing error
foo.save(numberCallback);

ถ้าคุณต้องการโดยใช้ฟังก์ชั่นอินเทอร์เฟซเช่นตัวแทน c # ทั่วไปมันจะเป็น:

interface CallBackFunc<T, U>
{
    (input:T): U;
};

class Foo {
    save(callback: CallBackFunc<number,void>) : void {        
        callback(42);
    }
}

var foo = new Foo();
var stringCallback = (result: string) : void => {
    console.log(result);
}

var numberCallback = (result: number) : void => {
    console.log(result);
}

let strCBObj:CallBackFunc<string,void> = stringCallback;
let numberCBObj:CallBackFunc<number,void> = numberCallback;

foo.save(strCBObj); //--will be showing error
foo.save(numberCBObj);

นอกจากสิ่งที่คนอื่นพูดแล้วปัญหาที่พบบ่อยคือการประกาศประเภทของฟังก์ชั่นเดียวกันที่มีการโอเวอร์โหลด กรณีทั่วไปคือเมธอด EventEmitter on () ซึ่งจะรับฟังได้หลายประเภท ที่คล้ายกันอาจเกิดขึ้นเมื่อทำงานกับการดำเนินการ redux - และที่นั่นคุณใช้ประเภทการกระทำเป็นตัวอักษรเพื่อทำเครื่องหมายการบรรทุกเกินพิกัดในกรณีของ EventEmitters คุณใช้ประเภทเหตุการณ์ชื่อตัวอักษร:

interface MyEmitter extends EventEmitter {
  on(name:'click', l: ClickListener):void
  on(name:'move', l: MoveListener):void
  on(name:'die', l: DieListener):void
  //and a generic one
  on(name:string, l:(...a:any[])=>any):void
}

type ClickListener = (e:ClickEvent)=>void
type MoveListener = (e:MoveEvent)=>void
... etc

// will type check the correct listener when writing something like:
myEmitter.on('click', e=>...<--- autocompletion