基本类型
TypeScript 支持 JavaScript 的基本类型，包括：
number：数字类型
string：字符串类型
boolean：布尔类型
null：null 类型
undefined：undefined 类型
您可以使用这些类型定义变量和函数参数，例如：
let age: number = 25;
let name: string = "John";
let isStudent: boolean = true;
function sayHello(name: string): void {
console.log(`Hello, ${
name}!`);
}
注意，void 类型表示函数不返回任何值。
数组
TypeScript 支持定义数组类型，例如：
let numbers: number[] = [1, 2, 3, 4, 5];
let names: string[] = ["John", "Mary", "David"];
您也可以使用 Array 表示数组类型：
let numbers: Array<number> = [1, 2, 3, 4, 5];
let names: Array<string> = ["John", "Mary", "David"];
元组
元组是一种包含固定数量元素的数组类型，每个元素可以有不同的类型。例如：
let person: [string, number] = ["John", 25];
这里的 person 是一个包含两个元素的元组，第一个元素是字符串类型，第二个元素是数字类型。
对象
您可以使用接口（interface）定义对象类型，例如：
interface Person {
name: string;
age: number;
}
let john: Person = {
name: "John",
age: 25
};
这里的 Person 接口定义了一个对象类型，包含两个属性，name 和 age。
类
TypeScript 支持面向对象编程，可以使用类（class）定义对象。例如：
class Person {
name: string;
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
sayHello(): void {
console.log(`Hello, my name is ${
this.name}, I'm ${
this.age} years old.`);
}
}
let john: Person = new Person("John", 25);
john.sayHello();
这里的 Person 类定义了一个对象类型，包含 name 和 age 两个属性，以及 sayHello 方法。
继承
TypeScript 支持类的继承，可以使用 extends 关键字继承一个父类。例如：
class Student extends Person {
grade: number;
constructor(name: string, age: number, grade: number) {
super(name, age);
this.grade = grade;
}
sayHello(): void {
console.log(`Hello, my name is ${
this.name}, I'm a student in grade ${
this.grade}.`);
}
}
let mary: Student = new Student("Mary", 20, 11);
mary.sayHello();
这里的 Student 类继承了 Person 类，并添加了 grade 属性和重新定义sayHello 方法。
泛型
TypeScript 支持泛型，可以在定义函数和类时使用泛型。例如：
function identity<T>(arg: T): T {
return arg;
}
let output1 = identity<string>("Hello");
let output2 = identity<number>(123);
这里的 identity 函数使用了一个泛型类型 T，它可以接受任意类型的参数，并返回相同类型的结果。使用时，可以明确指定泛型类型，也可以让 TypeScript 推断出类型。
class Box<T> {
value: T;
constructor(value: T) {
this.value = value;
}
getValue(): T {
return this.value;
}
}
let box1 = new Box<string>("Hello");
let box2 = new Box<number>(123);
这里的 Box 类使用了一个泛型类型 T，它可以接受任意类型的值，并保存到 value 属性中，getValue 方法返回 value 属性的值。使用时，可以明确指定泛型类型，也可以让 TypeScript 推断出类型。
接口
接口（interface）是定义对象类型的一种方式，可以定义对象的属性和方法。例如：
interface Person {
name: string;
age: number;
sayHello(): void;
}
class Student implements Person {
name: string;
age: number;
grade: number;
constructor(name: string, age: number, grade: number) {
this.name = name;
this.age = age;
this.grade = grade;
}
sayHello(): void {
console.log(`Hello, my name is ${
this.name}, I'm a student in grade ${
this.grade}.`);
}
}
let john: Person = new Student("John", 25, 11);
john.sayHello();
这里的 Person 接口定义了一个对象类型，包含 name 和 age 属性以及 sayHello 方法，Student 类实现了 Person 接口，定义了 grade 属性和重新定义了 sayHello 方法。
类型别名
类型别名（type alias）是给类型起一个别名，方便复用和阅读。例如：
type Point = {
x: number;
y: number;
};
function distance(p1: Point, p2: Point): number {
let dx = p1.x - p2.x;
let dy = p1.y - p2.y;
return Math.sqrt(dx * dx + dy * dy);
}
let p1: Point = {
x: 0, y: 0 };
let p2: Point = {
x: 3, y: 4 };
console.log(distance(p1, p2));
这里的 Point 是一个类型别名，定义了一个包含 x 和 y 属性的对象类型，distance 函数接受两个 Point 类型的参数，返回它们之间的距离。
枚举
枚举（enum）是一种定义常量的方式，可以使用枚举类型表示一组有限的取值。例如：
enum Color {
Red,
Green,
Blue
}
let c: Color
c = Color.Green;
console.log(c); // 输出 1
enum Direction {
Up = "UP",
Down = "DOWN",
Left = "LEFT",
Right = "RIGHT"
}
function move(direction: Direction): void {
console.log(Move ${
direction});
}
move(Direction.Up); // 输出 "Move UP"
这里的 Color 枚举定义了三个常量 Red、Green 和 Blue，它们的值分别为 0、1 和 2。Direction 枚举定义了四个常量，并且给每个常量指定了字符串值。move 函数接受一个 Direction 类型的参数，并输出一个字符串。
命名空间
命名空间（namespace）是一种将全局变量和函数组织在一个容器中的方式，避免命名冲突。例如：
namespace MyMath {
export const PI = 3.14;
export function add(x: number, y: number): number {
return x + y;
}
export function substract(x: number, y: number): number {
return x - y;
}
}
console.log(MyMath.PI); // 输出 3.14
console.log(MyMath.add(1, 2)); // 输出 3
console.log(MyMath.substract(3, 2)); // 输出 1
这里的 MyMath 是一个命名空间，包含了常量 PI 和函数 add、substract，可以通过 MyMath. 的方式访问它们。
模块
模块（module）是一种将代码分割成可重用的单元的方式，与命名空间类似，但模块可以被导入和导出，实现了更灵活的代码组织和复用。例如：
// lib/math.ts
export const PI = 3.14;
export function add(x: number, y: number): number {
return x + y;
}
export function substract(x: number, y: number): number {
return x - y;
}
// main.ts
import {
PI, add } from "./lib/math";
console.log(PI); // 输出 3.14
console.log(add(1, 2)); // 输出 3
这里的 math.ts 模块导出了常量 PI 和函数 add、substract，可以通过 export 关键字导出。main.ts 模块通过 import 关键字导入了 PI 和 add，可以直接使用它们。