Typescript:如何为方法参数中使用的函数回调(如任何函数类型,而不是通用任何函数)定义类型

时间:2015-04-17 03:53:20

标签: javascript typescript

目前我的类型定义为:

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

我需要类似的东西:

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

但第二个不被接受。

9 个答案:

答案 0 :(得分:196)

全局类型Function可用于此目的。

此外,如果您打算使用0个参数调用此回调并忽略其返回值,则类型() => void将匹配所有不带参数的函数。

答案 1 :(得分:136)

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处理程序这样的东西很有用。

可以通过这种方式尽可能强烈地输入函数,但是如果你试图用类型别名来解决所有问题,你可能会被带走并遇到组合问题。

答案 2 :(得分:50)

根据Ryan的回答,我认为您正在寻找的界面定义如下:

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

答案 3 :(得分:26)

以下是接受回调的函数示例

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

我认为这是TypeScript缺陷,因为我们需要为回调参数提供名称。在这种情况下,我使用了_,因为它在sqk函数中无法使用。

但是,如果你这样做

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

它是有效的 TypeScript,但它会被解释为......

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

即,TypeScript会认为参数 name number,隐含类型为any。这显然不是我们想要的,但唉,这就是TypeScript的工作原理。

所以不要忘记在输入函数参数时提供参数名称......看似愚蠢。

答案 4 :(得分:13)

您可以通过多种方式在界面中定义函数类型,

  1. 一般方式:
export interface IParam {
  title: string;
  callback(arg1: number, arg2: number): number;
}
  1. 如果您想使用属性语法,则
export interface IParam {
  title: string;
  callback: (arg1: number, arg2: number) => number;
}
  1. 如果先声明函数类型,
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;
}
  1. 您还可以声明一个函数类型文字,这意味着一个函数可以接受另一个函数作为其参数。参数化函数也可以称为回调。
export interface IParam{
  title: string;
  callback(lateCallFn?:
             (arg1:number,arg2:number)=>number):number;

}

答案 5 :(得分:10)

有四种抽象函数类型,当您知道函数将接受或不接受参数,是否返回数据时,可以分别使用它们。

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

答案 6 :(得分:4)

Typescript:如何为方法参数中使用的函数回调定义类型?

您可以将回调声明为1) function属性或2)方法

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

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

TS 2.6起,有一个重要的类型区别:

在声明了 function属性的情况下,您将在--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之类的内置类型结合使用时,方法仍然checked more permissively(即使听起来不太合理)也更加实用。

摘要

  • 函数属性和方法声明之间存在类型差异
  • 如果可能的话,为更强的类型选择一个函数属性

Playground sample code

答案 7 :(得分:2)

我刚刚开始使用 Typescript,并且一直在尝试解决类似的问题;如何告诉打字稿我正在传递一个没有 interface 的回调。

在浏览了 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);

答案 8 :(得分:1)

希望这会有所帮助...

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;

}