TypeScript 5.3 来了，一大波新特性

// 希望将这个文件解释为 JSON 数据，而不是一个带有 .json 扩展名的可执行/恶意的 JavaScript 文件。
import obj from "./something.json" with { type: "json" };

// TypeScript 对此没有问题，但是浏览器可能不支持。
import * as foo from "./foo.js" with { type: "fluffy bunny" };

const obj = await import("./something.json", {
    with: { type: "json" }
});

/// <reference types="pkg" resolution-mode="require" />

// 或

/// <reference types="pkg" resolution-mode="import" />

// 以使用 `require()` 进行导入的方式解析 `pkg`
import type { TypeFromRequire } from "pkg" with {
  "resolution-mode": "require"
};

// 以使用 `import` 进行导入的方式解析 `pkg`
import type { TypeFromImport } from "pkg" with {
  "resolution-mode": "import"
};

export interface MergedType extends TypeFromRequire, TypeFromImport {}

export type TypeFromRequire =
  import("pkg", { with: { "resolution-mode": "require" } }).TypeFromRequire;

export type TypeFromImport =
  import("pkg", { with: { "resolution-mode": "import" } }).TypeFromImport;

export interface MergedType extends TypeFromRequire, TypeFromImport {}

function f(x: unknown) {
    switch (true) {
        case typeof x === "string":
            // 这里，'x' 是一个 'string'
            console.log(x.toUpperCase());

        case Array.isArray(x):
            // 这里 'x' 是一个 'string | any[]'
            console.log(x.length);

        default:
          // 这里 'x' 是 'unknown'
          // ...
    }
}

interface A {
    a: string;
}

interface B {
    b: string;
}

type MyType = A | B;

function isA(x: MyType): x is A {
    return "a" in x;
}

function someFn(x: MyType) {
    if (isA(x) === true) {
        console.log(x.a); // works!
    }
}

class Weirdo {
    static [Symbol.hasInstance](testedValue) {
        return testedValue === undefined;
    }
}

// false
console.log(new Thing() instanceof Weirdo);

// true
console.log(undefined instanceof Weirdo);

interface PointLike {
    x: number;
    y: number;
}

class Point implements PointLike {
    x: number;
    y: number;

    constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
    }

    distanceFromOrigin() {
        return Math.sqrt(this.x ** 2 + this.y ** 2);
    }

    static [Symbol.hasInstance](val: unknown): val is PointLike {
        return !!val && typeof val === "object" &&
            "x" in val && "y" in val &&
            typeof val.x === "number" &&
            typeof val.y === "number";
    }
}


function f(value: unknown) {
    if (value instanceof Point) {
        // 可以访问这两个属性 - 正确！
        value.x;
        value.y;

        // 无法访问这个属性，有 'PointLike' 类型的对象，但实际上并没有 'Point' 类型的对象。
        value.distanceFromOrigin();
    }
}

class Base {
    someMethod() {
        console.log("Base method called!");
    }
}

class Derived extends Base {
    someMethod() {
        console.log("Derived method called!");
        super.someMethod();
    }
}

new Derived().someMethod();

// 输出结果：
//   Derived method called!
//   Base method called!

class Base {
    someMethod() {
        console.log("someMethod called!");
    }
}

class Derived extends Base {
    someOtherMethod() {
        // These act identically.
        this.someMethod();
        super.someMethod();
    }
}

new Derived().someOtherMethod();

// 输出结果：
//   someMethod called!
//   someMethod called!

class Base {
    someMethod = () => {
        console.log("someMethod called!");
    }
}

class Derived extends Base {
    someOtherMethod() {
        super.someMethod();
    }
}

new Derived().someOtherMethod();