어드민

다음은 콜백을 허용하는 함수의 예입니다.

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

그것은의 유효 타이프 라이터, 그러나 그것은으로 해석됩니다 …

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

즉, TypeScript는 매개 변수 이름 이 number묵시적 유형 이라고 생각합니다 any. 이것은 분명히 우리가 의도 한 것이 아니라 슬프게도 TypeScript가 작동하는 방식입니다.

따라서 함수 매개 변수를 입력 할 때 매개 변수 이름을 제공하는 것을 잊지 마십시오. 어리석은 것처럼 보일 수 있습니다.

답변

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;

}

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

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

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

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 ...