Hướng dẫn how typescript disinfect html? - cách loại bỏ tập lệnh html?

Trang tổng quan này chứa một phiên bản rút ngắn của tất cả các ghi chú phát hành cho TypeScript. Bởi vì trang này rất lớn. Các mẫu mã có các yếu tố tương tác của chúng bị vô hiệu hóa.

TypeScript 4.2

Bảo quản bí danh loại thông minh hơn

TypeScript có một cách để khai báo tên mới cho các loại gọi là bí danh loại. Nếu bạn viết một tập hợp các chức năng mà tất cả hoạt động trên

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
type BasicPrimitive = number | string | boolean;

Trong TypeScript 4.2, nội bộ của chúng tôi thông minh hơn một chút. Chúng tôi theo dõi cách các loại được xây dựng bằng cách giữ xung quanh các phần của cách chúng được viết và xây dựng ban đầu theo thời gian. Chúng tôi cũng theo dõi và phân biệt các bí danh loại vào các trường hợp của các bí danh khác!

Có thể in lại các loại dựa trên cách bạn đã sử dụng chúng trong mã của mình có nghĩa là với tư cách là người dùng TypeScript, bạn có thể tránh được một số loại không may được hiển thị và điều đó thường chuyển sang nhận ra đầu ra tệp

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Để biết thêm thông tin, hãy xem yêu cầu kéo đầu tiên cải thiện các trường hợp khác nhau xung quanh việc bảo tồn bí danh loại liên minh, cùng với yêu cầu kéo thứ hai bảo tồn bí danh gián tiếp.

Các yếu tố nghỉ ngơi hàng đầu/giữa trong các loại tuple

Trong TypeScript, các loại tuple có nghĩa là để mô hình các mảng với độ dài và loại phần tử cụ thể.

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

Trong TypeScript 4.2, các phần tử REST được mở rộng cụ thể trong cách chúng có thể được sử dụng. Trong các phiên bản trước, TypeScript chỉ cho phép các phần tử

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Tuy nhiên, bây giờ các yếu tố REST có thể xảy ra ở bất cứ đâu trong một tuple - chỉ với một vài hạn chế.

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

Mặc dù JavaScript không có bất kỳ cú pháp nào để mô hình các tham số REST hàng đầu, chúng tôi vẫn có thể khai báo

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Để biết thêm chi tiết, xem yêu cầu kéo ban đầu.

Kiểm tra chặt chẽ hơn cho nhà điều hành tsinterface SomeType { /** This is an index signature. */ [propName: string]: any;}function doStuff(value: SomeType) { let x = value["someProperty"];}23

Trong JavaScript, đó là một lỗi thời gian chạy để sử dụng loại không phải đối tượng ở bên phải của toán tử

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// @errors: 2361
"foo" in 42;

Kiểm tra này khá bảo thủ đối với hầu hết các phần, vì vậy nếu bạn đã nhận được một lỗi về điều này, thì đó có thể là một vấn đề trong mã.

Một lời cảm ơn lớn đến người đóng góp bên ngoài của chúng tôi Jonas Hzigter vì yêu cầu kéo của họ!

tsinterface SomeType { /** This is an index signature. */ [propName: string]: any;}function doStuff(value: SomeType) { let x = value["someProperty"];}25

Quay lại khi TypeScript lần đầu tiên giới thiệu chữ ký chỉ mục, bạn chỉ có thể nhận được các thuộc tính được khai báo bởi chúng với cú pháp truy cập phần tử của phần tử có giá đỡ như

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Điều này cuối cùng trở nên cồng kềnh trong các tình huống mà chúng ta cần làm việc với các đối tượng có tính chất tùy ý. Ví dụ, hãy tưởng tượng một API trong đó nó phổ biến để viết sai một tên thuộc tính bằng cách thêm một ký tự

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

Để làm cho các loại tình huống này dễ dàng hơn, một thời gian trở lại, TypeScript có thể sử dụng cú pháp truy cập thuộc tính của Toted dotted, như

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Trong một số trường hợp, người dùng muốn chọn lọc một cách rõ ràng vào chữ ký chỉ mục - họ muốn nhận được thông báo lỗi khi truy cập thuộc tính chấm chấm không tương ứng với một khai báo thuộc tính cụ thể.

Đó là lý do tại sao TypeScript giới thiệu một lá cờ mới gọi là

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Bạn có thể hiểu tính năng này chi tiết hơn bằng cách đọc theo yêu cầu kéo tương ứng. Chúng tôi cũng muốn gửi lời cảm ơn lớn đến Wenlu Wang, người đã gửi cho chúng tôi yêu cầu kéo này!

tsinterface SomeType { /** This is an index signature. */ [propName: string]: any;}function doStuff(value: SomeType) { let x = value["someProperty"];}31 Xây dựng chữ ký

TypeScript cho phép chúng tôi đánh dấu một lớp là trừu tượng. Điều này nói với TypeScript rằng lớp chỉ có nghĩa là được mở rộng từ đó và một số thành viên nhất định cần được điền bởi bất kỳ lớp con nào để thực sự tạo ra một thể hiện.

TypeScript 4.2 cho phép bạn chỉ định công cụ sửa đổi

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
abstract class Shape {
  abstract getArea(): number;
}
// ---cut---
interface HasArea {
    getArea(): number;
}
// Works!
let Ctor: abstract new () => HasArea = Shape;

Thêm công cụ sửa đổi

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Tính năng này cho phép chúng tôi viết các nhà máy mixin theo cách hỗ trợ các lớp trừu tượng. Ví dụ: trong đoạn mã sau, chúng tôi có thể sử dụng hàm mixin

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
abstract class SuperClass {
    abstract someMethod(): void;
    badda() {}
}
type AbstractConstructor<T> = abstract new (...args: any[]) => T
function withStyles<T extends AbstractConstructor<object>>(Ctor: T) {
    abstract class StyledClass extends Ctor {
        getStyles() {
            // ...
        }
    }
    return StyledClass;
}
class SubClass extends withStyles(SuperClass) {
    someMethod() {
        this.someMethod()
    }
}

Lưu ý rằng

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Bạn có thể đọc thêm về chữ ký xây dựng trừu tượng theo yêu cầu kéo của nó.

Hiểu cấu trúc dự án của bạn với tsinterface SomeType { /** This is an index signature. */ [propName: string]: any;}function doStuff(value: SomeType) { let x = value["someProperty"];}42

Một kịch bản phổ biến đáng ngạc nhiên cho người dùng TypeScript là hỏi tại sao TypeScript bao gồm cả tệp này? Suy ra các tệp trong chương trình của bạn hóa ra là một quá trình phức tạp và do đó có rất nhiều lý do tại sao một sự kết hợp cụ thể của

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Đó là lý do tại sao TypeScript bây giờ cung cấp cờ

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

sh
tsc --explainFiles

Khi sử dụng tùy chọn này, trình biên dịch TypeScript sẽ cung cấp một số đầu ra rất dài dòng về lý do tại sao một tệp kết thúc trong chương trình của bạn. Để đọc nó dễ dàng hơn, bạn có thể chuyển tiếp đầu ra đến một tệp hoặc gửi nó vào một chương trình có thể dễ dàng xem nó.

sh
# Forward output to a text file
tsc --explainFiles > expanation.txt
# Pipe output to a utility program like `less`, or an editor like VS Code
tsc --explainFiles | less
tsc --explainFiles | code -

Thông thường, đầu ra sẽ bắt đầu bằng cách liệt kê các lý do bao gồm các tệp

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

Ngay bây giờ, chúng tôi không đảm bảo về định dạng đầu ra - nó có thể thay đổi theo thời gian. Trên lưu ý đó, chúng tôi quan tâm đến việc cải thiện định dạng này nếu bạn có bất kỳ đề xuất nào!

Để biết thêm thông tin, hãy xem yêu cầu kéo ban đầu!

Cải thiện chức năng chưa được kiểm tra trong các biểu thức logic

Nhờ những cải tiến hơn nữa từ Alex Tarasyuk, các kiểm tra chức năng chưa được xác định của TypeScript hiện đang được áp dụng trong các biểu thức

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Theo

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

Để biết thêm chi tiết, hãy xem yêu cầu kéo ở đây.

Các biến bị phá hủy có thể được đánh dấu rõ ràng là không được sử dụng

Nhờ một yêu cầu kéo khác từ Alex Tarasyuk, giờ đây bạn có thể đánh dấu các biến bị phá hủy là không sử dụng bằng tiền tố chúng bằng một dấu gạch dưới (ký tự

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

Trước đây, nếu

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Để biết thêm chi tiết, hãy xem sự thay đổi đầy đủ.

Các quy tắc thư giãn giữa các thuộc tính tùy chọn và chữ ký chỉ số chuỗi

Chữ ký chỉ mục chuỗi là một cách gõ các đối tượng giống như từ điển, nơi bạn muốn cho phép truy cập với các khóa tùy ý:

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

Tất nhiên, đối với bất kỳ tiêu đề phim nào chưa có trong từ điển,

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

TypeScript 4.2 cho phép gán này. Tuy nhiên, nó không cho phép gán các thuộc tính không tùy chọn với

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

Quy tắc mới cũng không áp dụng cho chữ ký chỉ số số, vì chúng được coi là giống như mảng và dày đặc:

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

Bạn có thể hiểu rõ hơn về sự thay đổi này bằng cách đọc lên PR ban đầu.

Tuyên bố thiếu chức năng trợ giúp

Nhờ yêu cầu kéo theo cộng đồng từ Alexander Tarasyuk, giờ đây chúng tôi có một cách khắc phục nhanh chóng để tuyên bố các chức năng và phương thức mới dựa trên trang web cuộc gọi!

Phá vỡ thay đổi

Chúng tôi luôn cố gắng để giảm thiểu các thay đổi phá vỡ trong một bản phát hành. TypeScript 4.2 chứa một số thay đổi phá vỡ, nhưng chúng tôi tin rằng chúng nên được quản lý trong một bản nâng cấp.

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

43 Cập nhật

Như với mọi phiên bản TypeScript, các khai báo cho

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

68 Lỗi áp dụng cho các biểu thức lỏng lẻo

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

69

Khi giá trị của biểu thức

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

Xem thêm chi tiết trong các thay đổi tương ứng.

Kiểm tra chức năng chưa được mở rộng

Như đã mô tả ở trên, các kiểm tra chức năng chưa được đặt hiện tại sẽ hoạt động nhất quán trong các biểu thức

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Loại đối số trong JavaScript không được phân tích cú pháp là đối số loại

Các đối số loại đã không được phép trong JavaScript, nhưng trong TypeScript 4.2, trình phân tích cú pháp sẽ phân tích chúng theo cách tuân thủ đặc biệt hơn. Vì vậy, khi viết mã sau trong tệp JavaScript:

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

TypeScript sẽ phân tích nó là JavaScript sau:

ts
// A tuple that stores a pair of numbers
let a: [number, number] = [1, 2];
// A tuple that stores a string, a number, and a boolean
let b: [string, number, boolean] = ["hello", 42, true];

Điều này có thể ảnh hưởng đến bạn nếu bạn đang tận dụng API TypeScript của các cấu trúc loại phân tích trong các tệp JavaScript, điều này có thể xảy ra khi cố gắng phân tích các tệp luồng.

Xem yêu cầu kéo để biết thêm chi tiết về những gì đã kiểm tra.

Giới hạn kích thước Tuple cho chênh lệch

Các loại tple có thể được thực hiện bằng cách sử dụng bất kỳ loại cú pháp lan truyền (

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

Đôi khi các loại tuple này có thể vô tình phát triển trở nên lớn, và điều đó có thể khiến việc kiểm tra loại mất nhiều thời gian. Thay vì để quá trình kiểm tra loại (đặc biệt xấu trong các kịch bản biên tập), TypeScript có một bộ giới hạn để tránh thực hiện tất cả các công việc đó.

Bạn có thể thấy yêu cầu kéo này để biết thêm chi tiết.

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

19 Tiện ích mở rộng không thể được sử dụng trong các đường dẫn nhập

Trong TypeScript 4.2, giờ đây đây là một lỗi cho các đường dẫn nhập của bạn để chứa

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

Thay vào đó, đường dẫn nhập của bạn sẽ phản ánh bất cứ điều gì trình tải của bạn sẽ làm trong thời gian chạy. Bất kỳ nhập khẩu nào sau đây có thể có thể sử dụng thay thế.

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

Hoàn nguyên mẫu suy luận theo nghĩa đen

Thay đổi này đã loại bỏ một tính năng từ Beta TypeScript 4.2. Nếu bạn đã không nâng cấp qua bản phát hành ổn định cuối cùng của chúng tôi, bạn đã thắng bị ảnh hưởng, nhưng bạn vẫn có thể quan tâm đến sự thay đổi.

Phiên bản Beta của TypeScript 4.2 bao gồm một thay đổi trong chuỗi Mẫu. Trong thay đổi này, các chuỗi chuỗi mẫu sẽ được cung cấp các loại chuỗi mẫu hoặc đơn giản hóa thành nhiều loại theo nghĩa đen. Các loại này sau đó sẽ mở rộng thành

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

Điều này tương tự như cách thức hoạt động suy luận theo nghĩa đen của chuỗi.

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

Vì lý do đó, chúng tôi tin rằng việc tạo các biểu thức chuỗi mẫu có các loại chuỗi mẫu sẽ là sự nhất quán của Cameron; Tuy nhiên, từ những gì chúng tôi đã thấy và nghe thấy, đó không phải là mong muốn.

Đáp lại, chúng tôi đã hoàn nguyên tính năng này (và thay đổi phá vỡ tiềm năng). Nếu bạn muốn một biểu thức chuỗi mẫu được cung cấp một loại giống như nghĩa đen, bạn luôn có thể thêm

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

TypeScript 4.1

Mẫu các loại nghĩa đen

Chuỗi các loại chữ trong TypeScript cho phép chúng tôi mô hình hóa các chức năng và API mong đợi một tập hợp các chuỗi cụ thể.

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

Điều này khá đẹp vì các loại theo nghĩa đen về cơ bản có thể kiểm tra chính tả các giá trị chuỗi của chúng tôi.

Chúng tôi cũng thích rằng các chữ viết có thể được sử dụng làm tên thuộc tính trong các loại được ánh xạ. Theo nghĩa này, họ cũng có thể sử dụng như các khối xây dựng:

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

Nhưng có một nơi khác mà các loại chuỗi theo nghĩa đen có thể được sử dụng làm khối xây dựng: xây dựng các loại theo nghĩa đen khác.

Đó là lý do tại sao TypeScript 4.1 mang đến loại chuỗi theo nghĩa đen. Nó có cùng cú pháp với các chuỗi theo nghĩa đen trong JavaScript, nhưng được sử dụng ở các vị trí loại. Khi bạn sử dụng nó với các loại theo nghĩa đen cụ thể, nó sẽ tạo ra một loại chuỗi mới bằng cách kết hợp các nội dung.

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

Điều gì xảy ra khi bạn có công đoàn trong các vị trí thay thế? Nó tạo ra tập hợp của mọi chuỗi có thể có thể được đại diện bởi mỗi thành viên công đoàn.

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

Điều này có thể được sử dụng ngoài các ví dụ dễ thương trong ghi chú phát hành. Ví dụ, một số thư viện cho các thành phần UI có cách chỉ định cả căn chỉnh dọc và ngang trong API của chúng, thường với cả hai cùng một lúc sử dụng một chuỗi như

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// @errors: 2361
"foo" in 42;

Mặc dù có rất nhiều ví dụ về loại API này trong tự nhiên, nhưng đây vẫn là một ví dụ đồ chơi vì chúng tôi có thể viết chúng ra bằng tay. Trong thực tế, đối với 9 chuỗi, điều này có thể tốt; Nhưng khi bạn cần một tấn chuỗi, bạn nên xem xét tự động tạo chúng trước thời hạn để lưu công việc trên mỗi loại kiểm tra (hoặc chỉ sử dụng

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Một số giá trị thực đến từ việc tạo ra các chữ cái mới. Ví dụ, hãy tưởng tượng API

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// @errors: 2361
"foo" in 42;

Lưu ý rằng

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// @errors: 2361
"foo" in 42;

Với điều này, chúng ta có thể xây dựng một cái gì đó lỗi khi chúng ta đưa sai tài sản!

ts
// @errors: 2361
"foo" in 42;

Chúng ta cũng có thể làm một cái gì đó đặc biệt trong các loại theo nghĩa đen: chúng ta có thể suy ra từ các vị trí thay thế. Chúng ta có thể tạo ví dụ cuối cùng của chúng ta chung để suy ra từ các phần của chuỗi

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
// @errors: 2361
"foo" in 42;

Ở đây chúng tôi đã biến

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

Suy luận có thể được kết hợp theo những cách khác nhau, thường là để giải mã các chuỗi và tái cấu trúc chúng theo những cách khác nhau. Trên thực tế, để giúp sửa đổi các loại theo nghĩa đen này, chúng tôi đã thêm một vài bí danh loại tiện ích mới để sửa đổi vỏ trong các chữ cái (nghĩa là chuyển đổi sang các ký tự chữ thường và chữ hoa).

ts
// @errors: 2361
"foo" in 42;

Các bí danh loại mới là

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

Để biết thêm chi tiết, hãy xem yêu cầu kéo ban đầu và yêu cầu kéo theo tiến trình để chuyển sang người trợ giúp loại bí danh.

Nhắc lại chính trong các loại được ánh xạ

Chỉ như một sự bồi dưỡng, một loại được ánh xạ có thể tạo các loại đối tượng mới dựa trên các khóa tùy ý

ts
let foo: [...string[], number];
foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];
let bar: [boolean, ...string[], boolean];
bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

hoặc các loại đối tượng mới dựa trên các loại đối tượng khác.

ts
// @errors: 2361
"foo" in 42;

Cho đến bây giờ, các loại được ánh xạ chỉ có thể tạo ra các loại đối tượng mới với các khóa mà bạn đã cung cấp chúng; Tuy nhiên, rất nhiều thời gian bạn muốn có thể tạo các khóa mới hoặc lọc các khóa, dựa trên các đầu vào.

Đó là lý do tại sao TypeScript 4.1 cho phép bạn lập bản đồ lại các khóa theo các loại được ánh xạ với mệnh đề

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

ts
// @errors: 2361
"foo" in 42;

Với điều khoản

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

ts
// @errors: 2361
"foo" in 42;

Và bạn thậm chí có thể lọc các khóa bằng cách sản xuất

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}

ts
interface SomeType {
  /** This is an index signature. */
  [propName: string]: any;
}
function doStuff(value: SomeType) {
  let x = value["someProperty"];
}

Để biết thêm thông tin, hãy xem yêu cầu kéo ban đầu trên GitHub.

Các loại có điều kiện đệ quy

Trong JavaScript, nó khá phổ biến để thấy các chức năng có thể làm phẳng và xây dựng các loại container ở cấp độ tùy ý. Ví dụ, hãy xem xét phương pháp

ts
interface Options {
  /** File patterns to be excluded. */
  exclude?: string[];
  /**
   * It handles any extra properties that we haven't declared as type 'any'.
   */
  [x: string]: any;
}
function processOptions(opts: Options) {
  // Notice we're *intentionally* accessing `excludes`, not `exclude`
  if (opts.excludes) {
    console.error(
      "The option `excludes` is not valid. Did you mean `exclude`?"
    );
  }
}