Tạo đối tượng javascript hai

❌ Đừng bao giờ sử dụng các loại

ts

/* OK */

function reverse(s: string): string;

8,

ts

/* OK */

function reverse(s: string): string;

9,

ts

/* WRONG */

function fn(x: () => any) {

x();

}

0,

ts

/* WRONG */

function fn(x: () => any) {

x();

}

1 hoặc

ts

/* WRONG */

function fn(x: () => any) {

x();

}

2 Các loại này đề cập đến các đối tượng được đóng hộp không nguyên thủy hầu như không bao giờ được sử dụng một cách thích hợp trong mã JavaScript

ts

/* WRONG */

function reverse(s: String): String;

✅ Nên dùng các loại

ts

/* WRONG */

function fn(x: () => any) {

x();

}

8,

ts

/* WRONG */

function fn(x: () => any) {

x();

}

9,

ts

/* OK */

function fn(x: () => void) {

x();

}

0, và

ts

/* OK */

function fn(x: () => void) {

x();

}

1

ts

/* OK */

function reverse(s: string): string;

Thay vì

ts

/* WRONG */

function fn(x: () => any) {

x();

}

2, hãy sử dụng loại

ts

/* OK */

function fn(x: () => void) {

x();

}

3 không nguyên thủy (được thêm vào TypeScript 2. 2)

thuốc gốc

❌ Đừng bao giờ có một kiểu chung không sử dụng tham số kiểu của nó. Xem thêm chi tiết trong trang Câu hỏi thường gặp về TypeScript

không tí nào

❌ Không sử dụng loại

ts

/* OK */

function fn(x: () => void) {

x();

}

4 trừ khi bạn đang trong quá trình chuyển một dự án JavaScript sang TypeScript. Trình biên dịch xử lý hiệu quả

ts

/* OK */

function fn(x: () => void) {

x();

}

4 là “vui lòng tắt tính năng kiểm tra kiểu đối với thứ này”. Nó tương tự như đặt một nhận xét

ts

/* OK */

function fn(x: () => void) {

x();

}

6 xung quanh mọi cách sử dụng biến. Điều này có thể rất hữu ích khi bạn lần đầu tiên di chuyển một dự án JavaScript sang TypeScript vì bạn có thể đặt loại cho nội dung mà bạn chưa di chuyển là

ts

/* OK */

function fn(x: () => void) {

x();

}

4, nhưng trong một dự án TypeScript đầy đủ, bạn đang vô hiệu hóa tính năng kiểm tra loại đối với bất kỳ phần nào trong chương trình của mình.

Trong trường hợp bạn không biết loại nào bạn muốn chấp nhận hoặc khi bạn muốn chấp nhận bất cứ thứ gì vì bạn sẽ lướt qua nó một cách mù quáng mà không tương tác với nó, bạn có thể sử dụng

ts

/* OK */

function fn(x: () => void) {

x();

}

8

Các loại gọi lại

Trả lại các loại cuộc gọi lại

❌ Không sử dụng kiểu trả về

ts

/* OK */

function fn(x: () => void) {

x();

}

4 cho các lệnh gọi lại có giá trị sẽ bị bỏ qua

ts

/* WRONG */

function fn(x: () => any) {

x();

}

✅ Sử dụng loại trả về

ts

/* WRONG */

function fn(x: () => any) {

x();

}

00 cho các lệnh gọi lại có giá trị sẽ bị bỏ qua

________số 8

❔ Tại sao. Sử dụng

ts

/* WRONG */

function fn(x: () => any) {

x();

}

00 sẽ an toàn hơn vì nó ngăn bạn vô tình sử dụng giá trị trả về của

ts

/* WRONG */

function fn(x: () => any) {

x();

}

02 một cách không được kiểm soát

ts

/* WRONG */

function fn(x: () => any) {

x();

}

0

Tham số tùy chọn trong Callbacks

❌ Không sử dụng tham số tùy chọn trong lệnh gọi lại trừ khi bạn thực sự có ý đó

ts

/* WRONG */

function fn(x: () => any) {

x();

}

5

Điều này có một ý nghĩa rất cụ thể. cuộc gọi lại

ts

/* WRONG */

function fn(x: () => any) {

x();

}

03 có thể được gọi với 1 đối số hoặc có thể được gọi với 2 đối số. Có lẽ tác giả muốn nói rằng cuộc gọi lại có thể không quan tâm đến tham số

ts

/* WRONG */

function fn(x: () => any) {

x();

}

04, nhưng không cần đặt tham số tùy chọn để thực hiện điều này — việc cung cấp một cuộc gọi lại chấp nhận ít đối số hơn luôn là điều hợp pháp

✅ Viết tham số gọi lại là không bắt buộc

ts

/* WRONG */

function fn(x: () => any) {

x();

}

8

Quá tải và gọi lại

❌ Không viết các tình trạng quá tải riêng biệt chỉ khác nhau về tính chất gọi lại

ts

/* WRONG */

function fn(x: () => any) {

x();

}

9

✅ Viết một quá tải duy nhất bằng cách sử dụng arity tối đa

ts

/* WRONG */

function fn(x: () => any) {

x();

}

0

❔ Tại sao. Việc gọi lại bỏ qua một tham số luôn luôn hợp pháp, vì vậy không cần quá tải ngắn hơn. Trước tiên, cung cấp một cuộc gọi lại ngắn hơn cho phép các hàm được nhập không chính xác được chuyển vào vì chúng khớp với tình trạng quá tải đầu tiên

Quá tải chức năng

đặt hàng

❌ Đừng đặt quá tải chung chung trước quá tải cụ thể hơn

ts

/* WRONG */

function fn(x: () => any) {

x();

}

1

✅ Sắp xếp quá tải bằng cách đặt các chữ ký chung hơn sau các chữ ký cụ thể hơn

ts

/* OK */

function reverse(s: string): string;

0

❔ Tại sao. TypeScript chọn quá tải khớp đầu tiên khi giải quyết các lệnh gọi hàm. Khi quá tải trước đó "tổng quát hơn" so với quá tải sau, thì quá tải sau được ẩn một cách hiệu quả và không thể được gọi

Sử dụng các tham số tùy chọn

❌ Đừng viết quá tải chỉ khác nhau ở các tham số theo sau

ts

/* OK */

function reverse(s: string): string;

1

✅ Sử dụng các tham số tùy chọn bất cứ khi nào có thể

ts

/* OK */

function reverse(s: string): string;

2

Lưu ý rằng sự sụp đổ này chỉ xảy ra khi tất cả các quá tải có cùng kiểu trả về

❔ Tại sao. Điều này quan trọng vì hai lý do

TypeScript giải quyết khả năng tương thích chữ ký bằng cách xem liệu có thể gọi bất kỳ chữ ký nào của mục tiêu với các đối số của nguồn hay không và cho phép các đối số không liên quan. Ví dụ: mã này chỉ hiển thị lỗi khi chữ ký được viết chính xác bằng các tham số tùy chọn

ts

/* OK */

function reverse(s: string): string;

3

Lý do thứ hai là khi người tiêu dùng sử dụng tính năng “kiểm tra null nghiêm ngặt” của TypeScript. Bởi vì các tham số không xác định xuất hiện dưới dạng

ts

/* WRONG */

function fn(x: () => any) {

x();

}

05 trong JavaScript, thông thường bạn có thể chuyển một

ts

/* WRONG */

function fn(x: () => any) {

x();

}

05 rõ ràng cho một hàm với các đối số tùy chọn. Ví dụ, mã này sẽ ổn với giá trị rỗng nghiêm ngặt