Cú pháp cho các hàm mũi tên typecript với generic là gì?

Sổ tay bản thảo hiện không có gì trên các hàm mũi tên. Các hàm thông thường có thể được gõ chung với cú pháp này: ví dụ:

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

Cú pháp cho các chức năng mũi tên là gì?

Ví dụ đầy đủ giải thích cú pháp được tham chiếu bởi Robin ... đã mang nó về nhà cho tôi:

Hàm chung

Một cái gì đó như sau hoạt động tốt:

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

Tuy nhiên, sử dụng một hàm mũi tên chung sẽ không:

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

Giải pháp thay thế: Sử dụng mở rộng trên tham số chung để gợi ý trình biên dịch rằng đó là chung, ví dụ:

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

Tôi tìm thấy ví dụ trên khó hiểu. Tôi đang sử dụng React và JSX vì vậy tôi nghĩ nó phức tạp hóa kịch bản.

Tôi đã làm rõ từ TypeScript Deep Dive , trong đó nêu rõ về tướng mũi tên:

Giải pháp thay thế: Sử dụng mở rộng trên tham số chung để gợi ý trình biên dịch rằng đó là chung, điều này xuất phát từ một ví dụ đơn giản giúp tôi.

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

Nếu bạn đang ở trong một .tsxtệp bạn không thể chỉ viết <T>, nhưng điều này hoạt động:

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

Trái ngược với vụ extends {}hack, vụ hack này ít nhất bảo tồn ý định.

Đặc tả ngôn ngữ nói trên p.64f

Cấu trúc có dạng <T> (...) => {...} có thể được phân tích cú pháp dưới dạng biểu thức hàm mũi tên với tham số loại hoặc xác nhận loại được áp dụng cho hàm mũi tên không có tham số loại. Nó được giải quyết như trước đây [..]

thí dụ:

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

Điều này làm việc cho tôi

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

trong khi câu trả lời phổ biến với extends {}các tác phẩm và tốt hơn là extends any, nó buộc Tphải là một đối tượng

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

để tránh điều này và bảo vệ an toàn loại, extends unknownthay vào đó bạn có thể sử dụng

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

Tôi sử dụng loại khai báo này:

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

Nó cho phép xác định các đạo cụ bổ sung cho chức năng của bạn nếu bạn cần và trong một số trường hợp, nó giúp giữ cho thân chức năng sạch hơn khỏi định nghĩa chung.

Nếu bạn không cần các đạo cụ bổ sung (sắp xếp không gian tên của sự vật), nó có thể được đơn giản hóa thành:

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

quá muộn, nhưng với ES6 không cần gia hạn thì nó vẫn hoạt động với tôi .... :)

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)