这里我有2个带泛型的箭头函数:

直接呼叫:

const foo = <T>(value: T): void => {
    console.log(value);
foo('hello') // hello
}

创建一个稍后使用的类型:

type TFoo<S> = (value: S) => boolean;
const foo: TFoo<number> = (value) => value>0;
console.log(foo(1)) // true
console.log(foo(-1)) // false

希望这对你有所帮助!

这对我很有用

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

非箭头函数的方法。扩展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;
}

操场上

语言规范在p.64f上写着

形式为< T >(…)=>{…}可以解析为an 带有类型参数或类型断言的箭头函数表达式 应用于没有类型参数的箭头函数。它被解析为 前[. .]

例子:

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

使用<T, extends{}>在试图传递null作为参数时抛出错误。我更喜欢使用<T，>，因为它解决了这个问题。我还不知道原因。但这对我很管用。

我知道我回答这个问题有点晚了。但我想到了回答这个问题，以防其他人发现它有帮助。没有一个答案提到如何在异步箭头函数中使用泛型。

是这样的:

const example = async <T> (value: T) => {
    //awaiting for some Promise to resolve or reject;
     const result = await randomApi.getData(value);

}