Typescriptの関数の汎用戻り型

Question

私はtsを初めて使いましたが、私はjavaのジェネリックスの概念について少し学びました。 searchTrack、searchAlbum、searchArtist

searchTrack(query: string): Observable<Track[]> { 
    return this.search(query, 'track'); 
    } 

    searchArtist(query: string): Observable<Artist[]> { 
    return this.search(query, 'artist'); 
    } 

    searchAlbum(query: string): Observable<Album[]> { 
    return this.search(query, 'album'); 
    } 

私は、クエリとエンティティの種類を取り、特定のコレクションの観測を返します。このクラスの一般的な機能「検索」をしたい：クエリは、私は3つの機能を持っているということですエンティティタイプ。私はここで立ち往生している。どのようにしてジェネリックで作業して、関数の汎用戻り型を指定できますか。

search(query: string, type: string): Observable<Array<T>> { 
return this.query(`/search`, [ 
    `q=${query}`, 
    `type=${type}` 
]); 
} 

私はこれを達成する方法はありますか？

Answer 1

[012]の代わりにのクラスを使用してみてください。 検索機能で一般的なTタイプも定義します。

search<T>(query: string, type: string): Observable<Array<T>> { 
return this.query(`/search`, [ 
    `q=${query}`, 
    `type=${type}` 
]); 
} 

あなたはこのようにそれを呼び出すことができる必要があります：

let result = search<Artist>('someQuery', 'artist'); 

あなたがハンドブックhereにおけるジェネリック医薬品の章でtypescriptですでジェネリック医薬品についての詳細を見つけることができます。あなたができる、

myObj.search<Track>(query, "track"); 

をしかし：

Answer 2

@toskvは答えとして、あなたは、メソッドのシグネチャにジェネリックタイプを追加することができますが、あなたはそれを追加する必要がありますので、コンパイラは、型を推定する方法はありませんような何か：

interface MyObservableClass {} 

interface MyObservableClassCtor<T extends MyObservableClass> { 
    new(): T; 
    getType(): string; 
} 

class Artist implements MyObservableClass { 
    static getType(): string { 
     return "artist"; 
    } 
} 

class Album implements MyObservableClass { 
    static getType(): string { 
     return "album"; 
    } 
} 

class Track implements MyObservableClass { 
    static getType(): string { 
     return "track"; 
    } 
} 

class Searcher { 
    search<T extends MyObservableClass>(ctor: MyObservableClassCtor<T>, query: string): Observable<T[]> { 
     return this.query(`/search`, [ 
      `q=${query}`, 
      `type=${ ctor.getType() }` 
     ]); 
    } 
} 

let searcher: Searcher = ...; 

searcher.search(Track, "..."); 

をそして、コンパイラはTがクラス（/ ctorの）でそれを提供することであるものを推測することができます。

Answer 3

あなたは過負荷でそれを行うことができます：あなたは正しいタイプ与える

class A { 
    search<T>(query: string, type: "Track"): Observable<Track[]>; 
    search<T>(query: string, type: "Artist"): Observable<Artist[]>; 
    search<T>(query: string, type: "Album"): Observable<Album[]>; 
    search<T>(query: string, type: string): Observable<T[]>; 
    search<T>(query: string, type: string): Observable<T[]> { 
     return null; 
    } 
} 

：

var observable = x.search("test", "Track"); 

をと鴨の型キャストに文句は失敗します（ただし、トラックやアーティストが持っていると言うならば文句はありません同じ特性と機能）。

var observableError: Observable<Album[]> = x.search("test", "Track");