泛型专题测试

在 TypeScript 中,泛型函数的类型参数在调用时可以被自动推断,因此总是可以省略显式的类型参数指定。

一个泛型函数可以声明多个类型参数,这些类型参数之间可以相互引用和约束。

以下代码中,函数调用 identity(42) 的返回值类型是什么?

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

const result = identity(42);

对于以下泛型函数,当调用 createEmpty<string>(3) 时,返回值的类型是什么?

function createEmpty<T>(length: number): T[] {
  return new Array<T>(length);
}

const arr = createEmpty<string>(3);

以下关于 TypeScript 泛型函数优势的描述,哪些是正确的?

泛型接口在使用时必须显式指定类型参数,不能依赖类型推断。

在泛型接口中定义的泛型参数,会作用于接口的所有成员和方法。

以下代码中,Processor 接口使用方式正确的是?

interface Processor<T> {
  process(input: T): T;
  transform<U>(input: U): U;
}

const impl: Processor<number> = {
  process(input) { return input; },
  transform(input) { return input; }
};

以下关于泛型接口和泛型类型别名的区别,描述正确的是?

interface Handler<T> {
  handle(data: T): void;
}

type Processor<T> = (data: T) => void;

以下哪些场景适合使用泛型接口?

TypeScript 中的泛型类可以拥有静态成员,且静态成员可以引用类的泛型参数。

泛型类在实例化时必须显式指定类型参数,否则类型参数会被推断为 any 类型。

以下代码中,StringStack 类的 items 属性类型是什么?

class Stack<T> {
  protected items: T[] = [];
  push(item: T): void { this.items.push(item); }
  pop(): T | undefined { return this.items.pop(); }
}

class StringStack extends Stack<string> {
  // 继承时固定 T 为 string
}

const stack = new StringStack();

以下代码能够正确编译的是?

interface Collection<T> {
  add(item: T): void;
  getAll(): T[];
}

// 选项A: class List<T> implements Collection<T> { ... }
// 选项B: class List implements Collection { ... }
// 选项C: class List<T> implements Collection { ... }
// 选项D: class List<U> implements Collection<T> { ... }

interface KeyValueStore<K, V> {
  get(key: K): V | undefined;
  set(key: K, value: V): void;
}

关于以上泛型接口，以下哪些说法是正确的？

使用 T extends string 约束后,类型参数 T 只能是 string 类型,不能是 string 的字面量类型。

泛型约束中,一个泛型参数可以被另一个泛型参数所约束,例如 <T, K extends keyof T> 是合法的语法。

以下代码中,函数体内哪行代码可以正确编译?

interface HasLength {
  length: number;
}

function logLength<T extends HasLength>(arg: T): number {
  // A: return arg.length;
  // B: return arg.size;
  // C: return arg.valueOf();
  // D: return arg.toString().length;
}

对于以下代码,调用 mergeObjects({ name: "Alice" }, { age: 30 }) 的返回类型是什么?

function mergeObjects<T extends object, U extends object>(a: T, b: U): T & U {
  return { ...a, ...b };
}

以下哪些是 TypeScript 泛型约束的合法且常见的用法?