TypeScript Number 类型

在 TypeScript 中，Number 是一种基本数据类型，用于表示数值。它包括整数、浮点数、负数、正数、零，以及一些特殊值如 Infinity、-Infinity 和 NaN（Not a Number）。本文将详细介绍 TypeScript 中的 Number 类型。

1. 基本用法

声明 Number 类型变量

let age: number = 25;
let price: number = 9.99;
let temperature: number = -5;
let zero: number = 0;

数值字面量

TypeScript 支持多种数值字面量形式：

• 十进制：123
• 十六进制：0x7B（前缀 0x）
• 八进制：0o173（前缀 0o）
• 二进制：0b1111011（前缀 0b）
• 科学计数法：1.23e3（等于 1230）

let decimal: number = 123;
let hex: number = 0x7B; // 123
let octal: number = 0o173; // 123
let binary: number = 0b1111011; // 123
let scientific: number = 1.23e3; // 1230

2. 特殊数值

Infinity 和 -Infinity

Infinity 表示正无穷大，-Infinity 表示负无穷大。

let positiveInfinity: number = Infinity;
let negativeInfinity: number = -Infinity;

console.log(positiveInfinity); // 输出：Infinity
console.log(negativeInfinity); // 输出：-Infinity

// 计算得到 Infinity
console.log(1 / 0); // 输出：Infinity
console.log(-1 / 0); // 输出：-Infinity

NaN

NaN 表示不是一个数字（Not a Number），通常在无效的数学运算中产生。

let notANumber: number = NaN;

console.log(notANumber); // 输出：NaN

// 计算得到 NaN
console.log(0 / 0); // 输出：NaN
console.log(Math.sqrt(-1)); // 输出：NaN
console.log("hello" * 5); // 输出：NaN

3. 内置方法

Number 对象方法

Number.parseFloat()

将字符串转换为浮点数。

console.log(Number.parseFloat("123.45")); // 输出：123.45
console.log(Number.parseFloat("123")); // 输出：123
console.log(Number.parseFloat("123.45abc")); // 输出：123.45
console.log(Number.parseFloat("abc123")); // 输出：NaN

Number.parseInt()

将字符串转换为整数，可以指定进制。

console.log(Number.parseInt("123")); // 输出：123
console.log(Number.parseInt("123.45")); // 输出：123
console.log(Number.parseInt("123abc")); // 输出：123
console.log(Number.parseInt("abc123")); // 输出：NaN

// 指定进制
console.log(Number.parseInt("10", 2)); // 输出：2（二进制）
console.log(Number.parseInt("10", 8)); // 输出：8（八进制）
console.log(Number.parseInt("10", 10)); // 输出：10（十进制）
console.log(Number.parseInt("10", 16)); // 输出：16（十六进制）

Number.isNaN()

检查一个值是否是 NaN。

console.log(Number.isNaN(NaN)); // 输出：true
console.log(Number.isNaN(123)); // 输出：false
console.log(Number.isNaN("123")); // 输出：false
console.log(Number.isNaN("abc")); // 输出：false

Number.isFinite()

检查一个值是否是有限的数字。

console.log(Number.isFinite(123)); // 输出：true
console.log(Number.isFinite(123.45)); // 输出：true
console.log(Number.isFinite(Infinity)); // 输出：false
console.log(Number.isFinite(-Infinity)); // 输出：false
console.log(Number.isFinite(NaN)); // 输出：false

Number.isInteger()

检查一个值是否是整数。

console.log(Number.isInteger(123)); // 输出：true
console.log(Number.isInteger(123.45)); // 输出：false
console.log(Number.isInteger(0)); // 输出：true
console.log(Number.isInteger(-123)); // 输出：true

Number.isSafeInteger()

检查一个值是否是安全的整数（在 -(2^53 - 1) 到 2^53 - 1 之间）。

console.log(Number.isSafeInteger(123)); // 输出：true
console.log(Number.isSafeInteger(9007199254740991)); // 输出：true（2^53 - 1）
console.log(Number.isSafeInteger(9007199254740992)); // 输出：false（超出范围）

Number.MAX_VALUE

表示 JavaScript 中可以表示的最大数值。

console.log(Number.MAX_VALUE); // 输出：1.7976931348623157e+308

Number.MIN_VALUE

表示 JavaScript 中可以表示的最小正数。

console.log(Number.MIN_VALUE); // 输出：5e-324

Number.MAX_SAFE_INTEGER

表示 JavaScript 中可以安全表示的最大整数。

console.log(Number.MAX_SAFE_INTEGER); // 输出：9007199254740991

Number.MIN_SAFE_INTEGER

表示 JavaScript 中可以安全表示的最小整数。

console.log(Number.MIN_SAFE_INTEGER); // 输出：-9007199254740991

实例方法

toFixed()

将数字转换为字符串，并保留指定小数位数。

let num: number = 123.456;

console.log(num.toFixed(0)); // 输出："123"
console.log(num.toFixed(2)); // 输出："123.46"
console.log(num.toFixed(5)); // 输出："123.45600"

toExponential()

将数字转换为科学计数法表示的字符串。

let num: number = 12345;

console.log(num.toExponential()); // 输出："1.2345e+4"
console.log(num.toExponential(2)); // 输出："1.23e+4"

toPrecision()

将数字转换为指定精度的字符串。

let num: number = 123.456;

console.log(num.toPrecision(3)); // 输出："123"
console.log(num.toPrecision(4)); // 输出："123.5"
console.log(num.toPrecision(6)); // 输出："123.456"

toString()

将数字转换为字符串，可以指定进制。

let num: number = 123;

console.log(num.toString()); // 输出："123"
console.log(num.toString(2)); // 输出："1111011"（二进制）
console.log(num.toString(8)); // 输出："173"（八进制）
console.log(num.toString(16)); // 输出："7b"（十六进制）

valueOf()

返回数字的原始值。

let num: number = 123;
console.log(num.valueOf()); // 输出：123

4. 类型转换

字符串转数字

// 使用 Number() 函数
let str1: string = "123";
let num1: number = Number(str1);
console.log(num1); // 输出：123

// 使用 parseInt() 函数
let str2: string = "123.45";
let num2: number = parseInt(str2);
console.log(num2); // 输出：123

// 使用 parseFloat() 函数
let str3: string = "123.45";
let num3: number = parseFloat(str3);
console.log(num3); // 输出：123.45

// 使用一元加号运算符
let str4: string = "123";
let num4: number = +str4;
console.log(num4); // 输出：123

布尔值转数字

let bool1: boolean = true;
let num1: number = Number(bool1);
console.log(num1); // 输出：1

let bool2: boolean = false;
let num2: number = Number(bool2);
console.log(num2); // 输出：0

数字转字符串

// 使用 String() 函数
let num1: number = 123;
let str1: string = String(num1);
console.log(str1); // 输出："123"

// 使用 toString() 方法
let num2: number = 123;
let str2: string = num2.toString();
console.log(str2); // 输出："123"

// 使用模板字符串
let num3: number = 123;
let str3: string = `${num3}`;
console.log(str3); // 输出："123"

数字转布尔值

let num1: number = 123;
let bool1: boolean = Boolean(num1);
console.log(bool1); // 输出：true

let num2: number = 0;
let bool2: boolean = Boolean(num2);
console.log(bool2); // 输出：false

let num3: number = NaN;
let bool3: boolean = Boolean(num3);
console.log(bool3); // 输出：false

let num4: number = Infinity;
let bool4: boolean = Boolean(num4);
console.log(bool4); // 输出：true

5. 数学运算

基本运算

let a: number = 10;
let b: number = 3;

console.log(a + b); // 输出：13
console.log(a - b); // 输出：7
console.log(a * b); // 输出：30
console.log(a / b); // 输出：3.3333333333333335
console.log(a % b); // 输出：1
console.log(a ** b); // 输出：1000（10 的 3 次方）

Math 对象

Math 是 JavaScript 中的一个内置对象，提供了许多数学相关的方法。

Math.abs()

返回数字的绝对值。

console.log(Math.abs(-10)); // 输出：10
console.log(Math.abs(10)); // 输出：10

Math.ceil()

向上取整。

console.log(Math.ceil(10.1)); // 输出：11
console.log(Math.ceil(10.9)); // 输出：11

Math.floor()

向下取整。

console.log(Math.floor(10.1)); // 输出：10
console.log(Math.floor(10.9)); // 输出：10

Math.round()

四舍五入。

console.log(Math.round(10.1)); // 输出：10
console.log(Math.round(10.5)); // 输出：11
console.log(Math.round(10.9)); // 输出：11

Math.max()

返回一组数字中的最大值。

console.log(Math.max(1, 2, 3, 4, 5)); // 输出：5

Math.min()

返回一组数字中的最小值。

console.log(Math.min(1, 2, 3, 4, 5)); // 输出：1

Math.random()

返回一个 0 到 1 之间的随机数。

console.log(Math.random()); // 输出：0 到 1 之间的随机数

// 生成 1 到 100 之间的随机整数
let randomNum: number = Math.floor(Math.random() * 100) + 1;
console.log(randomNum);

Math.sqrt()

返回数字的平方根。

console.log(Math.sqrt(9)); // 输出：3
console.log(Math.sqrt(16)); // 输出：4

Math.pow()

返回一个数的指定幂次。

console.log(Math.pow(2, 3)); // 输出：8
console.log(Math.pow(10, 2)); // 输出：100

Math.PI

表示圆周率 π。

console.log(Math.PI); // 输出：3.141592653589793

Math.E

表示自然对数的底数 e。

console.log(Math.E); // 输出：2.718281828459045

6. 类型守卫

在 TypeScript 中，可以使用类型守卫来检查一个值是否是数字类型。

typeof 类型守卫

function processValue(value: string | number) {
  if (typeof value === "number") {
    // 在这个分支中，TypeScript 知道 value 是 number 类型
    console.log(value.toFixed(2));
  } else {
    // 在这个分支中，TypeScript 知道 value 是 string 类型
    console.log(value.toUpperCase());
  }
}

processValue(123.45); // 输出：123.45
processValue("hello"); // 输出：HELLO

自定义类型守卫

function isNumber(value: any): value is number {
  return typeof value === "number" && !isNaN(value);
}

function processValue(value: any) {
  if (isNumber(value)) {
    // 在这个分支中，TypeScript 知道 value 是 number 类型
    console.log(value.toFixed(2));
  } else {
    console.log("Not a number");
  }
}

processValue(123.45); // 输出：123.45
processValue("hello"); // 输出：Not a number
processValue(NaN); // 输出：Not a number

7. 最佳实践

1. 使用类型注解

为数字变量添加类型注解，提高代码的可读性和类型安全性。

// 推荐
let age: number = 25;

// 不推荐
let age = 25;

2. 避免使用 NaN 进行比较

NaN 不等于任何值，包括它自己，所以不能使用 === 或 == 来检查一个值是否是 NaN。

// 错误
let value = NaN;
if (value === NaN) {
  // 永远不会执行
}

// 正确
let value = NaN;
if (Number.isNaN(value)) {
  // 会执行
}

3. 注意浮点数精度问题

JavaScript 中的浮点数可能会有精度问题，需要注意。

// 浮点数精度问题
console.log(0.1 + 0.2); // 输出：0.30000000000000004

// 解决方法：使用 toFixed() 或 toPrecision()
console.log((0.1 + 0.2).toFixed(1)); // 输出："0.3"
console.log(parseFloat((0.1 + 0.2).toFixed(1))); // 输出：0.3

4. 使用 Math 方法进行数学运算

对于复杂的数学运算，使用 Math 对象提供的方法，而不是自己实现。

// 推荐
let max = Math.max(1, 2, 3, 4, 5);

// 不推荐
let numbers = [1, 2, 3, 4, 5];
let max = numbers[0];
for (let i = 1; i < numbers.length; i++) {
  if (numbers[i] > max) {
    max = numbers[i];
  }
}

5. 使用安全的整数

当处理大整数时，使用 Number.isSafeInteger() 检查是否是安全的整数。

function processInteger(num: number) {
  if (Number.isSafeInteger(num)) {
    console.log(`${num} is a safe integer`);
  } else {
    console.log(`${num} is not a safe integer`);
  }
}

processInteger(9007199254740991); // 输出：9007199254740991 is a safe integer
processInteger(9007199254740992); // 输出：9007199254740992 is not a safe integer

8. 常见错误

1. 类型转换错误

在进行类型转换时，可能会得到意外的结果。

// 错误：字符串转数字
let str = "abc";
let num = Number(str); // NaN

// 错误：布尔值转数字
let bool = true;
let num = Number(bool); // 1

// 错误：对象转数字
let obj = {};
let num = Number(obj); // NaN

2. 浮点数精度问题

JavaScript 中的浮点数精度问题可能会导致意外的结果。

// 错误：浮点数精度问题
let a = 0.1;
let b = 0.2;
let c = a + b; // 0.30000000000000004

// 错误：比较浮点数
if (a + b === 0.3) {
  // 永远不会执行
}

3. NaN 的处理

NaN 不等于任何值，包括它自己，所以需要使用 Number.isNaN() 来检查。

// 错误：检查 NaN
let value = NaN;
if (value === NaN) {
  // 永远不会执行
}

// 正确：检查 NaN
let value = NaN;
if (Number.isNaN(value)) {
  // 会执行
}

4. 整数溢出

当数字超出 JavaScript 可以安全表示的范围时，会发生整数溢出。

// 错误：整数溢出
let safeMax = Number.MAX_SAFE_INTEGER; // 9007199254740991
let unsafeNum = safeMax + 1; // 9007199254740992
console.log(unsafeNum); // 9007199254740992
console.log(unsafeNum + 1); // 9007199254740992（没有变化）

总结

TypeScript 中的 Number 类型是一种基本数据类型，用于表示数值。它包括：

• 基本用法：整数、浮点数、负数、正数、零
• 数值字面量：十进制、十六进制、八进制、二进制、科学计数法
• 特殊数值：Infinity、-Infinity、NaN
• 内置方法：Number 对象方法和实例方法
• 类型转换：字符串转数字、布尔值转数字、数字转字符串、数字转布尔值
• 数学运算：基本运算和 Math 对象方法
• 类型守卫：typeof 类型守卫和自定义类型守卫
• 最佳实践：使用类型注解、避免使用 NaN 进行比较、注意浮点数精度问题、使用 Math 方法进行数学运算、使用安全的整数

通过合理使用 Number 类型和相关方法，你可以在 TypeScript 中处理各种数值操作，编写更清晰、更安全的代码。