泛型类型(T)与打字稿中的任何区别有什么区别

By simon at 2018-02-28 • 0人收藏 • 40人看过

打字稿中generic Type(T)与any有什么区别?

功能1

function identity(arg: any): any {
    return arg;
}

功能2

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

功能3

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


功能1和3是接受,如果我们通过任何一种data type,但是 功能2不接受,如果我们通过array. 通用类型是 在编译时接受所有类型的数据类型。但在这里它为什么这样做不是 公认? *还有哪个功能有利于更好的性能(功能1或功能 3)?_ *

5 个回复 | 最后更新于 2018-02-28
2018-02-28   #1

如果这是返回一个的身份函数,则没有区别 参数和使用没有类型限制:

const foo: any = fn(['whatever']);
键入的代码有所不同:
const foo: string = fn('ok');
const bar: string = fn([{ not: 'ok' }]);
而且,泛型类型的使用提供了语义。这签名建议EST序列 该函数是无类型的并返回任何内容:
function fn(arg: any): any { ... }
此签名表明该函数返回相同键入为 论据:
function fn<T>(arg: T): T { ... }
实际功能通常比return arg例子更有意义。 泛型类型可以b从类型限制中获益(显然,any) 不能):
function fn<T>(arg: T[]): T[] {
  return arg.map((v, i) => arg[i - 1]);
}
但是,当这些好处变得更加明显时功能一起使用 与其他泛型类和泛型函数一起使用(并且, 泛型参与):
function fn<T>(arg: T[]): T[] {
  return Array.from(new Set<T>(arg));
}
这允许在输入之间始终保持T类型 (参数)和输出(返回值):
const foo: string[] = fn(['ok']);
const bar: string[] = fn([{ not: 'ok' }]);
由于存在TypeScript类型,因此性能不会有任何差异 仅限于设计时间。

2018-02-28   #2

运行时的一切都是any,最重要的是any at 编译时间在JavaScript.这就是为什么TypeScript提供 编译时的类型安全性。 any和T/T extends等之间的差异。是 例如,在编译期间你有类型安全

protected typeSafety = <T extends String>(args:T):T =>{
    return args;
}

this.typeSafety(1); // compile error
this.typeSafety("string"); // good to go
如果函数接受任何你会有的东西在运行时哪个错误 太迟了。

2018-02-28   #3

T的主要用途是避免在打电话时打破类型 方法。 例: 如果你这样做:

let foo = new Foo();
identity(foo).bar();
第二对于编译器来说,行可以,但不是因为他知道这一点 bar存在于Foo类型中,因为它是any,和 any可以有任何方法。 如果你这样做:
let foo = new Foo();
identity<Foo>(foo).bar();
identity<Foo>(foo).notExistingMethod();
第二行会编好,而不是第三行因为Foo 没有notExistingMethod方法。 当你需要在更多的Javascript中创建一些东西时,经常使用任何东西PT-方式, 这意味着你不会真正知道你的对象是什么,因为Javascript 没有任何类型(我不是说阿布)。

2018-02-28   #4

使用这些功能绝对没有性能差异 方法,因为所有这些奇特的东西都只是Typescript糖和是 只用于发展。 所有类型检查仅在编译时(当Typescript是 transpiling /反在您的服务器中将您的代码恢复为正常的JavaScript )。 无论哪种方式,当你的代码被发送到用户的浏览器,这是怎么回事 看起来:

function identity(arg){
    return arg;
}
但要解释这些差异: 当使用any时,你将失去所有类型的检查和安全检查 该Typescript提供,而T行为像一个变量 这将持有你不知道的类型这将是什么。 所以
function identity<T>(arg: T): T {
    return arg;
}
在上面,我们知道如果identify接受number,它将返回 number等,其中as:


function identity(arg: any): any {
    return arg;
}
但是现在,你不知道arg和returned的值是否是 SA我输入或不输入。


T将解决的另一个问题是当您创建方法时 在课堂上,它是exp引发你想确保的论点 此方法将只接受具有相同类型的类的参数 CON实例化时的structor参数。

export class MyClass<T>{

   myMethod(anotherArg:T){}

}
所以使用上面:
let str = "string";
let instance = new MyClass(str);
instance.myMethod("other string") // will compile
作为:
let num = 32423423;
let instance = new MyClass(num);
instance.myMethod("other string") // won't compile

2018-02-28   #5

如果这是返回一个的身份函数,则没有区别 参数和使用没有类型限制:

const foo: any = fn(['whatever']);
键入的代码有所不同:
const foo: string = fn('ok');
const bar: string = fn([{ not: 'ok' }]);
而且,泛型类型的使用提供了语义。这签名建议EST序列 该函数是无类型的并返回任何内容:
function fn(arg: any): any { ... }
此签名表明该函数返回相同键入为 论据:
function fn<T>(arg: T): T { ... }
实际功能通常比return arg例子更有意义。 泛型类型可以b从类型限制中获益(显然,any) 不能):
function fn<T>(arg: T[]): T[] {
  return arg.map((v, i) => arg[i - 1]);
}
但是,当这些好处变得更加明显时功能一起使用 与其他泛型类和泛型函数一起使用(并且, 泛型参与):
function fn<T>(arg: T[]): T[] {
  return Array.from(new Set<T>(arg));
}
这允许在输入之间始终保持T类型 (参数)和输出(返回值):
const foo: string[] = fn(['ok']);
const bar: string[] = fn([{ not: 'ok' }]);
由于存在TypeScript类型,因此性能不会有任何差异 仅限于设计时间。

登录后方可回帖

Loading...