Подтвердить что ты не робот

Реагировать на методы жизненного цикла

Я новичок в React.js и очень стараюсь понять несколько методов в методах жизненного цикла React.

Пока у меня есть кое-что, что меня смущает:

1)

Насколько я понимаю, разница между componentWillUpdate и componentWillReceiveProps в том, что componentWillReceiveProps будет вызываться, когда родитель меняет реквизит, и мы можем использовать setState (setState этого потомка внутри componentWillReceiveProps).

например: реакция-таблица-сортировщик-демонстрация

var App = React.createClass({
  getInitialState: function() {
    return {source: {limit: "200", source: "source1"}};
  },
  handleSourceChange: function(source) {
    this.setState({source: source});
  },
  render: function() {
    return (
      <div>
        <DataSourceSelectors onSourceChange={this.handleSourceChange} source={this.state.source} />
        <TableSorter dataSource={urlForDataSource(this.state.source)} config={CONFIG} headerRepeat="5" />
      </div>
    );
  }
});

В TableSorter у нас есть

componentWillReceiveProps: function(nextProps) {
    // Load new data when the dataSource property changes.
    if (nextProps.dataSource != this.props.dataSource) {
      this.loadData(nextProps.dataSource);
    }
  }

То есть, когда мы изменим this.state.source, мы ожидаем, что componentWillReceiveProps будет вызван в TableSorter.

Тем не менее, я не совсем понимаю, как использовать componentWillUpdate в этом случае, определение componentWillUpdate является

componentWillUpdate(object nextProps, object nextState)

Как мы можем передать nextState от родителя в child? Или, может быть, я не прав, передается ли nextState из родительского элемента?

2) метод componentWillMount смущает меня, потому что в официальной документации говорится, что

Вызывается один раз, как на клиенте, так и на сервере, непосредственно перед Первоначальный рендеринг происходит.

В этом случае, если я использую setState в этом методе, он переопределит getInitialState, так как он будет вызван только один раз изначально. В этом случае, какова причина для установки параметров в методе getInitialState. В данном конкретном случае мы имеем:

  getInitialState: function() {
    return {
      items: this.props.initialItems || [],
      sort: this.props.config.sort || { column: "", order: "" },
      columns: this.props.config.columns
    };
  },
  componentWillMount: function() {
    this.loadData(this.props.dataSource);
  },
  loadData: function(dataSource) {
    if (!dataSource) return;

    $.get(dataSource).done(function(data) {
      console.log("Received data");
     this.setState({items: data});
     }.bind(this)).fail(function(error, a, b) {
      console.log("Error loading JSON");
     });
  },

элементы будут переопределены изначально и зачем нам все еще нужно items: this.props.initialItems || [] в методе getInitialState?

Надеюсь, вы понимаете мое объяснение, и, пожалуйста, дайте мне несколько советов, если у вас есть.

4b9b3361

Ответ 1

1) componentWillReceiveProps вызывается до componentWillUpdate в жизненном цикле обновления React. Вы правы, что componentWillReceiveProps позволяет вам вызвать setState. С другой стороны, componentWillUpdate - это обратный вызов для использования, когда вам нужно ответить на изменение состояния.

Основное отличие между реквизитами и состоянием заключается в том, что состояние является частным компонентом. Поэтому ни родительский компонент, ни кто-либо другой не могут манипулировать состоянием (например, call setState) компонента. Таким образом, рабочий процесс по умолчанию для отношения между родительским и дочерним компонентами будет следующим:

  • Родитель передает новые реквизиты ребенку
  • Ребенок обрабатывает новые реквизиты в 'componentWillReceiveProps', при необходимости вызывает setState
  • Ребенок обрабатывает новое состояние в компоненте componentWillUpdate, но если ваш компонент является работоспособным, обработка реквизитов в компоненте componentWillReceiveProps будет достаточно.

2) Вы показали неплохой пример кода, чтобы проиллюстрировать разницу. Значения по умолчанию, установленные в getInitialState, будут использоваться для первоначального рендеринга. Вызов loadData из componentWillMount инициирует запрос AJAX, который может или не может быть успешным, - кроме того, неизвестно, сколько времени потребуется для завершения. К моменту завершения запроса AJAX и вызова setState с новым состоянием компонент будет отображаться в DOM со значениями по умолчанию. Вот почему он имеет смысл предоставлять состояние по умолчанию в getInitialState.

Примечание. Я нашел Понимание жизненного цикла компонентов React - огромная помощь для понимания методов жизненного цикла React.

Ответ 2

Четыре фазы компонента React

Initialization

Mounting

Update

Unmounting

Здесь краткий обзор различных методов

LifeCycle

компонента. Вы должны хорошо понимать методы жизненного цикла, чтобы код реагировал.

Методы на этапе монтажа:

Он начинается, когда создается экземпляр компонента и когда он отображается в DOM.

1. constructor(props) - вызывается при первой инициализации компонента. Этот метод вызывается только один раз.
 2. componentWillMount() - вызывается, когда компонент собирается смонтировать.
 3. render() -it вызывается при визуализации компонента.
 4. componentDidMount() - вызывается, когда компонент завершил монтирование.

Методы в фазе обновления:

Он начинается при изменении свойств или состояния компонента.

1. componentWillReceiveProps(nextProps) - вызывается, когда компонент обновился и получает новые реквизиты.
2. shouldComponentUpdate(nextProps, nextState) - вызывается после получения реквизита и готовится к обновлению. Если этот метод возвращает значение false, componentWillUpdate(), render() и componentDidUpdate() не будут выполнены.
3. componentWillUpdate(nextProps, nextState) - вызывается, когда компонент будет обновлен.
4. render() - вызывается при перерисовке компонента.
5. componentDidUpdate(prevProps, prevState) - вызывается, когда компонент завершил обновление.

Методы в фазе размонтирования:

Он начинается, когда компонент удаляется из DOM.

1. componentWillUnmount() - вызывается непосредственно перед размонтированием компонента.

Ref: https://hackernoon.com/reactjs-component-lifecycle-methods-a-deep-dive-38275d9d13c0

Ответ 5

Метод жизненного цикла компонента - это функция, которую мы можем определить внутри наших компонентов на основе классов. Если мы решим реализовать эти методы, они будут автоматически вызываться React в определенные моменты в течение жизненного цикла компонентов.

Компонент будет создан и показан в DOM или браузере, и мы можем сделать что-то вроде этого this.setState() что приведет к повторной визуализации компонента, и теоретически в какой-то момент времени компонент будет удален из DOM полностью и прекратить показывать его содержимое на экране.

Вся эта серия событий называется жизненным циклом компонентов.

Эти методы жизненного цикла вызываются в разное время в течение жизненного цикла.

Существует функция constructor(props), которая может быть опционально определена, и если мы это сделаем, она будет автоматически вызываться при создании нового экземпляра компонента.

Есть метод render(), который не является обязательным, мы должны определить его. Метод render() - это функция жизненного цикла, которая вызывается в определенный момент в течение жизненного цикла компонента.

Мы начинаем с вызова constructor(props), затем вызывается метод render(), возвращает некоторое количество jsx, и содержимое становится видимым на экране.

Затем есть другая серия методов жизненного цикла, вызываемых в разные моменты времени.

Во-первых, сразу после появления компонента на экране браузера будет вызван метод жизненного цикла componentDidMount(). Это означает, что если мы определим функцию внутри нашего класса, вне constructor(props), прямо над методом render() мы можем определить метод под названием componentDidMount() следующим образом:

componentDidMount() {

}

render() {

}

Эта функция будет автоматически вызываться один раз, когда компонент впервые отображается на экране. Мы можем поместить код внутрь для настройки или выполнить некоторую начальную загрузку данных или широкий спектр операций, которые мы могли бы выполнить один раз, когда компонент впервые появляется.

После вызова этого метода компонент будет сидеть и ждать обновления. Обновление будет иметь вид this.setState().

После этого компонент обновит или выполнит повторную визуализацию, которая вызовет другой метод жизненного цикла с именем componentDidUpdate(). Если мы определим эту функцию, она будет вызываться автоматически каждый раз, когда компонент обновляет себя.

Компонент будет сидеть сложа руки и ждать другого обновления и componentDidUpdate() снова или много раз.

В какой-то момент мы можем захотеть остановить componentDidUpdate() и именно там мы реализуем componentWillUnmount() и это метод, который мы хотим вызвать, когда мы хотим выполнить очистку нашего компонента.