如何定义类型的函数回调(作为任何函数类型，不是通用的任何)在一个方法参数中使用

目前我有类型定义为:

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

我需要这样的东西:

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

但是第二项不被接受。

当前回答

有四种抽象函数类型，当你知道你的函数是否接受参数，是否返回数据时，你可以分别使用它们。

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;

在上面的例子中，一切都是正确的。但是从大多数代码编辑器的角度来看，下面的使用示例是不正确的。

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

2020-01-04 14:06:26

其他回答

希望这对你有所帮助……

interface Param {
    title: string;
    callback: (error: Error, data: string) => void;
}

或在函数中


let myfunction = (title: string, callback: (error: Error, data: string) => void): string => {

    callback(new Error(`Error Message Here.`), "This is callback data.");
    return title;

}

2020-08-06 16:13:58

你可以用多种方式在接口中定义函数类型，

一般方法:

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

如果你想使用属性语法，

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

如果先声明函数类型，

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

你也可以声明一个函数类型文字，这意味着一个函数可以接受另一个函数作为它的形参。参数化函数也可以作为回调函数调用。

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

}

2018-09-17 07:41:52

我刚开始使用Typescript，我一直试图解决类似的问题，就像这样;如何告诉Typescript我正在传递一个没有接口的回调。

在浏览了Stack Overflow和GitHub问题的一些答案后，我终于找到了一个解决方案，可以帮助任何有同样问题的人。

函数的类型可以用(arg0: type0) => returnType定义，并且可以在另一个函数的形参列表中使用此类型定义。

function runCallback(callback: (sum: number) => void, a: number, b: number): void {
    callback(a + b);
}

// Another way of writing the function would be:
// let logSum: (sum: number) => void = function(sum: number): void {
//     console.log(sum);
// };
function logSum(sum: number): void {
    console.log(`The sum is ${sum}.`);
}

runCallback(logSum, 2, 2);

2021-01-20 08:38:22

从v1.4开始的Typescript有type关键字，它声明了一个类型别名(类似于C/ c++中的typedef)。你可以这样声明你的回调类型:

type CallbackFunction = () => void;

它声明了一个不接受参数且不返回任何值的函数。接受零个或多个任意类型参数且不返回任何值的函数是:

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

然后你可以说，例如，

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

如果你想要一个函数接受任意数量的参数并返回任何值(包括void):

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

你可以指定一些强制性参数，然后是一组额外的参数(比如一个字符串，一个数字，然后是一组额外的参数)，这样:

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

这对于EventEmitter处理器之类的东西很有用。

在这种方式下，函数的类型可以随心所欲，尽管如果您试图用类型别名确定所有内容，可能会失去控制并遇到组合问题。

2016-05-12 18:48:08