重新渲染react-redux组件

Question

I am using react-redux code structure and this is my first try with react-redux.I have cloned a github repository from Here and started editing it.

My directory structure:

Here schema is parent component and header and tables are 2 child components.Tables is showing data from localstorage through redux store.

Initializing store:

 const initialState = JSON.parse(window.localStorage.getItem('test'));
 const store = createStore(Reducers, initialState, compose(applyMiddleware(...middleware), extension));

Now an event is triggered from Header and sent to schema and in the response of this event schema is updating localstorage by requesting to server and saving server's response in localstorage as follows:

Schema.js:

class Schema extends PureComponent {
constructor(props) {
    super(props);
    this.table = ''; 
    getTables();       
}
myCallback = () => {//triggered by child(Header)
   getTables();       
}
getTables = () => {
  axios.get(url)
        .then((response) => {
            if(response.data.status==0){ 
 window.localStorage.setItem('test',JSON.stringify(response.data));
   this.tables=JSON.parse(window.localStorage.getItem('test'))
    });
}
render() {
 console.log(this.tables);//this is giving updated value at each updation
    return (
        <div className='container-fluid'>
            <Header callbackFromParent={ this.myCallback } />
            <br />
            <br />
            <Tables val={ this.tables } />
        </div>
    );
  }
}

Here is code for Tables.js:

   class Tables extends Component {
   props: Props
   render() {
   let {tables,val } = this.props;
   console.log(JSON.parse(window.localStorage.getItem('test')));//this is giving updated value at each updation in localstorage
   console.log(val);//this is also giving updated value at each updation in localstorage
   tables=val;
   console.log(tables);this is also updating in realtime.      
   return (
        <div className='table-wrapper'>
            { tables.map((table) => (
                <Table
                    key={ table.id }
                    data={ table }
                />
            ))}
        </div>
       );
     }
   }

   type Props = {
     tables: Array<TableType>
   };

The issue is whenever header triggers callback, schema updates value of localstorage, this updation also re render Tables component. Also an updated value can be seen in render of Tables component but the tables which are shown are from previous saved value. To get current value in tables, we need to refresh the page.

is it a mistake in code flow or i need something else for this?

Answer 1

The idea is that react will trigger rendering of component whenever the component state or props is updated.

If the component props are updated in parent component you will still need to update the component state to make the next render in inner component

The key of this is using componentWillReceiveProps

I updated your code with the code below:

Basically i did the following:

1- I used component state for Schema , Tables , and Table

2- I used this.setState whenever i need to make updates to state (this is very important)

3- I make sure that when a component props is updated in parent i update the component state as well using componentWillReceiveProps and this will make the new render with updated data

Schema component:

class Schema extends Component {
    constructor(props) {
        super(props);
        this.state = { tables : { } }
        this.getTables = this.getTables.bind(this);
        this.myCallback  = this.myCallback.bind(this);
    }

    componentWillMount(){
        this.getTables();
    }


    myCallback = () => {
       //triggered by child(Header)
       this.getTables();
    }


    getTables = () => {
      axios.get(url)
      .then((response) => {
            if(response.data.status==0)
            {
                window.localStorage.setItem('test',JSON.stringify(response.data));
                this.setState({
                    tables : JSON.parse(window.localStorage.getItem('test'))
                });
            }
        );
    }


    render() {
        //this is giving updated value at each updation
        console.log(this.state.tables);
        return (
            <div className='container-fluid'>
                <Header callbackFromParent={ this.myCallback } />
                <br />
                <br />
                <Tables tables={this.state.tables} />
            </div>
        );
    }
}

Tables Component

 class Tables extends Component {
   constructor(props) {
        super(props);
        this.state = { tables : { }  }
    }


    componentWillMount(){
        this.setState({
            tables : this.props.tables
        })
    }


    componentWillReceiveProps(nextProps){
        this.setState({
            tables : nextProps.tables
        })
    }


   render() {
        console.log(JSON.parse(window.localStorage.getItem('test')));//this is giving updated value at each updation in localstorage
        console.log(this.state.tables);//this is also giving updated value at each updation in localstorage
       return (
            <div className='table-wrapper'>
                { this.state.tables.map((table) => (
                    <Table key={ table.id } data={ table } />
                ))
                }
            </div>
           );
    }
}

And finally a dummy Table component to show that you will also need to handle props update using componentWillReceiveProps to make sure each individual table component did render after props update

And probably this is where you have the issue ... because the tables are showing old data but the console.log of Tables component is logging new data which means Each individual Table component is not rending after the update

 class Table extends Component {
   constructor(props) {
        super(props);
        this.state = { data : { }  }
    }


    componentWillMount(){
        this.setState({
            data : this.props.data
        })
    }


    componentWillReceiveProps(nextProps){
        this.setState({
            data : nextProps.data
        })
    }


   render() {
       console.log(this.state.data);
       return (
            <table className='table'>
                {this.state.data}
                //use your table data here
            </table>
           );
    }
}

Important Edit:

As mentioned by react documentation componentWillReceiveProps might get called even if the props have not changed, thats why in some situation you might need to consider comparing this.props with nextProps to make sure that you really got new updated props and based on that you update the component state ....