TypeScript 基础语法

1. 基础类型

1.1 原始类型

// 布尔值
let isActive: boolean = true;
let isCompleted: boolean = false;

// 数字（支持十进制、十六进制、二进制等）
let decimal: number = 42;
let hex: number = 0x2a;      // 十六进制
let binary: number = 0b1010; // 二进制

// 字符串
let framework: string = "TypeScript";
let version: string = `4.0`;  // 模板字符串
let greeting = `Hello ${framework} v${version}`;

1.2 复合类型

// 数组（两种声明方式）
let numbers: number[] = [1, 2, 3];
let strings: Array<string> = ["a", "b", "c"];

// 元组（固定长度和类型）
let userInfo: [string, number] = ["Alice", 28];
let rgb: [number, number, number] = [255, 0, 100];

1.3 特殊类型

// 枚举（默认从0开始）
enum Direction { Up, Down, Left, Right }
let move: Direction = Direction.Up;

// Any（动态类型，慎用）
let dynamicData: any = "可以是任意类型";
dynamicData = 42;
dynamicData = true;

// Void（无返回值）
function logMessage(): void {
  console.log("This function returns nothing");
}

// Never（永不返回）
function throwError(message: string): never {
  throw new Error(message);
}

2. 变量声明

2.1 基本声明

// let（块级作用域）
let counter: number = 0;
counter = 1; // 允许重新赋值

// const（常量）
const MAX_USERS: number = 100;
// MAX_USERS = 200; // 报错：不能重新赋值

// 类型推断
let inferredString = "自动推断为string类型";
let inferredNumber = 3.14; // 自动推断为number

2.2 解构赋值

// 数组解构
let [first, second, ...rest] = [1, 2, 3, 4];
console.log(rest); // 输出: [3, 4]

// 对象解构（带类型注解）
let { 
  username, 
  age 
}: { 
  username: string; 
  age: number 
} = { username: "Bob", age: 30 };

// 重命名解构
let { name: fullName, email: contact } = { 
  name: "Alice", 
  email: "alice@example.com" 
};

3. 接口

3.1 基本接口

interface User {
  readonly id: number;   // 只读属性
  name: string;
  age?: number;         // 可选属性
  [prop: string]: any;  // 任意属性
}

// 使用接口
function printUser(user: User) {
  console.log(`ID: ${user.id}, Name: ${user.name}`);
}

let currentUser: User = {
  id: 1,
  name: "Alice",
  gender: "female" // 任意属性
};

3.2 函数类型接口

interface SearchFunc {
  (source: string, keyword: string): boolean;
}

let mySearch: SearchFunc = function(src, kw) {
  return src.includes(kw);
};

4.类

4.1 基础类

class Animal {
  private name: string;  // 私有属性
  
  constructor(name: string) {
    this.name = name;
  }

  public move(distance: number = 0) {
    console.log(`${this.name} moved ${distance}m`);
  }
}

class Dog extends Animal {
  bark() {
    console.log("Woof! Woof!");
  }
}

const dog = new Dog("Buddy");
dog.bark();
dog.move(10);

4.1 访问器与静态属性

class Employee {
  private _fullName: string;
  static company = "ACME";

  get fullName(): string {
    return this._fullName;
  }

  set fullName(name: string) {
    this._fullName = name;
  }
}

let emp = new Employee();
emp.fullName = "John Doe";
console.log(Employee.company); // 静态属性

5.函数

5.1 函数类型

// 完整函数类型
let add: (x: number, y: number) => number;

add = function(a, b) {
  return a + b;
};

// 可选参数与默认值
function buildName(
  firstName: string,
  lastName?: string = "Smith"
): string {
  return `${firstName} ${lastName}`;
}

5.2 剩余参数

function sum(...numbers: number[]): number {
  return numbers.reduce((a, b) => a + b, 0);
}

console.log(sum(1, 2, 3)); // 输出: 6

6. 泛型

6.1 基础泛型

function identity<T>(arg: T): T {
  return arg;
}

let output = identity<string>("TypeScript");

// 泛型接口
interface GenericArray<T> {
  [index: number]: T;
}

let numArray: GenericArray<number> = [1, 2, 3];

6.2 泛型约束

interface Lengthwise {
  length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length);
  return arg;
}

loggingIdentity("hello"); // 输出: 5

7. 类型推断与断言

7.1 类型推断

let x = 3;            // 推断为number
let y = [0, 1, null]; // 推断为(number | null)[]

7.2 类型断言

let someValue: any = "this is a string";

// 两种语法
let strLength1: number = (<string>someValue).length;
let strLength2: number = (someValue as string).length;

8. 模块系统

8.1 导出与导入

// math.ts
export function square(x: number): number {
  return x * x;
}

// app.ts
import { square } from './math';
console.log(square(2)); // 输出: 4

8.2 默认导出

// logger.ts
export default class Logger {
  log(message: string) {
    console.log(message);
  }
}

// app.ts
import MyLogger from './logger';
const logger = new MyLogger();

9. 进阶特性

9.1 类型别名

type StringOrNumber = string | number;
type Callback = (data: string) => void;

9.2 交叉类型

interface A { a: number }
interface B { b: string }
type C = A & B;

let obj: C = { a: 1, b: "hello" };

9.3 装饰器（实验性）

function sealed(constructor: Function) {
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

@sealed
class Greeter {
  greeting: string;
  constructor(message: string) {
    this.greeting = message;
  }
}