正在加载文档...
文档内容较大，正在处理中，请稍候
正在加载文档...
文档内容较大，正在处理中，请稍候
常用的类型有：
当未定义具体类型时，TypeScript 会根据上下文自动推断类型。
let a = 10;
// a 的类型被推断为 number后续可以执行
a = 20;
// a 的类型被推断为 number当需要指定变量的类型时，使用类型注解。
let b: number = 10;
// b 被注解为 number 类型后续只能执行
b = 20;
// b 被注解为 number 类型当需要手动指定变量的类型时，使用类型断言。
let c = 10;
// c 的类型被推断为 number
let d = c as number;
// d 被断言为 number 类型当变量可以是多个类型中的一种时，使用联合类型。
let e: number | string = 10;
// e 可以是 number 或 string 类型
e = "hello";
// e 现在是 string 类型typeof 类型守卫 instanceof 类型守卫 自定义类型守卫
当使用联合类型时，需要使用类型守卫来判断具体的类型。
function isNumber(x: number | string): x is number {
return typeof x === "number";
}? 可选类型参数(必须在必选参数后面，一般在尾部使用)
interface User {
id: number;
name: string;
email?: string; // 可选属性
}
const user1: User = { id: 1, name: "Alice" }; // 正确：email 未提供
const user2: User = { id: 2, name: "Bob", email: "bob@example.com" }; // 正确function greet(name: string, salutation?: string) {
const greeting = salutation || "Hello";
return `${greeting}, ${name}!`;
}
greet("Alice"); // 正确
greet("Bob", "Hi"); // 正确数组是一种特殊的对象，用于存储多个值。
let f: number[] = [1, 2, 3];
// f 被注解为 number 数组类型
let g: Array<number> = [4, 5, 6];
// g 被注解为 number 数组类型
let h: string[] = ["a", "b", "c"];
// h 被注解为 string 数组类型
let i: boolean[] = [true, false, true];
// i 被注解为 boolean 数组类型T[] 表示泛型数组，T 是数组元素的类型。
元组是一种特殊的数组，用于存储多个不同类型的值。
let h: [number, string, boolean] = [10, "hello", true];
// h 被注解为 number, string, boolean 元组类型枚举是一种特殊的类型，用于定义命名的常量集合。
enum Color {
Red,
Green,
Blue,
}
let i: Color = Color.Green;
// i 被注解为 Color 枚举类型
// 枚举默认从 0 开始编号
console.log(Color.Red); // 0
console.log(Color.Green); // 1
console.log(Color.Blue); // 2
console.log(Color[0]); // "Red"
console.log(Color[1]); // "Green"
console.log(Color[2]); // "Blue"字符串是一种特殊的类型，用于存储文本。
let j: string = "hello";
// j 被注解为 string 类型数字是一种特殊的类型，用于存储数值。
let k: number = 10;
// k 被注解为 number 类型布尔值是一种特殊的类型，用于存储 true 或 false。
let l: boolean = true;
// l 被注解为 boolean 类型null 和 undefined 是特殊的类型，分别表示空值和未定义。
let m: null = null;
// m 被注解为 null 类型
let n: undefined = undefined;
// n 被注解为 undefined 类型对象是一种特殊的类型，用于存储多个属性。
let o: object = { id: 1, name: "Alice" };
// o 被注解为 object 类型void 类型表示没有任何类型，通常用于函数没有返回值的情况。
function logMessage(message: string): void {
console.log(message);
}any 类型表示任意类型，通常用于在不确定类型的情况下使用。
let p: any = 10;
// p 被注解为 any 类型
p = "hello";
// p 现在是 string 类型函数类型用于描述函数的参数和返回值类型。
function add(a: number, b: number): 返回值 {
return a + b;
}接口interface是一种特殊的类型，用于定义对象的形状。
interface User {
id: number;
name: string;
email?: string; // 可选属性
}type 类型别名用于为类型定义一个新的名称。
type Point = {
x: number;
y: number;
};
let p: Point = { x: 10, y: 20 };
// p 被注解为 Point 类型泛型是一种特殊的类型，用于定义可以在多个类型上工作的组件。
function identity<T>(arg: T): T {
return arg;
}
let output1 = identity<string>("myString"); // output1 的类型为 string
let output2 = identity<number>(100); // output2 的类型为 number接口可以继承其他接口，从而扩展其属性。
interface Person {
name: string;
age: number;
}
interface Student extends Person {
studentId: number;
}
let student: Student = {
name: "Alice",
age: 18,
studentId: 1001,
};type 和 interface 都可以用于定义对象的形状，但是它们有一些区别。
type 可以定义基本类型、联合类型、元组类型等，而 interface 只能定义对象类型。
type 可以使用交叉类型（&）合并多个类型，而 interface 只能使用 extends 继承。
type 可以使用 typeof 操作符获取变量的类型，而 interface 不能直接获取。
默认情况下，类的属性和方法都是 public 的。
修饰符：
public：公共的，任何地方都可以访问。
private：私有的，只能在类的内部访问。
protected：受保护的，只能在类的内部和子类中访问。
static：静态的，属于类而不是实例。
readonly：只读的，只能在类的内部初始化，不能在外部修改。
访问器：
get 访问器用于获取属性的值，set 访问器用于设置属性的值。
类是一种特殊的类型，用于创建对象的蓝图。
class Person {
name: string;
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
greet() {
console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
}
}
let person1 = new Person("Alice", 18);
person1.greet(); // 输出：Hello, my name is Alice and I am 18 years old.class Person {
public name: string;
public age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
greet() {
console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
}
}class Person {
private name: string;
private age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
greet() {
console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
}
}class Person {
protected name: string;
protected age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
greet() {
console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
}
}
class Student extends Person {
studentId: number;
constructor(name: string, age: number, studentId: number) {
super(name, age);
this.studentId = studentId;
}
greet() {
console.log(
`Hello, my name is ${this.name} and I am ${this.age} years old. My student ID is ${this.studentId}.`
);
}
}class MathUtils {
static PI: number = 3.14159;
static add(a: number, b: number): number {
return a + b;
}
}
console.log(MathUtils.PI); // 输出：3.14159
console.log(MathUtils.add(2, 3)); // 输出：5class Person {
readonly name: string;
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
greet() {
console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
}
}
let person1 = new Person("Alice", 18);
person1.greet(); // 输出：Hello, my name is Alice and I am 18 years old.
// person1.name = "Bob"; // 错误：name 是只读的get 访问器用于获取属性的值，set 访问器用于设置属性的值。
class Person {
private _name: string;
constructor(name: string) {
this._name = name;
}
get name(): string {
return this._name;
}
set name(newName: string) {
this._name = newName;
}
}
let person1 = new Person("Alice");
console.log(person1.name); // 输出：Alice
person1.name = "Bob";
console.log(person1.name); // 输出：Bob抽象类是一种特殊的类，不能被实例化，只能被继承。
abstract class Animal {
abstract makeSound(): void;
}
class Dog extends Animal {
makeSound() {
console.log("Woof!");
}
}implements 可以实现多个接口。
interface Animal {
name: string;
age: number;
makeSound(): void;
}
class Dog implements Animal {
name: string;
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
makeSound() {
console.log("Woof!");
}
}class Box<T> {
value: T;
constructor(value: T) {
this.value = value;
}
}