Làm cách nào để xóa thẻ html khỏi văn bản trong phản ứng gốc?

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

2 là một công cụ để làm nổi bật các vấn đề tiềm ẩn trong một ứng dụng. Giống như

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

3,

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

2 không hiển thị bất kỳ giao diện người dùng hiển thị nào. Nó kích hoạt kiểm tra và cảnh báo bổ sung cho hậu duệ của nó

Ghi chú

Kiểm tra chế độ nghiêm ngặt chỉ được chạy trong chế độ phát triển;

Bạn có thể bật chế độ nghiêm ngặt cho bất kỳ phần nào trong ứng dụng của mình. Ví dụ

import React from 'react';

function ExampleApplication() {
  return (
    <div>
      <Header />
      <React.StrictMode>        <div>
          <ComponentOne />
          <ComponentTwo />
        div>
      React.StrictMode>      <Footer />
    div>
  );
}

Trong ví dụ trên, kiểm tra chế độ nghiêm ngặt sẽ không được chạy đối với các thành phần

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

0 và

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

1. Tuy nhiên,

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

2 và

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

3, cũng như tất cả con cháu của họ, sẽ có séc

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

2 hiện đang giúp với

• Xác định các thành phần có vòng đời không an toàn
• Cảnh báo về việc sử dụng API tham chiếu chuỗi kế thừa
• Cảnh báo về việc sử dụng findDOMNode không dùng nữa
• Phát hiện tác dụng phụ không mong muốn
• Phát hiện API ngữ cảnh kế thừa
• Đảm bảo trạng thái tái sử dụng

Chức năng bổ sung sẽ được thêm vào với các bản phát hành React trong tương lai

Xác định vòng đời không an toàn

Như đã giải thích trong bài đăng trên blog này, một số phương pháp vòng đời cũ không an toàn để sử dụng trong các ứng dụng React không đồng bộ. Tuy nhiên, nếu ứng dụng của bạn sử dụng thư viện của bên thứ ba, có thể khó đảm bảo rằng các vòng đời này không được sử dụng. May mắn thay, chế độ nghiêm ngặt có thể giúp ích cho việc này

Khi chế độ nghiêm ngặt được bật, React sẽ biên dịch danh sách tất cả các thành phần lớp sử dụng vòng đời không an toàn và ghi lại thông báo cảnh báo với thông tin về các thành phần này, như vậy

Giải quyết các vấn đề được xác định bởi chế độ nghiêm ngặt ngay bây giờ sẽ giúp bạn dễ dàng tận dụng lợi thế của kết xuất đồng thời trong các bản phát hành React trong tương lai

Cảnh báo về việc sử dụng API tham chiếu chuỗi kế thừa

Trước đây, React đã cung cấp hai cách để quản lý lượt giới thiệu. API tham chiếu chuỗi kế thừa và API gọi lại. Mặc dù API tham chiếu chuỗi thuận tiện hơn trong cả hai, nhưng nó có một số nhược điểm và do đó, đề xuất chính thức của chúng tôi là sử dụng biểu mẫu gọi lại thay thế

phản ứng 16. 3 đã thêm tùy chọn thứ ba mang đến sự tiện lợi của chuỗi ref mà không có bất kỳ nhược điểm nào

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

Vì các tham chiếu đối tượng phần lớn được thêm vào để thay thế cho tham chiếu chuỗi, chế độ nghiêm ngặt hiện cảnh báo về việc sử dụng tham chiếu chuỗi

Ghi chú

Giới thiệu gọi lại sẽ tiếp tục được hỗ trợ ngoài API

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

5 mới

Bạn không cần thay thế giới thiệu gọi lại trong các thành phần của mình. Chúng linh hoạt hơn một chút, vì vậy chúng sẽ vẫn là một tính năng nâng cao

Tìm hiểu thêm về API

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

5 mới tại đây

Cảnh báo về việc sử dụng findDOMNode không dùng nữa

React được sử dụng để hỗ trợ

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

7 tìm kiếm nút DOM trên cây với một thể hiện của lớp. Thông thường, bạn không cần điều này vì bạn có thể đính kèm trực tiếp ref vào nút DOM

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

7 cũng có thể được sử dụng trên các thành phần của lớp nhưng điều này đã phá vỡ mức độ trừu tượng bằng cách cho phép cha mẹ yêu cầu một số phần tử con nhất định được hiển thị. Nó tạo ra rủi ro tái cấu trúc khi bạn không thể thay đổi chi tiết triển khai của một thành phần vì cha mẹ có thể đang truy cập vào nút DOM của nó.

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

7 chỉ trả về nút con đầu tiên, nhưng với việc sử dụng Fragment, một thành phần có thể hiển thị nhiều nút DOM.

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

7 là API đọc một lần. Nó chỉ cho bạn một câu trả lời khi bạn yêu cầu nó. Nếu một thành phần con hiển thị một nút khác, không có cách nào để xử lý thay đổi này. Do đó,

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

7 chỉ hoạt động nếu các thành phần luôn trả về một nút DOM duy nhất không bao giờ thay đổi

Thay vào đó, bạn có thể làm rõ điều này bằng cách chuyển một giới thiệu tới thành phần tùy chỉnh của mình và chuyển nó tới DOM bằng cách sử dụng chuyển tiếp giới thiệu

Bạn cũng có thể thêm một nút DOM trình bao bọc trong thành phần của mình và đính kèm một tham chiếu trực tiếp vào nó

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

3

Ghi chú

Trong CSS, thuộc tính

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

32 có thể được sử dụng nếu bạn không muốn nút là một phần của bố cục

Phát hiện tác dụng phụ không mong muốn

Về mặt khái niệm, React hoạt động theo hai giai đoạn

• Giai đoạn kết xuất xác định những thay đổi cần thực hiện đối với. g. DOM. Trong giai đoạn này, React gọi

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  33 và sau đó so sánh kết quả với lần hiển thị trước đó
• Giai đoạn cam kết là khi React áp dụng bất kỳ thay đổi nào. (Trong trường hợp React DOM, đây là khi React chèn, cập nhật và xóa các nút DOM. ) React cũng gọi các vòng đời như

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  34 và

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  35 trong giai đoạn này

Giai đoạn cam kết thường rất nhanh nhưng kết xuất có thể chậm. Vì lý do này, chế độ đồng thời sắp tới (chưa được bật theo mặc định) sẽ chia nhỏ công việc kết xuất thành từng phần, tạm dừng và tiếp tục công việc để tránh chặn trình duyệt. Điều này có nghĩa là React có thể gọi các vòng đời của pha kết xuất nhiều lần trước khi thực hiện hoặc có thể gọi chúng mà không thực hiện lần nào (do lỗi hoặc gián đoạn mức độ ưu tiên cao hơn)

Vòng đời của giai đoạn kết xuất bao gồm các phương thức thành phần lớp sau

• class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  36

• class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  37 (hoặc

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  38)

• class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  39 (hoặc

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  20)

• class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  21 (hoặc

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  22)

• class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  23

• class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  24

• class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  33

• class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  26 hàm cập nhật (đối số đầu tiên)

Bởi vì các phương pháp trên có thể được gọi nhiều lần, điều quan trọng là chúng không chứa tác dụng phụ. Bỏ qua quy tắc này có thể dẫn đến nhiều vấn đề, bao gồm rò rỉ bộ nhớ và trạng thái ứng dụng không hợp lệ. Thật không may, có thể khó phát hiện những vấn đề này vì chúng thường không mang tính quyết định.

Chế độ nghiêm ngặt không thể tự động phát hiện các tác dụng phụ cho bạn, nhưng nó có thể giúp bạn phát hiện ra chúng bằng cách làm cho chúng trở nên rõ ràng hơn một chút. Điều này được thực hiện bằng cách gọi hai lần có chủ ý các chức năng sau

• Các phương thức thành phần lớp

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  36,

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  33 và

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  24
• Thành phần lớp phương pháp tĩnh

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  23
• Cơ quan thành phần chức năng
• Các hàm cập nhật trạng thái (đối số đầu tiên của

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  26)
• Các hàm được truyền cho

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  42,

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  43 hoặc

  class MyComponent extends React.Component {
    constructor(props) {
      super(props);
  
      this.inputRef = React.createRef();  }
  
    render() {
      return <input type="text" ref={this.inputRef} />;  }
  
    componentDidMount() {
      this.inputRef.current.focus();  }
  }

  44

Ghi chú

Điều này chỉ áp dụng cho chế độ phát triển. Vòng đời sẽ không được gọi hai lần trong chế độ sản xuất

Ví dụ: xem xét đoạn mã sau

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

2

Thoạt nhìn, mã này có vẻ không có vấn đề gì. Nhưng nếu

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

45 không bình thường, thì việc khởi tạo thành phần này nhiều lần có thể dẫn đến trạng thái ứng dụng không hợp lệ. Loại lỗi tinh vi này có thể không biểu hiện trong quá trình phát triển hoặc có thể xảy ra không nhất quán và do đó bị bỏ qua

Bằng cách cố ý gọi hai phương thức như hàm tạo thành phần, chế độ nghiêm ngặt làm cho các mẫu như thế này dễ dàng phát hiện hơn

Ghi chú

Trong React 17, React tự động sửa đổi các phương thức của bảng điều khiển như

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

46 để tắt tiếng nhật ký trong lần gọi thứ hai đến các chức năng vòng đời. Tuy nhiên, nó có thể gây ra hành vi không mong muốn trong một số trường hợp có thể sử dụng giải pháp thay thế

Bắt đầu từ React 18, React không chặn bất kỳ nhật ký nào. Tuy nhiên, nếu bạn đã cài đặt React DevTools, nhật ký từ cuộc gọi thứ hai sẽ xuất hiện hơi mờ. React DevTools cũng cung cấp một cài đặt (tắt theo mặc định) để loại bỏ chúng hoàn toàn

Phát hiện API ngữ cảnh kế thừa

API ngữ cảnh cũ dễ bị lỗi và sẽ bị xóa trong phiên bản chính trong tương lai. Nó vẫn hoạt động cho tất cả 16. x phát hành nhưng sẽ hiển thị thông báo cảnh báo này ở chế độ nghiêm ngặt

Đọc tài liệu API ngữ cảnh mới để giúp chuyển sang phiên bản mới

Đảm bảo trạng thái tái sử dụng

Trong tương lai, chúng tôi muốn thêm một tính năng cho phép React thêm và xóa các phần của giao diện người dùng trong khi vẫn giữ nguyên trạng thái. Ví dụ: khi người dùng rời khỏi màn hình và quay lại, React sẽ có thể hiển thị ngay màn hình trước đó. Để làm điều này, React sẽ hỗ trợ sắp xếp lại các cây bằng cách sử dụng cùng một trạng thái thành phần được sử dụng trước khi ngắt kết nối

Tính năng này sẽ giúp React có hiệu suất vượt trội tốt hơn, nhưng yêu cầu các thành phần phải linh hoạt trước các hiệu ứng được gắn và phá hủy nhiều lần. Hầu hết các hiệu ứng sẽ hoạt động mà không có bất kỳ thay đổi nào, nhưng một số hiệu ứng không dọn dẹp đúng cách các đăng ký trong lệnh gọi lại hủy hoặc mặc nhiên cho rằng chúng chỉ được gắn hoặc hủy một lần

Để giúp giải quyết những vấn đề này, React 18 giới thiệu một kiểm tra mới chỉ dành cho nhà phát triển đối với Chế độ nghiêm ngặt. Kiểm tra mới này sẽ tự động ngắt kết nối và kết nối lại mọi thành phần, bất cứ khi nào một thành phần được gắn kết lần đầu tiên, khôi phục trạng thái trước đó trong lần gắn kết thứ hai

Để chứng minh hành vi phát triển mà bạn sẽ thấy trong Chế độ nghiêm ngặt với tính năng này, hãy xem xét điều gì sẽ xảy ra khi React gắn kết một thành phần mới. Nếu không có sự thay đổi này, khi một thành phần được gắn kết, React sẽ tạo ra các hiệu ứng

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

4

Với Chế độ nghiêm ngặt bắt đầu từ React 18, bất cứ khi nào một thành phần được gắn kết trong quá trình phát triển, React sẽ mô phỏng ngay lập tức việc ngắt kết nối và kết nối lại thành phần đó

class MyComponent extends React.Component {
  constructor(props) {
    super(props);

    this.inputRef = React.createRef();  }

  render() {
    return <input type="text" ref={this.inputRef} />;  }

  componentDidMount() {
    this.inputRef.current.focus();  }
}

1

Ở lần gắn kết thứ hai, React sẽ khôi phục trạng thái từ lần gắn kết đầu tiên. Tính năng này mô phỏng hành vi của người dùng, chẳng hạn như người dùng rời khỏi màn hình và quay lại, đảm bảo rằng mã sẽ xử lý khôi phục trạng thái đúng cách

Làm cách nào để xóa thẻ HTML khỏi chuỗi phản ứng gốc?

Làm cách nào để xóa tất cả các thẻ HTML khỏi chuỗi trong phản ứng JS?