Generic ile daktilo okları işlevlerinin sözdizimi nedir?

Daktilo el kitabının şu anda ok işlevleri hakkında hiçbir şey yok. Normal işlevler genel olarak bu sözdizimi ile yazılabilir: örnek:

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

Ok işlevleri için sözdizimi nedir?

Robin'in referans aldığı sözdizimini açıklayan tam örnek ... benim için eve getirdi:

Genel fonksiyonlar

Aşağıdaki gibi bir şey iyi çalışıyor:

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

Ancak bir ok genel işlevi kullanıldığında:

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

Geçici çözüm: Derleyiciye genel olduğunu göstermek için generic parametresindeki uzantıları kullanın, örneğin:

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

Yukarıdaki örneği kafa karıştırıcı buldum. React ve JSX kullanıyorum, bu yüzden senaryoyu karmaşık hale getiriyor.

Ok jeneriklerini belirten TypeScript Deep Dive'dan açıklama aldım :

Geçici çözüm: Derleyiciye genel olduğunu göstermek için generic parametresinde uzantıları kullanın, bu bana yardımcı olan daha basit bir örnekten geldi.

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

Bir .tsxdosyadaysanız yazamazsınız <T>, ancak bu işe yarar:

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

Saldırının aksine extends {}, bu saldırı en azından niyetini korur.

Dil belirtimi p.64f'de yazıyor

<T> (...) => {...} formunun bir yapısı, bir tür parametresiyle bir ok işlevi ifadesi veya tür parametresiz bir ok işlevine uygulanan bir tür iddiası olarak ayrıştırılabilir. Eski gibi çözülür [..]

misal:

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

Bu benim için çalışıyor

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

popüler cevap extends {}işe yarıyor ve daha iyi extends anyolsa Tda, nesneyi

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

Bundan kaçınmak ve tip güvenliğini korumak için extends unknownbunun yerine

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

çok geç, ama ES6 ile gerek yok benim için hala çalışır .... :)

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)

Bu tür bir beyanı kullanmak için:

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

İhtiyacınız olursa, işlevinize ek desteklerin tanımlanmasına izin verir ve bazı durumlarda işlev gövdesini genel tanımdan daha temiz tutmaya yardımcı olur.

Ek desteklere (ad alanı bir şey) ihtiyacınız yoksa, basitleştirilebilir:

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