<p style="margin: 5px 0px; font-family: sans-serif; font-size: 16px;">&nbsp;</p> 

考虑前面部分中的滴答时钟示例（第三章）。
到目前为止，我们只学习了一种更新UI的方法。
我们调用来改变渲染输出：

讯享网 function tick() {
    const element = (
                    Hell world            It is {new Date().toLocaleTimeString()}            );
    ReactDOM.render(
        element,
        document.getElementById('root')
    );
}
setInterval(tick, 1000);

 function Clock(props) {
    return (
                    hello world            It is {props.date.toLocaleTimeString()}            );
}
function tick() {
   ReactDOM.render(
       ,
       document.getElementById('root')
   );
}
setInterval(tick, 1000);

然而，它缺少了一个关键要求：时钟设置一个定时器和每秒更新UI的事实应该是时钟的实现细节。理想情况下，我们要写这一次，并由时钟本身来更新时间：

讯享网 ReactDOM.render(
    ,
    document.getElementById('root')
);

要实现这一点，我们需要添加“state”到时钟组件。

state类似于props，但它是私有的，完全由组件控制。

我们之前提到，定义为类组件具有一些附加功能。 内部state就是：一个只有类组件可用的功能。

您可以通过五个步骤将功能组件（如Clock）转换为类组件 ：

 class Clock extends React.Component {
   render() {
       return (
                          hello world               It is {this.props.date.toLocaleTimeString()}.                  )
   };
}

我们将分为三个步骤把从移动到：

1）在方法中将替换为：

讯享网 class Clock extends React.Component {
    render() {
        return (
                            hello world                It is {this.state.date.toLocaleTimeString()}.                    );
    }
}

2）添加一个赋值初始的类构造函数：

 class Clock extends React.Component {
    constructor(props) {
        super(props);
        this.state = {date: new Date()};
    }
    
    render() {
        return (
                            hello world                It is {this.state.date.toLocalTimeString()}.                    );
    }
}

注意我们如何将props传递给基类的构造函数：

讯享网 constructor(props) {
    super(props);
    this.state = {date: new Date()};
}

类组件应该总是用props调用基类构造函数。

3）从元素中删除 prop：

 ReactDOM.render(
    ,
    document.getElementById('root')
);

我们稍后将定时器代码添加回组件本身。结果如下所示：

讯享网 class Clock extends React.Component {
    constructor(props) {
        super(props);
        this.state = {date: new Date()};
    }
    
    render() {
       return (
                          hello world               It is {this.state.date.toLocaleTimeString()}.                  );
    }
}
ReactDOM.render(
    ,
    document.getElementById('root')
);

接下来，我们将使时钟设置自己的定时器，并每秒更新一次。

在具有许多组件的应用程序中，释放组件在销毁时占用的资源非常重要。
我们想要在第一次将时钟渲染到DOM时设置一个计时器。 这在React中称为。
我们还想清除定时器，当时钟产生的DOM被删除。 这在React中称为。
我们可以在组件类上声明特殊方法，以便在组件装入和卸载时运行一些代码：

 class Clock extends React.Component {
    constructor(props) {
        super(props);        this.state = {date: new Date()};
    }
    
    componentDidMount() {        // 组件已经安装完毕
    }
    
    componentWillUnmount() {        // 组件将要被卸载
    }
    
    render() {
       return (
                          hello world               It is {this.state.date.toLocaleTimeString()}.                  );
    }
}

讯享网 componentDidMount() {
    this.timerID = setInterval(
        () => this.tick(),
        1000
    )
}

注意我们如何保存计时器ID就在这。
虽然是由React本身设置的，并且有一个特殊的含义，如果你需要存储不用于视觉输出的东西，你可以手动地添加额外的字段到类中。
如果你不使用中的东西，它不应该放置在中。
我们将拆除生命周期钩子中的计时器：

 componentWillUnmount() {
    clearInterval(this.timerID);
}

讯享网 class Clock extends React.Component {
    constructor(props) {
        super(props);
        this.state = {date: new Date()};
    }
    
    componentDidMount() {
        this.timerID = setInterval(
            () => this.tick(),
            1000
        )
    }
    
    componentWillUnmount() {
        clearInterval(this.timerID);
    }
    tick() {
        this.setState({
            date: new Date()
        });
    }
    
    render() {
       return (
                          hello world               It is {this.state.date.toLocaleTimeString()}.                  );
    }
}
ReactDOM.render(
    ,
    document.getElementById('root')
);

现在时钟每秒钟都在滴答地走，棒不棒。。。。

让我们快速回顾一下发生了什么以及调用方法的顺序：

讯享网

关于你应该了解三件事情:

不要直接修改state

例如，这将不会重新渲染组件：

 // 这是错误的this.state.comment = 'hello';

应该使用代替：

讯享网 // 这是正确的this.setState({comment: 'hello'});

唯一可以分配的地方是构造函数。

state更新可能是异步的

React可以将多个用批处理为单个更新以实现较高的性能。
因为和可能是异步更新的，你不应该依赖它们的值来计算下一个state。
例如，此代码可能无法更新计数器：

 // 这是错误的this.setState({
    counter: this.state.counter + this.props.increment,
});

要解决它，应该使用回调函数而不是对象来调用。 回调函数将接收先前的state作为第一个参数，并将应用更新时的作为第二个参数：

讯享网 // 这是正确的this.setState((prevState, props) => ({
    counter: prevState.counter + props.increment
}));

我们使用上面的箭头函数，但它也可以与常规函数一起使用：

 // 这同样也是正确的，将剪头函数改为普通函数
this.setState(function(prevState, props) {
   return {
       counter: prevState.counter + prps.increment
   }
});

state更新是经过合并的

讯享网 constructor(props) {
    super(props);
    this.state = {
        posts: [],
        comments: []
    }
}

然后，您可以使用单独的来独立地更新它们：

 componentDidMount() {
    fetchPosts().then(response => {
        this.setState({
            posts: response.posts
        });
    });
    
    fetchComments().then(response => {
        this.setState({
            comments: response.comments
        }});
    });
}

合并很浅，所以不会波及。仅仅只是完全替换了而已。

父组件和子组件都不能知道某个组件是有State的还是无State的，并且它们不应该关心它是否为功能组件或类组件。

这就是为什么State通常被设置为局部变量或封装到组件内部。 除了拥有和设置它的组件之外的其他任何组件都不能访问它。

组件可以选择将其state作为props传递给其子组件：

讯享网 Is is {this.state.date.toLocaleTimeString()}.

这也适用于用户定义的组件：

组件将在其中接收，并且不知道它是来自时钟的，还是：

讯享网 function FormattedData(props) {
    return Is is {props.date.toLocaleTimeString()}.;
}

这通常被称为或数据流。 任何state总是由一些特定组件拥有，并且从该state派生的任何数据或UI只能影响树中的“下面”组件。

如果你想象一个组件树作为props的瀑布流，每个组件的state就像一个额外的水源，它可以在任意点连接它，但也向下流。

为了显示所有组件都是真正隔离的，我们可以创建一个App组件来渲染三个：

 function App() {
    return (
                                                        );
}
ReactDOM.render(
    ,
    document.getElementById(‘root’)
);

每个时钟设置自己的定时器并独立更新。在React应用程序中，组件是有状态还是无状态被视为可能随时间更改的组件的实现细节。 您可以在有状态组件内使用无状态组件，反之亦然。