TypeScript的泛型允许我们在定义函数、类和接口时使用参数化类型，使得这些实体可以适应不同类型的数据。泛型可以增加代码的重用性和灵活性。
同时，TypeScript的命名空间提供了一种在全局命名空间中组织代码的方式，可以避免全局变量污染和命名冲突。命名空间使用namespace关键字定义，可以包含变量、函数、类和接口等。
通过使用泛型和命名空间，我们可以更好地组织和重用代码，提高了TypeScript的可扩展性和可维护性。
TypeScript 泛型
泛型（Generics）是一种编程语言特性，允许在定义函数、类、接口等时使用占位符来表示类型，而不是具体的类型。
泛型是一种在编写可重用、灵活且类型安全的代码时非常有用的功能。
使用泛型的主要目的是为了处理不特定类型的数据，使得代码可以适用于多种数据类型而不失去类型检查。
泛型的优势包括：
-
代码重用： 可以编写与特定类型无关的通用代码，提高代码的复用性。
-
类型安全： 在编译时进行类型检查，避免在运行时出现类型错误。
-
抽象性： 允许编写更抽象和通用的代码，适应不同的数据类型和数据结构。
泛型标识符
在泛型中，通常使用一些约定俗成的标识符，比如常见的 T（表示 Type）、U、V 等，但实际上你可以使用任何标识符。
T: 代表 "Type"，是最常见的泛型类型参数名。
function identity<T>(arg: T): T
{
return arg;
}K, V: 用于表示键（Key）和值（Value）的泛型类型参数。
interface KeyValuePair<K, V>
{
key: K;
value: V;
}E: 用于表示数组元素的泛型类型参数。
function printArray<E>(arr: E[]): void
{
arr.forEach(item => console.log(item));
}R: 用于表示函数返回值的泛型类型参数。
function getResult<R>(value: R): R
{
return value;
}U, V: 通常用于表示第二、第三个泛型类型参数。
function combine<U, V>(first: U, second: V): string
{
return `${first} ${second}`;
}这些标识符是约定俗成的，实际上你可以选择任何符合标识符规范的名称。关键是使得代码易读和易于理解，所以建议在泛型类型参数上使用描述性的名称，以便于理解其用途。
泛型函数（Generic Functions）
使用泛型来创建一个可以处理不同类型的函数：
function identity<T>(arg: T): T
{
return arg;
}
// 使用泛型函数
let result = identity<string>("Hello");
console.log(result); // 输出: Hello
let numberResult = identity<number>(42);
console.log(numberResult); // 输出: 42解析： 以上例子中，identity 是一个泛型函数，使用 <T> 表示泛型类型。它接受一个参数 arg 和返回值都是泛型类型 T。在使用时，可以通过尖括号 <> 明确指定泛型类型。第一个调用指定了 string 类型，第二个调用指定了 number 类型。
泛型接口（Generic Interfaces）
可以使用泛型来定义接口，使接口的成员能够使用任意类型：
// 基本语法
interface Pair<T, U>
{
first: T;
second: U;
}
// 使用泛型接口
let pair: Pair<string, number> = { first: "hello", second: 42 };
console.log(pair); // 输出: { first: 'hello', second: 42 }解析： 这里定义了一个泛型接口 Pair，它有两个类型参数 T 和 U。然后，使用这个泛型接口创建了一个对象 pair，其中 first 是字符串类型，second 是数字类型。
泛型类（Generic Classes）
泛型也可以应用于类的实例变量和方法：
// 基本语法
class Box<T>
{
private value: T;
constructor(value: T)
{
this.value = value;
}
getValue(): T
{
return this.value;
}
}
// 使用泛型类
let stringBox = new Box<string>("TypeScript");
console.log(stringBox.getValue()); // 输出: TypeScript泛型约束（Generic Constraints）
有时候你想限制泛型的类型范围，可以使用泛型约束：
// 基本语法
interface Lengthwise
{
length: number;
}
function logLength<T extends Lengthwise>(arg: T): void
{
console.log(arg.length);
}
// 正确的使用
logLength("hello"); // 输出: 5
// 错误的使用，因为数字没有 length 属性
logLength(42); // 错误解析： 在这个例子中，定义了一个泛型函数 logLength，它接受一个类型为 T 的参数，但有一个约束条件，即 T 必须实现 Lengthwise 接口，该接口要求有 length 属性。因此，可以正确调用 logLength("hello")，但不能调用 logLength(42)，因为数字没有 length 属性。
泛型与默认值
可以给泛型设置默认值，使得在不指定类型参数时能够使用默认类型：
// 基本语法
function defaultValue<T = string>(arg: T): T
{
return arg;
}
// 使用带默认值的泛型函数
let result1 = defaultValue("hello"); // 推断为 string 类型
let result2 = defaultValue(42); // 推断为 number 类型说明： 这个例子展示了带有默认值的泛型函数。函数 defaultValue 接受一个泛型参数 T，并给它设置了默认类型为 string。在使用时，如果没有显式指定类型，会使用默认类型。在例子中，第一个调用中 result1 推断为 string 类型，第二个调用中 result2 推断为 number 类型。
TypeScript 命名空间
命名空间一个最明确的目的就是解决重名问题。
假设这样一种情况，当一个班上有两个名叫小明的学生时，为了明确区分它们，我们在使用名字之外，不得不使用一些额外的信息，比如他们的姓（王小明，李小明），或者他们父母的名字等等。
命名空间定义了标识符的可见范围，一个标识符可在多个命名空间中定义，它在不同命名空间中的含义是互不相干的。这样，在一个新的命名空间中可定义任何标识符，它们不会与任何已有的标识符发生冲突，因为已有的定义都处于其他命名空间中。
TypeScript 中命名空间使用 namespace 来定义，语法格式如下：
namespace SomeNameSpaceName
{
export interface ISomeInterfaceName { }
export class SomeClassName { }
}以上定义了一个命名空间 SomeNameSpaceName，如果我们需要在外部可以调用 SomeNameSpaceName 中的类和接口，则需要在类和接口添加 export 关键字。
要在另外一个命名空间调用语法格式为：
SomeNameSpaceName.SomeClassName;如果一个命名空间在一个单独的 TypeScript 文件中，则应使用三斜杠 /// 引用它，语法格式如下：
/// <reference path = "SomeFileName.ts" />以下实例演示了命名空间的使用，定义在不同文件中：
IShape.ts 文件代码：
namespace Drawing
{
export interface IShape
{
draw();
}
}Circle.ts 文件代码：
/// <reference path = "IShape.ts" />
namespace Drawing
{
export class Circle implements IShape
{
public draw()
{
console.log("Circle is drawn");
}
}
}Triangle.ts 文件代码：
/// <reference path = "IShape.ts" />
namespace Drawing
{
export class Triangle implements IShape
{
public draw()
{
console.log("Triangle is drawn");
}
}
}TestShape.ts 文件代码：
/// <reference path = "IShape.ts" />
/// <reference path = "Circle.ts" />
/// <reference path = "Triangle.ts" />
function drawAllShapes(shape:Drawing.IShape)
{
shape.draw();
}
drawAllShapes(new Drawing.Circle());
drawAllShapes(new Drawing.Triangle());嵌套命名空间
命名空间支持嵌套，即你可以将命名空间定义在另外一个命名空间里头。
namespace namespace_name1
{
export namespace namespace_name2
{
export class class_name { }
}
}成员的访问使用点号 . 来实现，如下实例：
Invoice.ts 文件代码：
namespace Zachen
{
export namespace invoiceApp
{
export class Invoice
{
public calculateDiscount(price: number)
{
return price * .40;
}
}
}
}InvoiceTest.ts 文件代码：
/// <reference path = "Invoice.ts" />
var invoice = new Runoob.invoiceApp.Invoice();
console.log(invoice.calculateDiscount(500));结论
通过泛型和命名空间，确实可以更好地组织和重用代码，提高了TypeScript的可扩展性和可维护性。以便在如Cocos这样的引擎中以更高效的方式开发项目。