基本数据类型

let name: string = "Willow"
const age: number = 18

// TS 自动推断类型
let inferred = "hello"      // let inferred: string
const frozen = 42           // const frozen: 42  （字面量类型，详见下文）

let title: string = "Hello TypeScript"
let name = "Willow"                  // 推断为 string

// 模板字符串
let greeting = `Hello, ${name}!`      // "Hello, Willow!"
let multiline = `
  多行字符串
  支持换行和 ${name}
`

let age: number = 18
let price = 9.99                     // 推断为 number
let negative = -1
let nan = NaN                        // ✅ 合法的 number
let infinity = Infinity              // ✅ 合法的 number

let isDone: boolean = true
let hasError = false                // 推断为 boolean

let list: number[] = [1, 2, 3]
let names: Array<string> = ["Willow", "Ash"]  // 泛型写法

// 自动推断联合类型
let mixed = [1, "hello"]           // (string | number)[]

let readonlyList: ReadonlyArray<number> = [1, 2, 3]
// readonlyList.push(4)            // ❌ error
// readonlyList[0] = 0             // ❌ error

let roList: readonly number[] = [1, 2, 3]

let tuple: [string, number] = ["hello", 42]
// tuple = [42, "hello"]   // ❌ 类型不匹配

let opt: [string, number?] = ["hello"]          // ✅ 第二个元素可省略
opt = ["hello", 42]                              // ✅

let http: [status: number, body: string] = [200, "OK"]
// 在编辑器中会显示 status / body 标签，但运行时仍是数字索引

let rest: [string, ...number[]] = ["hello", 1, 2, 3]
let labels: [number, ...string[]] = [1, "a", "b", "c"]

enum Direction {
    Up,       // 0
    Down,     // 1
    Left,     // 2
    Right     // 3
}

enum Status {
    Active = 1,
    Inactive,   // 2
    Pending     // 3
}

enum Flags {
    A = 1,
    B = 2,
    C = 4,
    D = 8
}

enum Direction {
    Up = "UP",
    Down = "DOWN",
    Left = "LEFT",
    Right = "RIGHT"
}

enum Mixed {
    No = 0,
    Yes = "YES"
}

enum Color {
    Red,     // 0
    Green,   // 1
    Blue     // 2
}

console.log(Color.Red)      // 0
console.log(Color[0])       // "Red"  ✅ 反向映射

const enum Animal {
    Cat,
    Dog
}

let pet = Animal.Cat         // 编译后: let pet = 0

// 源码
enum Color { Red, Green, Blue }

// 编译后（ES5）
var Color;
(function (Color) {
    Color[Color["Red"] = 0] = "Red";
    Color[Color["Green"] = 1] = "Green";
    Color[Color["Blue"] = 2] = "Blue";
})(Color || (Color = {}));

// enum 方式
enum Direction {
    Up = "UP",
    Down = "DOWN"
}
function move(dir: Direction) { /* ... */ }
move(Direction.Up)

// as const + union 方式（零 JS 开销）
const DIRECTIONS = ["UP", "DOWN"] as const
type Direction = (typeof DIRECTIONS)[number]  // "UP" | "DOWN"
function move(dir: Direction) { /* ... */ }
move("UP")

const s1: symbol = Symbol("desc")
const s2: symbol = Symbol("desc")
// s1 !== s2  ✅ 每次调用都创建新的唯一符号

const ID: unique symbol = Symbol("id")
// 可以直接用作类型注解
let id: typeof ID

const STATUS: unique symbol = Symbol("status")

let obj = {
    [STATUS]: "active",
    status: "inactive"       // 与上面的属性完全独立，不会冲突
}
console.log(obj[STATUS])     // "active"
console.log(obj.status)      // "inactive"

const big: bigint = 9007199254740991n
const big2: bigint = BigInt(100)
const huge = 123456789012345678901234567890n  // 推断为 bigint

let user: { name: string; age: number } = {
    name: "Willow",
    age: 18
}

let user: {
    name: string
    age: number
    email?: string       // 可选，可以不传
} = { name: "Willow", age: 18 }

let config: {
    readonly host: string
    port: number
} = { host: "localhost", port: 8080 }
// config.host = "other"   // ❌ 只读属性不可修改

let dict: { [key: string]: string } = {
    name: "Willow",
    city: "Beijing"
}

// 只限制值类型，键名可以任意添加
dict.country = "China"   // ✅

let anything: any = "hello"
anything = 42                     // ✅ 不报错
anything.foo.bar()                // ✅ 不报错，但运行时可能崩溃
anything()                        // ✅ 不报错，但运行时可能崩溃

// 开启 noImplicitAny 后 ❌
// function log(msg) {           // 报错：参数隐式 any
//     console.log(msg)
// }

function log(msg: string) {     // ✅ 显式注解
    console.log(msg)
}

let value: unknown = "hello"

// let str: string = value         // ❌ unknown 不能直接赋给其他类型
// value.toUpperCase()             // ❌ 不能直接调用方法

// 必须收窄后才能使用
if (typeof value === "string") {
    let str: string = value        // ✅ 类型已收窄为 string
    console.log(value.toUpperCase())
}

let data: unknown = { name: "Willow" }
let name = (data as { name: string }).name

let u: undefined = undefined
let n: null = null

// let str: string = null        // ❌ strictNullChecks 下报错
// let num: number = undefined   // ❌ strictNullChecks 下报错

let name: string | null = null   // ✅ 允许 null
let age: string | undefined = undefined  // ✅ 允许 undefined

function log(msg: string): void {
    console.log(msg)
    // 没有 return 语句
}

function greet(name: string): void {
    console.log("Hello, " + name)
    return        // ✅ 空 return 也合法
}

let unusable: void = undefined
// let x: void = null   // ❌ strictNullChecks 下报错

function throwError(message: string): never {
    throw new Error(message)
}

function infiniteLoop(): never {
    while (true) { /* ... */ }
}

type Shape =
    | { kind: "circle"; radius: number }
    | { kind: "square"; side: number }

function area(s: Shape): number {
    switch (s.kind) {
        case "circle": return Math.PI * s.radius ** 2
        case "square": return s.side ** 2
        default:
            // 如果未来新增了 Shape 变体但忘记处理，
            // 这里会编译报错，因为 s 不能赋给 never
            const _exhaustive: never = s
            return _exhaustive
    }
}

let direction: "left" = "left"
// direction = "right"     // ❌ 只能是 "left"

const name = "Willow"          // const name: "Willow"  （字面量）
let nickname = "Willow"        // let nickname: string    （宽泛）

let one: 1 = 1
// one = 2                    // ❌ 只能是 1

let isTrue: true = true
// isTrue = false             // ❌ 只能是 true

type Direction = "up" | "down" | "left" | "right"
type DiceRoll = 1 | 2 | 3 | 4 | 5 | 6
type Response = { status: "ok"; data: unknown } | { status: "error"; message: string }

function move(dir: Direction) { /* ... */ }
move("up")       // ✅
// move("north") // ❌ 不在联合中