使用泛型的Typescript箭头函数的语法是什么？

Question

打字稿手册目前在箭头功能上没有任何内容.可以使用以下语法对普通函数进行泛型输入:示例:

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

箭头函数的语法是什么？

Answer 1

完整的例子解释了Robin引用的语法...让我回家:

通用功能

像下面这样的工作正常:

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

但是,使用箭头通用函数不会:

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

解决方法:对泛型参数使用扩展来提示编译器它是通用的,例如:

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

Answer 2

我发现上面的例子令人困惑.我正在使用React和JSX,所以我认为它使场景变得复杂.

我得到了澄清.https://basarat.gitbooks.io/typescript/content/docs/types/generics.html

箭头泛型的哪些状态:解决方法:使用扩展泛型参数来提示编译器它是通用的,这来自一个帮助我的简单示例.

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

Answer 3

语言规范在p.64f上说

形式<T>(...)=> {...}的构造可以被解析为箭头函数表达式,其中类型参数或类型断言应用于没有类型参数的箭头函数.它被解决为前[...]

例:

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

Answer 4

这么晚了，但是使用 ES6 不需要扩展它仍然对我有用....:)

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)

Answer 5

这对我有用

 const logSomething = <T>(something:T): T => {
       return something;
    }

Answer 6

如果您在.tsx文件中，则不能只写<T>，但这可以工作：

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

与extends {}hack 相对，此hack至少保留了意图。

Answer 7

非箭头函数方式。扩展 OP 中的示例。

function foo<T>(abc: T): T {
    console.log(abc);
    return abc;
}

const x = { abc: 123 };
foo(x);

const y = 123;
foo<number>(y);

除了将整个事情嵌入到一个声明中的答案之外：

const yar = <T,>(abc: T) => {
    console.log(abc);
    return abc;
}

另一种方法是使用中间类型：

type XX = <T>(abc: T) => T;

const bar: XX = (abc) => {
    console.log(abc);
    return abc;
}

操场

Answer 8

虽然流行的答案 withextends {}有效并且比 好extends any，但它迫使 theT成为一个对象

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

为避免这种情况并保持类型安全，您可以extends unknown改用

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

Answer 9

这对我有用

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

Answer 10

我使用这种类型的声明：

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

如果您需要，它允许为您的函数定义额外的道具，并且在某些情况下，它有助于使函数体与通用定义保持清洁。

如果你不需要额外的道具（命名空间之类的东西），它可以简化为：

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