Bir işlevin dönüş türünü elde etmek

Aşağıdaki işleve sahibim:

function test(): number {
    return 42;
}

İşlevin türünü şu şekilde elde edebilirim typeof:

type t = typeof test;

Burada tolacak () => number.

İşlevin dönüş türünü elde etmenin bir yolu var mı? Ben istiyorum tolmak numberyerine () => number.

DÜZENLE

TypeScript 2.8'den itibaren bu resmi olarak mümkündür 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[]

Ayrıntılar için buraya bakın.

TypeScript harika!

Eski usul hack

Ryan'ın cevabı maalesef artık işe yaramıyor. Ama mantıksız bir şekilde mutlu olduğum bir hack ile değiştirdim. Seyretmek:

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

Bu, yanlış değerini true değerine çevirerek çalışır, böylece tür sistemi, dönüş değerinin işlevin türü olduğunu düşünür, ancak kodu gerçekten çalıştırdığınızda, yanlışta kısa devre yapar.

TypeScript en iyisidir. : D

TypeScript 2.8'deki en kolay yol:

const foo = (): FooReturnType => {
}

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

Aşağıdaki kod, işlevi çalıştırmadan çalışır. React-redux-typescript kitaplığından ( 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;

Bunu yapmanın bir yolu yoktur (bunu ekleyen iş öğesi izleme için bkz. Https://github.com/Microsoft/TypeScript/issues/6606 ).

Yaygın bir çözüm şuna benzer bir şey yazmaktır:

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

Düzenleme: TS 2.8 ile artık buna gerek yok! ReturnType<F>dönüş türünü verir. Kabul edilen cevaba bakın.

Kullandığım önceki cevaplardan bazılarının bir varyantı strictNullChecks, çıkarım jimnastiğinde işe yarayan ve biraz gizleyen bir varyant :

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

Kullanım:

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

Bu mu diyoruz getReturnTypefonksiyonu, ancak vermez orijinal işlevini çağırın. Sen olabilir önlemek getReturnTypekullanarak çağrı (false as true) && getReturnType(foo)ama IMO bu sadece daha kafa karıştırıcı hale getirir.

Bu yöntemi, orijinal olarak JS'de ~ 1500 fabrika işlevi bu şekilde yazılmış ve Fooetc türlerini tüm kullanımlara ekleyen eski bir Angular 1.x projesini taşımak için bazı regexp bul / değiştir ile kullandım. bulacak. :)

Söz konusu işlev, kullanıcı tanımlı bir sınıfın bir yöntemiyse , çalışma zamanında dönüş türünü (yapıcı işlevi) belirlemek için (ve bununla uygun gördüğünüz gibi yapın) yöntem dekoratörlerini Reflect Metadata ile birlikte kullanabilirsiniz .

Örneğin, konsola kaydedebilirsiniz:

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

    console.log(returnType);
}

Sadece bu yöntem dekoratörünü seçtiğiniz bir yönteme yapıştırın ve sözde yöntem çağrısından döndürülen nesnenin yapıcı işlevine tam referansa sahip olursunuz.

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

Bununla birlikte, bu yaklaşımın birkaç önemli sınırlaması vardır:

• Bu şekilde dekore edilmiş bir yöntemde dönüş türünü açıkça tanımlamanız gerekir, aksi takdirde tanımsız olursunuz Reflect.getMetadata,
• yalnızca derlemeden sonra var olan gerçek türlere başvurabilirsiniz; yani, arayüz veya jenerik yok

Ayrıca, daktilo derleyicisi için aşağıdaki komut satırı bağımsız değişkenlerini belirtmeniz gerekir, çünkü hem dekoratörler hem de meta verileri yansıtmak, bu yazıyı yazarken deneysel özelliklerdir:

--emitDecoratorMetadata --experimentalDecorators

Ne yazık ki çalıştırmadan işlevin dönüş türünü almanın bir yolu yoktur. Bunun nedeni, TypeScript'in JS'ye derlendiğinde, türle ilgili tüm bilgileri kaybetmenizdir.

Aşağıdakileri buldum, bu güzel çalışıyor gibi görünüyor:

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