TypeScript基本类型 #

一、类型系统概述 #

TypeScript支持JavaScript的所有原始类型，并添加了额外的类型检查能力。TypeScript的类型系统是结构化类型系统（structural type system），也称为"鸭子类型"（duck typing）。

二、字符串类型（string） #

2.1 基本用法 #

typescript 
let name: string = 'TypeScript';
let greeting: string = "Hello, World!";

2.2 模板字符串 #

typescript 
let name: string = 'TypeScript';
let version: number = 5.4;

let message: string = `Welcome to ${name} ${version}!`;
console.log(message);

2.3 多行字符串 #

typescript 
let multiline: string = `
    This is a
    multiline string
    in TypeScript
`;

2.4 字符串方法 #

typescript 
let str: string = 'Hello, TypeScript!';

console.log(str.length);
console.log(str.toUpperCase());
console.log(str.toLowerCase());
console.log(str.substring(0, 5));
console.log(str.split(', '));
console.log(str.replace('TypeScript', 'World'));
console.log(str.includes('Type'));
console.log(str.startsWith('Hello'));
console.log(str.endsWith('!'));

三、数字类型（number） #

3.1 基本用法 #

TypeScript中的所有数字都是浮点数，类型为number。

typescript 
let integer: number = 42;
let float: number = 3.14;
let negative: number = -10;

3.2 不同进制 #

typescript 
let decimal: number = 42;
let hex: number = 0x2a;
let binary: number = 0b101010;
let octal: number = 0o52;

console.log(decimal === hex);
console.log(decimal === binary);
console.log(decimal === octal);

3.3 特殊数值 #

typescript 
let infinity: number = Infinity;
let negInfinity: number = -Infinity;
let notANumber: number = NaN;

console.log(Number.POSITIVE_INFINITY);
console.log(Number.NEGATIVE_INFINITY);
console.log(Number.NaN);

3.4 数字方法 #

typescript 
let num: number = 3.14159;

console.log(num.toFixed(2));
console.log(num.toPrecision(4));
console.log(Number.parseInt('42'));
console.log(Number.parseFloat('3.14'));
console.log(Number.isInteger(42));
console.log(Number.isNaN(NaN));
console.log(Number.isFinite(Infinity));

3.5 数学运算 #

typescript 
console.log(Math.PI);
console.log(Math.abs(-42));
console.log(Math.ceil(3.14));
console.log(Math.floor(3.14));
console.log(Math.round(3.5));
console.log(Math.max(1, 2, 3));
console.log(Math.min(1, 2, 3));
console.log(Math.random());
console.log(Math.sqrt(16));
console.log(Math.pow(2, 3));

四、布尔类型（boolean） #

4.1 基本用法 #

typescript 
let isDone: boolean = false;
let hasStarted: boolean = true;

4.2 布尔运算 #

typescript 
let a: boolean = true;
let b: boolean = false;

console.log(a && b);
console.log(a || b);
console.log(!a);

4.3 比较运算 #

typescript 
let x: number = 5;
let y: number = 10;

let isGreater: boolean = x > y;
let isEqual: boolean = x === y;
let isNotEqual: boolean = x !== y;

4.4 类型转换 #

typescript 
let truthy: boolean = Boolean(1);
let falsy: boolean = Boolean(0);
let fromString: boolean = !!'hello';
let fromEmptyString: boolean = !!'';

五、null类型 #

5.1 基本用法 #

null表示"没有值"或"空值"。

typescript 
let n: null = null;

5.2 严格空值检查 #

在严格模式下，null只能赋值给null、undefined或any类型。

typescript 
let name: string = null;

let name: string | null = null;

5.3 null检查 #

typescript 
function greet(name: string | null): string {
    if (name === null) {
        return 'Hello, Guest!';
    }
    return `Hello, ${name}!`;
}

console.log(greet(null));
console.log(greet('TypeScript'));

六、undefined类型 #

6.1 基本用法 #

undefined表示"未定义"或"缺少值"。

typescript 
let u: undefined = undefined;

6.2 自动赋值 #

未初始化的变量自动为undefined。

typescript 
let name: string;
console.log(name);

6.3 可选参数 #

可选参数自动包含undefined类型。

typescript 
function greet(name?: string): string {
    if (name === undefined) {
        return 'Hello, Guest!';
    }
    return `Hello, ${name}!`;
}

6.4 可选属性 #

typescript 
interface User {
    name: string;
    email?: string;
}

let user: User = { name: 'TypeScript' };
console.log(user.email);

七、symbol类型 #

7.1 基本用法 #

symbol是ES6引入的原始类型，表示唯一的标识符。

typescript 
let sym1: symbol = Symbol('key');
let sym2: symbol = Symbol('key');

console.log(sym1 === sym2);

7.2 用作对象属性键 #

typescript 
const key: symbol = Symbol('key');

interface Obj {
    [key: symbol]: string;
}

let obj: Obj = {
    [key]: 'value'
};

console.log(obj[key]);

7.3 全局Symbol注册表 #

typescript 
let globalSym1: symbol = Symbol.for('app.key');
let globalSym2: symbol = Symbol.for('app.key');

console.log(globalSym1 === globalSym2);
console.log(Symbol.keyFor(globalSym1));

7.4 内置Symbol #

typescript 
const iterable = {
    [Symbol.iterator]() {
        let step = 0;
        return {
            next() {
                step++;
                if (step <= 3) {
                    return { value: step, done: false };
                }
                return { value: undefined, done: true };
            }
        };
    }
};

for (const value of iterable) {
    console.log(value);
}

八、bigint类型 #

8.1 基本用法 #

bigint用于表示任意精度的整数，可以表示超过Number.MAX_SAFE_INTEGER的整数。

typescript 
let big1: bigint = 9007199254740991n;
let big2: bigint = BigInt(9007199254740991);
let big3: bigint = BigInt('9007199254740991');

8.2 运算 #

typescript 
let a: bigint = 100n;
let b: bigint = 200n;

console.log(a + b);
console.log(b - a);
console.log(a * b);
console.log(b / a);
console.log(b % a);
console.log(a ** 2n);

8.3 比较 #

typescript 
let big: bigint = 100n;
let num: number = 100;

console.log(big === num);
console.log(big == num);
console.log(big > 50n);

8.4 类型转换 #

typescript 
let big: bigint = 100n;
let num: number = Number(big);
let str: string = big.toString();

8.5 注意事项 #

typescript 
let big: bigint = 100n;
let num: number = 50;

let result = big + num;

let result = big + BigInt(num);

九、类型兼容性 #

9.1 null和undefined的兼容性 #

在非严格模式下：

typescript 
let name: string = null;
let age: number = undefined;

在严格模式下：

typescript 
let name: string | null = null;
let age: number | undefined = undefined;

9.2 联合类型处理 #

typescript 
function process(value: string | null | undefined): string {
    if (value === null) {
        return 'null';
    }
    if (value === undefined) {
        return 'undefined';
    }
    return value;
}

9.3 可选链和空值合并 #

typescript 
interface User {
    name: string;
    address?: {
        city?: string;
    };
}

let user: User = { name: 'TypeScript' };

let city: string | undefined = user.address?.city;

let cityOrDefault: string = user.address?.city ?? 'Unknown';

十、类型守卫 #

10.1 typeof检查 #

typescript 
function process(value: string | number): void {
    if (typeof value === 'string') {
        console.log(value.toUpperCase());
    } else {
        console.log(value.toFixed(2));
    }
}

10.2 null检查 #

typescript 
function greet(name: string | null): string {
    if (name === null) {
        return 'Hello, Guest!';
    }
    return `Hello, ${name}!`;
}

10.3 真值检查 #

typescript 
function printLength(str: string | null | undefined): void {
    if (str) {
        console.log(str.length);
    } else {
        console.log('Empty string');
    }
}

十一、总结 #

本章介绍了TypeScript的基本类型：

类型 描述 示例
string 字符串 'hello', "world", `template`
number 数字 42, 3.14, 0xff, 0b1010
boolean 布尔值 true, false
null 空值 null
undefined 未定义 undefined
symbol 唯一标识符 Symbol('key')
bigint 大整数 9007199254740991n

关键要点：

  1. TypeScript完全支持JavaScript的所有原始类型
  2. 严格模式下需要显式处理null和undefined
  3. symbol用于创建唯一标识符
  4. bigint用于处理大整数
  5. 使用类型守卫进行类型收窄
最后更新：2026-03-26