Updating

In React, "updating" is a phase of the component lifecycle that happens when changes occur in the props or state of a component, causing it to re-render. This phase comprises several lifecycle methods including: shouldComponentUpdate(), componentWillUpdate(), and componentDidUpdate().

shouldComponentUpdate(nextProps, nextState): This method decides whether a re-rendering process is required or not. It is called just before the rendering process starts. The default implementation returns true. If you are sure that in some situations your component doesn't need to be updated, you can override this method to improve performance.

componentWillUpdate(nextProps, nextState): This method is executed just before the re-rendering process starts. However, you can't use this.setState() in this method. If you need to change the state based on the new props, you do so in getDerivedStateFromProps() method.

componentDidUpdate(prevProps, prevState): This method is executed after the re-rendering process. Unlike componentWillUpdate(), you can use this.setState() here, but be careful to wrap it in a condition, or you'll cause an infinite loop.

Here is a simple code snippet:

```jsx
class ExampleComponent extends React.Component {

shouldComponentUpdate(nextProps, nextState){
//decide whether to proceed with rendering or not
}

componentWillUpdate(nextProps, nextState){
//perform any preparations for an upcoming update
}

componentDidUpdate(prevProps, prevState){
//You can call setState() here, but it must be wrapped
//Inside a condition to prevent endless loop because it will trigger another componentDidUpdate() call.
}

render() {
return (
<div>
{/* component code */}
</div>
);
}
}
```
Remember that these lifecycle methods are only called during updates, not in the initial render. Remember to use them for their respective cases to avoid unnecessary re-renders and improve app performance.