javascript Datilografe: Como definir o tipo para um retorno de chamada da função(como qualquer tipo de função, não universal qualquer) usado em um parâmetro do método




tooltip bootstrap css (5)

Seguindo a resposta de Ryan, acho que a interface que você está procurando é definida da seguinte maneira:

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

Atualmente tenho definição de tipo como:

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

Eu preciso de algo como:

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

mas o segundo não está sendo aceito.


Answer #1

Datilografado da v1.4 tem a palavra-chave type que declara um alias de tipo (análogo a um typedef em C / C ++). Você pode declarar seu tipo de retorno de chamada assim:

type CallbackFunction = () => void;

que declara uma função que não recebe argumentos e não retorna nada. Uma função que usa zero ou mais argumentos de qualquer tipo e retorna nada seria:

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

Então você pode dizer, por exemplo,

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

Se você quer uma função que leva um número arbitrário de argumentos e retorna qualquer coisa (incluindo void):

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

Você pode especificar alguns argumentos obrigatórios e, em seguida, um conjunto de argumentos adicionais (digamos, uma string, um número e, em seguida, um conjunto de argumentos extras):

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

Isso pode ser útil para coisas como manipuladores EventEmitter.

As funções podem ser digitadas da maneira mais forte que você desejar, embora você possa se deixar levar por problemas combinatórios se tentar encontrar tudo com um alias de tipos.


Answer #2

O tipo global Function serve a esse propósito.

Adicionalmente, se você pretende invocar este callback com 0 argumentos e irá ignorar seu valor de retorno, o tipo () => void combina todas as funções sem argumentos.


Answer #3

Aqui está um exemplo de uma função que aceita um retorno de chamada

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

Se você não se importa com os valores de retorno dos retornos de chamada (a maioria das pessoas não sabe como utilizá-los de qualquer maneira efetiva), você pode usar

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

Observe, a assinatura que usei para o parâmetro de callback ...

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

Eu diria que isso é uma deficiência do TypeScript, pois espera-se que forneçamos um nome para os parâmetros de retorno de chamada. Neste caso eu usei _ porque não é utilizável dentro da função sqk .

No entanto, se você fizer isso

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

É um TypeScript válido , mas será interpretado como ...

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

Ou seja, o TypeScript achará que o nome do parâmetro é number e o tipo implícito é any . Obviamente, isso não é o que pretendíamos, mas, infelizmente, é assim que funciona o TypeScript.

Portanto, não se esqueça de fornecer os nomes dos parâmetros ao digitar seus parâmetros de função ... por mais estúpido que isso possa parecer.


Answer #4

Você pode definir um tipo de função na interface de várias maneiras,

  1. maneira geral:
export interface IParam {
  title: string;
  callback(arg1: number, arg2: number): number;
}
  1. Se você gostaria de usar a sintaxe da propriedade,
export interface IParam {
  title: string;
  callback: (arg1: number, arg2: number) => number;
}
  1. Se você declarar primeiro o tipo de função,
type MyFnType = (arg1: number, arg2: number) => number;

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

Usando é muito simples,

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

    return result;
}
  1. Você também pode declarar um literal de tipo de função, o que significa que uma função pode aceitar outra função como parâmetro. função de parametrização pode ser chamada como callback também.
export interface IParam{
  title: string;
  callback(lateCallFn?:
             (arg1:number,arg2:number)=>number):number;

}




typescript