如何将 TypeScript 定义文件用于另一个 function

Question

I'm new to TS and would like to use a definition file I created to tell a separate function about it's arguments type.

functions.ts

export default ({}) => {
  const myFunction = ({ param1 }: { param1: string }) => {
    return param1;
  };

  return {
    myFunction
  };
};

functions.d.ts

declare var _default: ({}: {}) => {
    myFunction: ({ param1 }: {
        param1: string;
    }) => string;
};
export default _default;

someotherfile.ts

export default ({ functions }) => {
  functions().myFunction({ param1: 1 });
};

The functions parameter is from functions.ts above, but of course someotherfile.ts does not know what the structure of functions is.

How can I use functions.d.ts here? Do I even need to use it?

Answer 1

I think this will solve your problem, just create a new type if you need only it.

// functionsType.ts
export type functions = ({}: {}) => {
  myFunction: ({ param1 }: {
      param1: string;
  }) => string;
};

and use it like so

//someotherfile.ts
import { functions } from './functionsType';

export default (functions: functions) => {
  functions({}).myFunction({ param1: 1 });
};

here is stackBlitz example where you can see an error about wrong argument type

Answer 2

It does not work like that.

You use definitions to provide types to untyped javascript code you may import. For instance, let's say you did import library X into yout project and it did not have a @types/X package. Then you could write a .d.ts file to integrate it into your project. But that is completely optional, you can also consume JS code as-is, without types.

If you want the return of a function to depend on its arguments, what you are probably looking for is generics , which may be a somewhat complicated topic. For instance:

const myFunction = <Input extends { param1: any }>(inp: Input) => {
    return inp.param1
};

On the previous excerpt we tell that myFunction accepts any object that at least has a property named param1 . And its return value will be inferred to whatever type param1 has. Which is different from writing:

const myFunction = (inp: { param1: any, [k: string]: any }) => {
    return inp.param1
};

This last example puts similar constraints on the function inputs, but the return type will be always erased to any .

The difference is that, while in the 2nd sample we are "casting" the input type, on the 1st sample, we are generically using whichever type comes in while imposing a constraint.