15个Typescript 5.0 中重要的新功能快速了解一下

function log<This, Args extends any[], Return>(
  target: (this: This, ...args: Args) => Return,
  context: ClassMethodDecoratorContext<
    This,
    (this: This, ...args: Args) => Return
  >
) {
  const methodName = String(context.name);


  function replacementMethod(this: This, ...args: Args): Return {
    console.log(`LOG: Entering method '${methodName}'.`);
    const result = target.call(this, ...args);
    console.log(`LOG: Exiting method '${methodName}'.`);
    return result;
  }


  return replacementMethod;
}


class Calculator {
  @log
  add(a: number, b: number): number {
    return a + b;
  }
}


const calculator = new Calculator();
console.log(calculator.add(2, 3)); 
// "LOG: Entering method 'add'." 
// "LOG: Exiting method 'add'." 
// 5

// string[]
const a = ["Alice", "Bob", "Eve"]


// readonly ["Alice", "Bob", "Eve"]
const b = ["Alice", "Bob", "Eve"] as const

declare function fnGood<const T extends readonly string[]>(args: T): void;


// T is readonly ["a", "b", "c"]
fnGood(["a", "b" ,"c"]);

declare function fnGood<const T extends readonly string[]>(args: T): void;
const arr = ["a", "b" ,"c"];


// 'T' is still 'string[]'-- the 'const' modifier has no effect here
fnGood(arr);

{
  "extends": ["./config/base", "./config/jest"],
  "compilerOptions": {
    "target": "esnext",
    "module": "commonjs",
    "strict": true
  }
}

enum E {
  A = 10 * 10, // Numeric literal enum member
  B = 'foo', // String literal enum member
  C = Math.random(), // Opaque computed enum member
}


function getStringValue(e: E): string {
  return String(e);
}


const val = getStringValue(E.A); // "100"

{
  "compilerOptions": {
    "moduleResolution": "bundler"
  }
}

// Erased away entirely.
import type { A } from "a";


// Rewritten to 'import { b } from "bcd";'
import { b, type c, type d } from "bcd";


// Rewritten to 'import {} from "xyz";'
import { type xyz } from "xyz";

{
  "compilerOptions": {
    "verbatimModuleSyntax": true
  }
}

// types.ts
export type { Foo } from './foo';
export type { Bar } from './bar';


// index.ts
export type * from './types';
// Also support
export type * as Types from './types';

// interface Greeter {
//   greet(name: string): number;
// }


/**
 * @typedef {Function} Greeter
 * @param {string} name
 * @returns {string}
 */


/**
 * @satisfies {Greeter}
 */
function greeter(name: string) {
  return `Hello, ${name}!`;
}

/**
 * @overload
 * @param {string} a
 * @param {string} b
 * @return {string}
 */


/**
 * @overload
 * @param {number} a
 * @param {number} b
 * @return {number}
 */


/**
 * @param {string | number} a
 * @param {string | number} b
 */
export function add(a, b) {
  if (typeof a === 'number' && typeof b === 'number') {
    return a + b;
  } else if (typeof a === 'string' && typeof b === 'string') {
    return a.concat(b);
  }
}


const numResult = add(1, 2); // 3
const strResult = add('hello', 'world'); // "helloworld"
const errResult = add('hello', 123); // Error: No overload matches this call.

type Animal = "cat" | "dog" | "fish";


function speak(animal: Animal): string {
  switch (animal) {
    // TypeScript 5.0 will suggest all possible cases: "cat", "dog", "fish"
  }
}

function func1(ns: number | string) {
  return ns * 4; // Error, possible implicit coercion
}


function func2(ns: number | string) {
  return ns > 4; // Error, possible implicit coercion
}


function func3(ns: number | string) {
  return +ns > 4; // OK
}

// Part1: Assigning an out-of-domain literal to an enum type 
// now errors out as one would expect.
enum SomeEvenDigit {
  Zero = 0,
  Two = 2,
  Four = 4,
}


// Now correctly an error
let m: SomeEvenDigit = 1;


// Part2: Enums declaring values with mixed numeric and 
// indirect string enum references incorrectly create an all-numeric enum.
enum Letters {
  A = 'a',
}
enum Numbers {
  one = 1,
  two = Letters.A,
}


// Now correctly an error
const t: number = Numbers.two;