数据类型

1. TypeScript Number

Number对象是原始数值的包装对象。以下是一些Number的例子：

let num1: number = 123; // 整数
let num2: number = 0.456; // 浮点数// Number类型还可以表示特殊的值，如Infinity、-Infinity和NaN（非数字）
let notANumber: number = NaN;
let infinity: number = Infinity;

进制表示：

// Number 类型还支持二进制、八进制、十进制和十六进制字面量
let binary: number = 0b1010; // 二进制，输出 10
let octal: number = 0o744; // 八进制，输出 484
let decimal: number = 6; // 十进制，输出 6
let hex: number = 0xf00d; // 十六进制，输出 61453

---

常用的内置属性：

1. Number.MAX_VALUE: 表示可表示的最大数字。

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

2. Number.MIN_VALUE: 表示最小的正数。

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

3. Number.NaN: 表示 “非数字” 值。

   console.log(Number.NaN); // NaN
   

4. Number.POSITIVE_INFINITY: 正无穷大。

   console.log(Number.POSITIVE_INFINITY); // Infinity
   

5. Number.NEGATIVE_INFINITY: 负无穷大。

   console.log(Number.NEGATIVE_INFINITY); // -Infinity
   

6. Number.EPSILON: 表示 1 和比 1 大的最小浮点数之间的差值。

   console.log(Number.EPSILON); // 2.220446049250313e-16
   

7. Number.MAX_SAFE_INTEGER: 可精确表示的最大整数。

   console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991
   

8. Number.MIN_SAFE_INTEGER: 可精确表示的最小整数。

   console.log(Number.MIN_SAFE_INTEGER); // -9007199254740991
   

---

常用的内置方法：

1. Number.isFinite(number): 检查数字是否为有限的数字。

   console.log(Number.isFinite(1000)); // true
   console.log(Number.isFinite(Infinity)); // false
   

2. Number.isInteger(number): 检查是否是整数。

   console.log(Number.isInteger(1000)); // true
   console.log(Number.isInteger(1000.5)); // false
   

3. Number.isNaN(number): 检查是否是 NaN。

   console.log(Number.isNaN(NaN)); // true
   console.log(Number.isNaN(1000)); // false
   

4. Number.isSafeInteger(number): 检查是否是安全整数。

   console.log(Number.isSafeInteger(Math.pow(2, 53) - 1)); // true
   console.log(Number.isSafeInteger(Math.pow(2, 53))); // false
   

5. Number.parseFloat(string): 将字符串解析为浮点数。

   let str = "123.45";
   console.log(Number.parseFloat(str)); // 123.45
   

6. Number.parseInt(string, radix): 将字符串解析为指定基数的整数。

   let str = "1000";
   console.log(Number.parseInt(str, 10)); // 1000
   

7. toFixed(digits): 将数字格式化为字符串，保留指定小数位。

   let num: number = 123.456;
   console.log(num.toFixed(2)); // "123.46"
   

8. toExponential(fractionDigits): 转换为指数表示法。

   let num: number = 123456;
   console.log(num.toExponential(2)); // "1.23e+5"
   

9. toPrecision(precision): 指定有效位数。

   let num: number = 123.456;
   console.log(num.toPrecision(2)); // "1.2e+2"
   

10. toString(radix): 将数字转换为指定基数的字符串。

    let num: number = 123;
    console.log(num.toString(10)); // "123"
    console.log(num.toString(16)); // "7b" (16进制表示)
    

---

2. TypeScript String

字符串的创建：

let str1: string = 'Hello, world'; // 使用单引号
let str2: string = "Hello, world"; // 使用双引号
let str3: string = `Hello, 
world`; // 使用反引号创建多行模板字符串let name: string = 'world';
let str4: string = `Hello, ${name}`; // 模板字符串中嵌入表达式

---

常用的内置属性和方法：

1. length: 返回字符串长度。

   let str: string = "Hello, TypeScript!";
   console.log(str.length); // 18
   

2. charAt(index): 返回指定位置的字符。

   let str: string = "Hello, TypeScript!";
   console.log(str.charAt(0)); // 'H'
   

3. charCodeAt(index): 返回字符的 Unicode 编码。

   let str: string = "Hello, TypeScript!";
   console.log(str.charCodeAt(0)); // 72 ('H' 的 Unicode 编码)
   

4. concat(...strings): 连接两个或多个字符串。

   let str1: string = "Hello, ";
   let str2: string = "TypeScript!";
   console.log(str1.concat(str2)); // "Hello, TypeScript!"
   

5. indexOf(searchValue): 返回字符串中第一次出现的指定值的索引。

   let str: string = "Hello, TypeScript!";
   console.log(str.indexOf("Type")); // 7
   

6. slice(start, end): 提取子字符串。

   let str: string = "Hello, TypeScript!";
   console.log(str.slice(0, 5)); // "Hello"
   

7. substring(start, end): 提取子字符串（类似slice）。

   let str: string = "Hello, TypeScript!";
   console.log(str.substring(0, 5)); // "Hello"
   

8. toUpperCase(): 转换为大写。

   let str: string = "Hello, TypeScript!";
   console.log(str.toUpperCase()); // "HELLO, TYPESCRIPT!"
   

9. toLowerCase(): 转换为小写。

   let str: string = "Hello, TypeScript!";
   console.log(str.toLowerCase()); // "hello, typescript!"
   

---

3. TypeScript Array

数组的声明与使用：

let arr1: number[] = [1, 2, 3, 4, 5];
let arr2: Array<string> = ["a", "b", "c"];

---

常用的内置属性和方法：

1. length: 返回数组长度。

   let arr: number[] = [1, 2, 3, 4, 5];
   console.log(arr.length); // 5
   

2. push(item): 添加元素到数组末尾。

   let arr: number[] = [1, 2, 3];
   arr.push(4, 5);
   console.log(arr); // [1, 2, 3, 4, 5]
   

3. pop(): 移除并返回数组最后一个元素。

   let arr: number[] = [1, 2, 3, 4, 5];
   let lastElement = arr.pop();
   console.log(lastElement); // 5
   console.log(arr); // [1, 2,

3, 4]
```

4. shift(): 移除并返回数组第一个元素。

   let arr: number[] = [1, 2, 3, 4, 5];
   let firstElement = arr.shift();
   console.log(firstElement); // 1
   console.log(arr); // [2, 3, 4, 5]
   

5. unshift(item): 向数组开头添加一个或多个元素。

   let arr: number[] = [2, 3, 4, 5];
   arr.unshift(1);
   console.log(arr); // [1, 2, 3, 4, 5]
   

6. splice(start, deleteCount, ...items): 删除并添加新元素。

   let arr: number[] = [1, 2, 3, 4, 5];
   arr.splice(2, 1, 6, 7); // 删除索引2的1个元素，并插入6, 7
   console.log(arr); // [1, 2, 6, 7, 4, 5]
   

7. slice(start, end): 返回一个新数组，包含从 start 到 end（不包括 end）的元素。

   let arr: number[] = [1, 2, 3, 4, 5];
   let slicedArr = arr.slice(1, 3);
   console.log(slicedArr); // [2, 3]
   

8. forEach(callback): 对数组的每个元素执行给定函数。

   let arr: number[] = [1, 2, 3, 4, 5];
   arr.forEach((value, index) => {console.log(`Index: ${index}, Value: ${value}`);
   });
   

---

4. TypeScript Map

Map 用于存储键值对，其中键和值可以是任意类型。

let myMap = new Map<string, number>();
myMap.set("one", 1); // 添加键值对
myMap.set("two", 2);
console.log(myMap.get("one")); // 1

---

常用的内置属性和方法：

1. set(key, value): 添加键值对。

   myMap.set("three", 3);
   console.log(myMap); // Map { 'one' => 1, 'two' => 2, 'three' => 3 }
   

2. get(key): 获取键对应的值。

   console.log(myMap.get("two")); // 2
   

3. has(key): 检查是否存在指定键。

   console.log(myMap.has("one")); // true
   

4. delete(key): 删除指定键及其对应的值。

   myMap.delete("two");
   console.log(myMap); // Map { 'one' => 1, 'three' => 3 }
   

5. clear(): 清空所有键值对。

   myMap.clear();
   console.log(myMap); // Map {}
   

---

5. TypeScript Tuple（元组）

元组用于存储不同类型的固定数量的元素。

let tuple: [string, number, boolean] = ["Hello", 42, true];
console.log(tuple); // ["Hello", 42, true]

---

常用的内置方法：

1. push(...items): 添加一个或多个元素到元组末尾。

   tuple.push("World");
   console.log(tuple); // ["Hello", 42, true, "World"]
   

2. pop(): 移除并返回元组的最后一个元素。

   let lastElement = tuple.pop();
   console.log(lastElement); // "World"
   console.log(tuple); // ["Hello", 42, true]
   

3. concat(...tuples): 连接多个元组。

   let anotherTuple: [string, number] = ["TypeScript", 101];
   let combinedTuple = tuple.concat(anotherTuple);
   console.log(combinedTuple); // ["Hello", 42, true, "TypeScript", 101]
   

6.联合类型

联合类型（Union Types）允许一个变量拥有多个类型。

let value: string | number;value = "Hello";
console.log(value);  // 输出: Hellovalue = 42;
console.log(value);  // 输出: 42

还可以使用联合类型与函数：

function printValue(val: string | number): void {if (typeof val === "string") {console.log(`String value: ${val}`);} else {console.log(`Number value: ${val}`);}
}printValue("Hello");  // 输出: String value: Hello
printValue(123);      // 输出: Number value: 123

联合类型也可以用于数组：

let mixedArray: (string | number)[] = ["Alice", 25, "Bob", 30];
console.log(mixedArray);

学习总结

本次学习了TypeScript中的数据类型：数字、字符串、数组、Map对象、元组、联合类型。
其中需要特别注意：
1、Number 类型是基于 IEEE 754 双精度浮点数标准实现的。这意味着它不能精确表示所有的实数，特别是对于非常大或非常小的数，或者需要高精度的计算（如金融计算）时，可能会出现精度问题。
2、联合类型（Union Types）是指一个变量可以具有多种不同的类型。由于联合类型可以是多个类型的集合，因此直接使用联合类型的属性和方法需要确保这些属性和方法在所有可能的类型中都是共有的。