Ottenere il tipo di ritorno di una funzione

Ho la seguente funzione:

function test(): number {
    return 42;
}

Posso ottenere il tipo di funzione utilizzando typeof:

type t = typeof test;

Qui tsarà () => number.

C'è un modo per ottenere il tipo di ritorno della funzione? Vorrei tessere numberinvece di () => number.

MODIFICARE

A partire da TypeScript 2.8 questo è ufficialmente possibile con ReturnType<T>.

type T10 = ReturnType<() => string>;  // string
type T11 = ReturnType<(s: string) => void>;  // void
type T12 = ReturnType<(<T>() => T)>;  // {}
type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>;  // number[]

Vedi qui per i dettagli.

TypeScript è fantastico!

Trucco della vecchia scuola

La risposta di Ryan non funziona più, sfortunatamente. Ma l'ho modificato con un hack di cui sono irragionevolmente contento. Ecco:

const fnReturnType = (false as true) && fn();

Funziona eseguendo il cast di false al valore letterale di true, in modo che il sistema di tipi pensi che il valore restituito sia il tipo della funzione, ma quando si esegue effettivamente il codice, cortocircuiti su false.

TypeScript è il migliore. : D

Il modo più semplice in TypeScript 2.8:

const foo = (): FooReturnType => {
}

type returnType = ReturnType<typeof foo>;
// returnType = FooReturnType

Il codice seguente funziona senza eseguire la funzione. Proviene dalla libreria react-redux-typescript ( https://github.com/alexzywiak/react-redux-typescript/blob/master/utils/redux/typeUtils.ts )

interface Func<T> {
    ([...args]: any, args2?: any): T;
}
export function returnType<T>(func: Func<T>) {
    return {} as T;
}


function mapDispatchToProps(dispatch: RootDispatch, props:OwnProps) {
  return {
    onFinished() {
      dispatch(action(props.id));
    }
  }
}

const dispatchGeneric = returnType(mapDispatchToProps);
type DispatchProps = typeof dispatchGeneric;

Non c'è un modo per farlo (vedere https://github.com/Microsoft/TypeScript/issues/6606 per il monitoraggio dell'elemento di lavoro che aggiunge questo).

Una soluzione comune è scrivere qualcosa come:

var dummy = false && test();
type t2 = typeof dummy;

Modifica: non è più necessario con TS 2.8! ReturnType<F>fornisce il tipo restituito. Vedi risposta accettata.

Una variante su alcune delle risposte precedenti che sto usando, che funziona strictNullCheckse nasconde un po 'la ginnastica inferenziale:

function getReturnType<R>(fn: (...args: any[]) => R): R {
  return {} as R;
}

Utilizzo:

function foo() {
  return {
    name: "",
    bar(s: string) { // doesn't have to be shorthand, could be `bar: barFn` 
      return 123;
    }
  }
}

const _fooReturnType = getReturnType(foo);
export type Foo = typeof _fooReturnType; // type Foo = { name: string; bar(s: string): number; }

Si fa chiamare la getReturnTypefunzione, ma non chiamare la funzione originale. Si potrebbe evitare che la getReturnTypechiamata utilizzando (false as true) && getReturnType(foo), ma IMO questo solo rende più confusa.

Ho appena usato questo metodo con alcuni regexp trova / sostituisci per migrare un vecchio progetto Angular 1.x che aveva ~ 1500 funzioni di fabbrica scritte in questo modo, originariamente in JS, e ho aggiunto i Footipi ecc. A tutti gli usi ... incredibile quello con codice rotto troverà. :)

Se la funzione in questione è un metodo di una classe definita dall'utente, è possibile utilizzare decoratori di metodi in combinazione con Reflect Metadata per determinare il tipo di ritorno (funzione di costruzione) in fase di esecuzione (e con esso, fare come meglio credi).

Ad esempio, potresti registrarlo sulla console:

function logReturnType(
    target: Object | Function,
    key: string,
    descriptor: PropertyDescriptor
): PropertyDescriptor | void {
    var returnType = Reflect.getMetadata("design:returntype", target, key);

    console.log(returnType);
}

Basta agganciare questo decoratore di metodo su un metodo di tua scelta e avrai il riferimento esatto alla funzione di costruzione dell'oggetto che viene presumibilmente restituito dalla chiamata al metodo.

class TestClass {
    @logReturnType // logs Number (a string representation)
    public test(): number {
        return 42;
    }
}

Tuttavia, ci sono alcune limitazioni notevoli a questo approccio:

• devi definire esplicitamente il tipo di ritorno su un metodo decorato come tale, altrimenti verrai indefinito da Reflect.getMetadata,
• puoi fare riferimento solo a tipi effettivi che esistono anche dopo la compilazione; cioè niente interfacce o generici

Inoltre, dovrai specificare i seguenti argomenti della riga di comando per il compilatore dattiloscritto, perché sia ​​i decoratori che i metadati di riflessione sono funzionalità sperimentali al momento della stesura di questo post:

--emitDecoratorMetadata --experimentalDecorators

Non c'è modo di recuperare il tipo di ritorno della funzione senza eseguirlo tristemente. Questo perché quando TypeScript viene compilato in JS, si perdono tutte le informazioni relative al tipo.

Mi è venuto in mente quanto segue, che sembra funzionare bene:

function returnType<A, B, Z>(fn: (a: A, b: B) => Z): Z
function returnType<A, Z>(fn: (a: A) => Z): Z
function returnType<Z>(fn: () => Z): Z
function returnType(): any {
    throw "Nooooo"
}

function complicated(value: number): { kind: 'complicated', value: number } {
    return { kind: 'complicated', value: value }
}

const dummy = (false as true) && returnType(complicated)
type Z = typeof dummy