Wie lautet die Syntax für Typescript-Pfeilfunktionen mit Generika?

Das Typoskript-Handbuch enthält derzeit keine Pfeilfunktionen. Normale Funktionen können generisch mit folgender Syntax eingegeben werden: Beispiel:

function identity<T>(arg: T): T {
    return arg;
}

Wie lautet die Syntax für Pfeilfunktionen?

Das vollständige Beispiel, das die Syntax erklärt, auf die Robin verweist, brachte es für mich nach Hause:

Generische Funktionen

So etwas funktioniert gut:

function foo<T>(x: T): T { return x; }

Die Verwendung einer generischen Pfeilfunktion führt jedoch nicht zu:

const foo = <T>(x: T) => x; // ERROR : unclosed `T` tag

Problemumgehung: Verwenden Sie die Erweiterung des generischen Parameters, um den Compiler darauf hinzuweisen, dass es sich um einen generischen Parameter handelt, z.

const foo = <T extends unknown>(x: T) => x;

Ich fand das obige Beispiel verwirrend. Ich verwende React und JSX, daher denke ich, dass dies das Szenario kompliziert hat.

Ich habe von TypeScript Deep Dive eine Klarstellung erhalten , in der für Pfeilgenerika Folgendes angegeben ist:

Problemumgehung: Verwenden Sie die Erweiterung des generischen Parameters, um den Compiler darauf hinzuweisen, dass es sich um einen generischen Parameter handelt. Dies stammt aus einem einfacheren Beispiel, das mir geholfen hat.

    const identity = < T extends {} >(arg: T): T => { return arg; }

Wenn Sie sich in einer .tsxDatei befinden, können Sie nicht einfach schreiben <T>, aber das funktioniert:

const foo = <T, >(x: T) => x;

Im Gegensatz zum extends {}Hack bewahrt dieser Hack zumindest die Absicht.

Die Sprachspezifikation sagt auf S.64f

Ein Konstrukt der Form <T> (...) => {...} kann als Pfeilfunktionsausdruck mit einem Typparameter oder als Typzusicherung analysiert werden, die auf eine Pfeilfunktion ohne Typparameter angewendet wird. Es wird als erstere gelöst [..]

Beispiel:

// helper function needed because Backbone-couchdb's sync does not return a jqxhr
let fetched = <
           R extends Backbone.Collection<any> >(c:R) => {
               return new Promise(function (fulfill, reject) {
                   c.fetch({reset: true, success: fulfill, error: reject})
               });
           };

Das funktioniert bei mir

const Generic = <T> (value: T) => {
    return value;
} 

Während die populäre Antwort mit extends {}funktioniert und besser ist als extends any, zwingt sie das T, ein Objekt zu sein

const foo = <T extends {}>(x: T) => x;

Um dies zu vermeiden und die Typensicherheit zu erhalten, können Sie extends unknownstattdessen verwenden

const foo = <T extends unknown>(x: T) => x;

Ich benutze diese Art von Erklärung:

const identity: { <T>(arg: T): T } = (arg) => arg;

Es ermöglicht das Definieren zusätzlicher Requisiten für Ihre Funktion, falls dies jemals erforderlich sein sollte, und in einigen Fällen hilft es dabei, den Funktionskörper sauberer von der generischen Definition zu halten.

Wenn Sie keine zusätzlichen Requisiten benötigen (Namespace), können Sie dies vereinfachen:

const identity: <T>(arg: T) => T = (arg) => arg;

so spät, aber mit ES6 keine Notwendigkeit verlängert es funktioniert immer noch für mich .... :)

let getArray = <T>(items: T[]): T[] => {
    return new Array<T>().concat(items)
}

let myNumArr = getArray<number>([100, 200, 300]);
let myStrArr = getArray<string>(["Hello", "World"]);
myNumArr.push(1)
console.log(myNumArr)