Jaka jest składnia funkcji strzałek maszynopisu z rodzajami?

Podręcznik maszynopisu obecnie nie ma nic na temat funkcji strzałek. Zwykłe funkcje można ogólnie wpisywać za pomocą tej składni: przykład:

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

Jaka jest składnia funkcji strzałek?

Pełny przykład wyjaśniający składnię, do której odwołuje się Robin ... przyniósł mi ją do domu:

Funkcje ogólne

Coś takiego działa dobrze:

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

Jednak użycie ogólnej funkcji strzałki nie spowoduje:

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

Obejście: użycie rozszerza parametr ogólny, aby zasugerować kompilatorowi, że jest to rodzaj ogólny, np .:

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

Powyższy przykład jest mylący. Używam React i JSX, więc myślę, że to skomplikowało scenariusz.

Otrzymałem wyjaśnienie od TypeScript Deep Dive , które stanowi dla generycznych strzałek:

Obejście: Zastosowanie rozszerza parametr ogólny, aby zasugerować kompilatorowi, że jest to rodzaj ogólny, pochodzi on z prostszego przykładu, który mi pomógł.

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

Jeśli jesteś w .tsxpliku, nie możesz po prostu pisać <T>, ale to działa:

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

W przeciwieństwie do extends {}hacka, ten hack przynajmniej zachowuje zamiar.

Specyfikacja języka mówi na str. 64f

Konstrukt w postaci <T> (...) => {...} może zostać przeanalizowany jako wyrażenie funkcji strzałki z parametrem typu lub asercja typu zastosowana do funkcji strzałki bez parametru typu. Jest rozwiązany jako poprzedni [..]

przykład:

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

To działa dla mnie

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

popularna odpowiedź z extends {}działaniem i jest lepsza niż extends any, ale zmusza ją Tdo bycia przedmiotem

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

Aby tego uniknąć i zachować bezpieczeństwo typu, możesz użyć extends unknownzamiast tego

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

I użyć tego typu deklaracji:

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

Pozwala zdefiniować dodatkowe rekwizyty dla twojej funkcji, jeśli zajdzie taka potrzeba, a w niektórych przypadkach pomaga utrzymać ciało funkcji w czystości od definicji ogólnej.

Jeśli nie potrzebujesz dodatkowych rekwizytów (coś w rodzaju przestrzeni nazw), możesz to uprościć:

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

tak późno, ale z ES6 nie ma potrzeby przedłużania, nadal działa dla mnie .... :)

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)