TypeScript any vs unknown 详细对比

TypeScript any vs unknown 详细对比

any 和 unknown 是 TypeScript 中两个特殊的顶层类型（top type），它们可以接受任何类型的值，但在类型安全上有本质区别。

---

一、核心区别

一句话总结

• any：可以赋值给任何类型，也可以访问任何属性/方法（完全不安全）

• unknown：只能赋值给 unknown 或 any，必须先进行类型检查才能使用（类型安全）

---

二、基本对比表

 

特性	any	unknown
接受任何类型的值	✅	✅
赋值给其他类型	✅ 可以	❌ 不可以（需要类型收窄）
访问属性/方法	✅ 可以（无检查）	❌ 不可以（需要类型收窄）
调用函数	✅ 可以	❌ 不可以
类型安全	❌ 不安全	✅ 安全
设计意图	绕过类型检查	安全地处理未知类型
IDE 提示	无任何提示	有类型收窄提示

三、详细示例

1. 赋值行为

typescript

// ===== any =====
let anyValue: any = "hello";

// ✅ any 可以赋值给任何类型（可能出错）
const str: string = anyValue;    // ✅ 编译通过
const num: number = anyValue;    // ✅ 编译通过
const bool: boolean = anyValue;  // ✅ 编译通过
// 运行时：num 实际是字符串 "hello"，导致类型不匹配

// ===== unknown =====
let unknownValue: unknown = "hello";

// ❌ unknown 不能直接赋值给具体类型
// const str2: string = unknownValue;   // ❌ 错误
// const num2: number = unknownValue;   // ❌ 错误

// ✅ 只能赋值给 unknown 或 any
const anotherUnknown: unknown = unknownValue;  // ✅ 正确
const anotherAny: any = unknownValue;          // ✅ 正确

---

2. 访问属性和方法

typescript

// ===== any =====
const anyObj: any = { name: "Alice" };

console.log(anyObj.name);           // ✅ 编译通过
console.log(anyObj.nonExistent);    // ✅ 编译通过（运行时 undefined）
anyObj.anyMethod();                 // ✅ 编译通过（运行时可能报错）

// ===== unknown =====
const unknownObj: unknown = { name: "Alice" };

// console.log(unknownObj.name);     // ❌ 错误：类型是 unknown
// unknownObj.anyMethod();           // ❌ 错误：类型是 unknown

// ✅ 需要先进行类型检查
if (typeof unknownObj === 'object' && unknownObj !== null) {
  console.log((unknownObj as { name: string }).name);  // ✅ 正确
}

---

3. 函数调用

typescript

// ===== any =====
const anyFn: any = () => console.log("hello");
anyFn();  // ✅ 编译通过

// ===== unknown =====
const unknownFn: unknown = () => console.log("hello");
// unknownFn();  // ❌ 错误：类型是 unknown

// ✅ 需要先检查是否为函数
if (typeof unknownFn === 'function') {
  unknownFn();  // ✅ 正确
}

---

4. 运算操作

typescript

// ===== any =====
const anyValue: any = 10;
const result1 = anyValue + 5;      // ✅ 编译通过
const result2 = anyValue.toFixed(); // ✅ 编译通过

// ===== unknown =====
const unknownValue: unknown = 10;
// const result3 = unknownValue + 5;  // ❌ 错误
// const result4 = unknownValue.toFixed(); // ❌ 错误

// ✅ 需要先进行类型收窄
if (typeof unknownValue === 'number') {
  const result5 = unknownValue + 5;      // ✅ 正确
  const result6 = unknownValue.toFixed(); // ✅ 正确
}

---

四、类型收窄（Type Narrowing）

unknown 的强大之处在于配合类型收窄使用：

1. typeof 类型守卫

typescript

function processValue(value: unknown): string {
  if (typeof value === 'string') {
    return value.toUpperCase();  // ✅ value 是 string
  }
  
  if (typeof value === 'number') {
    return value.toFixed(2);     // ✅ value 是 number
  }
  
  if (typeof value === 'boolean') {
    return value ? 'true' : 'false';  // ✅ value 是 boolean
  }
  
  return 'unknown type';
}