原始类型定义 - 元素码农

发布时间: 2025-03-31 09:19

↑

# 原始类型定义

TypeScript中的原始类型（Primitive Types）是最基本的数据类型。本文将详细介绍这些类型的定义和使用方法。

## 基本原始类型

### 布尔类型（boolean）

```typescript
let isDone: boolean = false;
let isActive: boolean = true;

// 布尔对象（不推荐）
let booleanObject: Boolean = new Boolean(true);
```

### 数字类型（number）

```typescript
// 十进制
let decimal: number = 6;

// 十六进制
let hex: number = 0xf00d;

// 二进制
let binary: number = 0b1010;

// 八进制
let octal: number = 0o744;

// 浮点数
let float: number = 3.14;

// 特殊数值
let notANumber: number = NaN;
let infinityNumber: number = Infinity;
```

### 字符串类型（string）

```typescript
// 普通字符串
let color: string = "blue";
let name: string = 'TypeScript';

// 模板字符串
let fullName: string = `John Smith`;
let age: number = 30;
let greeting: string = `Hello, my name is ${fullName} and I'm ${age} years old`;

// 多行字符串
let multiLine: string = `
  This is a
  multi-line
  string
`;
```

### null和undefined

```typescript
// 明确的null和undefined类型
let nullValue: null = null;
let undefinedValue: undefined = undefined;

// 在严格模式下，null和undefined只能赋值给它们自己
let strictNull: null = null;
let strictUndefined: undefined = undefined;
```

## Symbol类型

```typescript
// 创建唯一的Symbol值
let sym1: symbol = Symbol();
let sym2: symbol = Symbol("key");

// Symbols是唯一的
let sym3: symbol = Symbol("key");
console.log(sym2 === sym3); // false

// 用作对象属性的键
let obj = {
    [sym1]: "value"
};
```

## BigInt类型

```typescript
// BigInt字面量
let bigInt1: bigint = 9007199254740991n;

// BigInt函数
let bigInt2: bigint = BigInt(9007199254740991);

// 算术运算
let sum: bigint = bigInt1 + BigInt(1);
```

## void类型

```typescript
// 用于表示没有返回值的函数
function warnUser(): void {
    console.log("This is a warning message");
}

// void类型变量（不常用）
let unusable: void = undefined;
```

## never类型

```typescript
// 永远不会返回的函数（抛出错误）
function error(message: string): never {
    throw new Error(message);
}

// 永远不会返回的函数（无限循环）
function infiniteLoop(): never {
    while (true) {}
}
```

## 类型推断

TypeScript具有强大的类型推断能力，通常不需要显式声明原始类型：

```typescript
// 类型推断为number
let x = 3;

// 类型推断为string
let y = "hello";

// 类型推断为boolean
let z = true;
```

## 类型断言

有时需要手动指定一个值的类型：

```typescript
// 尖括号语法
let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;

// as语法（推荐，在JSX中必须使用）
let otherValue: any = "this is a string";
let otherLength: number = (otherValue as string).length;
```

## 最佳实践

1. **使用原始类型而不是对象包装器**：
```typescript
// 好的做法
let str: string = "Hello";

// 避免这样做
let str: String = new String("Hello");
```

2. **正确处理null和undefined**：
```typescript
// 启用严格空值检查
function process(value: string | null) {
    if (value === null) {
        // 处理null情况
        return;
    }
    console.log(value.toUpperCase());
}
```

3. **合理使用类型推断**：
```typescript
// 让TypeScript推断简单类型
let message = "Hello"; // 推断为string

// 为复杂类型添加显式注解
let complex: { name: string; age: number } = {
    name: "TypeScript",
    age: 25
};
```

## 常见问题

1. **数字精度问题**：
```typescript
// 使用toFixed处理浮点数
let price: number = 0.1 + 0.2;
console.log(price.toFixed(2)); // "0.30"
```

2. **字符串比较**：
```typescript
// 使用toLowerCase()进行不区分大小写的比较
function compareStrings(a: string, b: string): boolean {
    return a.toLowerCase() === b.toLowerCase();
}
```

3. **null检查**：
```typescript
// 使用可选链操作符
type User = { name: string; address?: { street: string } };
function getStreet(user: User): string | undefined {
    return user.address?.street;
}
```

## 下一步

掌握了原始类型后，你可以：

1. 学习复杂类型（数组、对象、接口等）
2. 探索类型转换和类型守卫
3. 了解泛型的使用
4. 实践高级类型特性

通过合理使用原始类型，你可以构建更加健壮和类型安全的TypeScript应用。