How to use Immutable and PureRender to improve React performance - Codes Helper

there is a solution for react performance optimization in "going deep into the React technology stack". The original text is as follows
(P106-P107 2.6 component performance optimization):

as mentioned earlier, shouldComponentUpdate is the most commonly used method for React performance optimization, but it returns true by default, that is, it always executes the render method, then makes a Virtual DOM comparison, and finds out whether you need to update the real DOM. This often brings a lot of unnecessary rendering. Of course, we can also use deep copy and deep comparison in shouldComponentUpdate to avoid unnecessary render, but deep copy and deep comparison are generally very expensive options.

Immutable.js  ===  is   render     shouldComponentUpdate :

import React, { Component } from "react";
import { is } from "immutable";

class App extends Component {
    shouldComponentUpdate(nextProps, nextState) {
        const thisProps = this.props || {};
        const thisState = this.state || {};
        if (
            Object.keys(thisProps).length !== Object.keys(nextProps).length ||
            Object.keys(thisState).length !== Object.keys(nextState).length
        ) {
            return true;
        }
        for (const key in nextProps) {
            if (
                nextProps.hasOwnProperty(key) &&
                !is(thisProps[key], nextProps[key])
            ) {
                return true;
            }
        }
        for (const key in nextState) {
            if (
                nextState.hasOwnProperty(key) &&
                !is(thisState[key], nextState[key])
            ) {
                return true;
            }
        }
        return false;
    }
}

I wonder why the author has to make it so complicated. Wouldn"t it be easier to do something like this:

import React, { Component } from "react";
import { is } from "immutable";

class App extends Component {
    shouldComponentUpdate(nextProps, nextState) {
        const thisProps = this.props || {};
        const thisState = this.state || {};
        if (is(thisProps, nextProps) && is(thisState, nextState)) {
            return false
        } else { 
            return true
        }
    }
}

Please advise me what are the defects of my method and what are the advantages of the original author"s method