Say we have a function that accepts a variable number of arguments, I believe it's called variadic function.

Something like this:

function foo(){
 let args = Array.from(arguments).map(v => whatever);
  // do something with args
}

A TypeScript interface for this function might look like:

interface IVariadicFn {
   (...args: string[]): void,
}

but let's say we expect a variable number of strings, but the final parameter, we expect to be a callback function.

So we'd have something like this:

function variadic(){
 let args = Array.from(arguments)
 let fn = args.pop();
 let $args = args.map(v => whatever);
  // do something with args
 process.nextTick(function(){
   fn(null, $args); // fire the callback, asynchronously
 });
}

is there a way to declare a TypeScript definition for this function?

The best I can do right now is this:

type IVariadicArgs = string | Function;

export interface IBeforeFn {
  (...args: IVariadicArgs[]): void;
}

Say we have a function that accepts a variable number of arguments, I believe it's called variadic function.

Something like this:

function foo(){
 let args = Array.from(arguments).map(v => whatever);
  // do something with args
}

A TypeScript interface for this function might look like:

interface IVariadicFn {
   (...args: string[]): void,
}

but let's say we expect a variable number of strings, but the final parameter, we expect to be a callback function.

So we'd have something like this:

function variadic(){
 let args = Array.from(arguments)
 let fn = args.pop();
 let $args = args.map(v => whatever);
  // do something with args
 process.nextTick(function(){
   fn(null, $args); // fire the callback, asynchronously
 });
}

is there a way to declare a TypeScript definition for this function?

The best I can do right now is this:

type IVariadicArgs = string | Function;

export interface IBeforeFn {
  (...args: IVariadicArgs[]): void;
}

• javascript
• node.js
• typescript
• typescript2.0
• typescript2.4

• 1 See github./Microsoft/TypeScript/issues/1336 – kemsky Commented Jun 21, 2017 at 8:49
• 1 Discussion currently seems to have moved to #5453. – Kiara Grouwstra Commented Jun 26, 2017 at 14:50
• this question about statically checking for falsy arguments / empty strings is really good – Alexander Mills Commented Jun 26, 2017 at 18:06

3 Answers 3

No, you can't do like you want, but you can pass the first parameter as a function, then the last ones. And also don't use arguments. You can replace this with rest parameters

interface IVariadicFn {
   (func: Function, ...args: string[]): void,
}

function foo(func: Function, ...args: string[]){
   let arguments = Array.from(args).map(v => whatever);
   // do something with arguments
}

And you can call like

foo(yourFunc, 'asd', 'bsd', 'csd');

While you can't do this in general, you can define multiple overloads which should cover most use cases:

function variadic(fn: () => void)
function variadic(a: string, fn: () => void)
function variadic(a: string, b: string, fn: () => void)
function variadic(a: string, b: string, c: string, fn: () => void)
function variadic(a: string, b: string, c: string, d: string, fn: () => void)
function variadic(...args: (string | (() => void))[]) {
    // ...
}

variadic(() => 3, "foo") // error
variadic("foo", () => 3) // ok 
variadic("foo", "bar", () => 3) // ok

playground

With TypeScript 4.2 and above, you can!

You can use leading/middle rest elements in tuple types for your variable arguments, like this:

type Callback = (strings: string[]) => void;

interface IVariadicFn {
   (...args: [...string[], Callback]): void,
}

const variadic: IVariadicFn = (...args: [...string[], Callback]) => {
  // Sadly typescript doesn't infer the type when we destructure the array,
  // so we have to help the piler a little within our function body.

  const fn = args[args.length - 1] as Callback;
  const strings = args.slice(0, args.length - 1) as string[];

  fn(strings);
}

You can use it like so:

const callback: Callback = (s) => console.log(s);

// Works!
variadic(callback);

// Works!
variadic("yo", callback);

// Works!
variadic("yo", "hello", "hi", callback);

/*
Type error!
Argument of type '[Callback, Callback]' is not assignable to parameter of type '[...string[], Callback]'.
  Type at position 0 in source is not patible with type at position 0 in target.
    Type 'Callback' is not assignable to type 'string'.(2345)
 */
variadic(callback, callback);

See this typescript playground example.