• React 的学习笔记

    React 的学习笔记

    参考文档：https://www.runoob.com/react/react-tutorial.html

    文章目录

    1. 简介

    React 是一个用于构建用户界面的 JAVASCRIPT 库。

    React 主要用于构建 UI，很多人认为 React 是 MVC 中的 V （视图）。

    React 起源于 Facebook 的内部项目，用来架设 Instagram 的网站，并于 2013 年5月 开源。

    React 拥有较高的性能，代码逻辑非常简单，越来越多的人已开始关注和使用它。

    React 官网：https://reactjs.org/

    React 特点

    1. 声明式设计 - React采用声明范式，可以轻松描述应用。
    2. 高效 - React 通过对 DOM的模拟，最大限度地减少与DOM的交互。
    3. 灵活 - React 可以与已知的库或框架很好地配合。
    4. JSX - JSX 是 JavaScript 语法的扩展。 React 开发不一定使用 JSX，但建议使用它。
    5. 组件 - 通过 React 构建组件，使得代码更加容易得到复用，能够很好的应用在大项目的开发中。
    6. 单向响应的数据流 - React 实现了单向响应的数据流，从而减少了重复代码，这也是它为什么比传统数据绑定更简单。

    React第一个实例

    当前 React 版本为 16.4.0。

    



Hello React!





 

    

 



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    实例解析：

    实例中引入了三个库：react.development.min.js、react-dom.development.min.js 和 babel.min.js:

    • react.min.js - React 的核心库
    • react-dom.min.js - 提供与 DOM 相关的功能
    • babel.min.js - Babel 可以将 ES6 代码转为 ES5 代码，这样救恩那个在目前不支持 ES6 浏览器上执行 React 代码。Babel 内嵌了对 JSX 的支持。通过将 Babel 和 babel-sublime 包（package）一同使用可以让源码的语法渲染上升到一个全新的水平。
    ReactDOM.render(
    
    Hello, world!
    ,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4

    以上代码将一个 h1 标题，插入 id="example"节点中。
    注意：如果需要使用JSX，则

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    注意

    由于 JSX 就是 JavaScript，一些标识符像 class 和 for 不建议作为 XML属性名。作为替代，React DOM 使用 className 和 htmlFor 来做对应的属性。

    使用 JSX

    JSX 看起来类似 HTML，我们可以看下示例：

    ReactDOM.render(
    
    Hello, world!
    ,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4

    我们可以在以上代码中嵌套多个 HTML 标签，需要使用一个 div 元素包裹它，实例中的 p 标签添加了自定义属性 data-myattribute，添加自定义属性需要使用 data-前缀。

    ReactDOM.render(
    <div>
    <h1>菜鸟教程</h1>
    <h2>欢迎学习 React</h2>
    <p data-myattribute = "somevalue">这是一个很不错的 JavaScript 库!</p>
    </div>
    ,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    独立文件

    你的 React JSX 代码可以放在一个独立文件上，例如我们创建一个 helloworld_react.js 文件，代码如下：

    ReactDOM.render(
  
    Hello, world!
    ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4

    然后在 HTML 文件中引入该 JS文件：

    
  
    



    • 1
    • 2
    • 3
    • 4

    JavaScript 表达式

    我们可以在 JSX 中使用 JavaScript 表达式。表达式写在花括号 {} 中。实例如下：

    ReactDOM.render(
    
    
      
    {1+1}
    
    
    
    ,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    在 JSX 中不能使用 if else 语句，但可以使用 conditional(三元运算) 表达式来替代。如下实例中如果变量 i 等于 1 浏览器将输出 true，如果修改 i 的值，则会输出 false。

    ReactDOM.render(
    
    
      
    {i == 1 ? 'True!' : 'False'}
    
    
    
    ,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    样式

    React 推荐使用内联样式。我们可以使用 camelCase 语法来设置内联样式。React 会在指定元素数字后自动添加 px。以下实例演示了为 h1 元素添加 mystyle 内联样式：

    var myStyle = {
    fontSize: 100,
    color: '#FF0000'
};
ReactDOM.render(
    
    菜鸟教程
    ,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    注释

    注释是需要写在花括号中，实例如下：

    ReactDOM.render(
    
    
    
    菜鸟教程
    
    {/*注释...*/}
     
    ,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    数组

    JSX 允许在模板中插入数组，数组会自动展开所有成员：

    var arr = [
  
    菜鸟教程
    ,
  
    学的不仅是技术，更是梦想！
    ,
];
ReactDOM.render(
  
    {arr}
    ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    4. React 组件

    组件可以使得我们的应用更容易来管理。

    接下来我们封装一个输出 “Hello World!” 的组件，组件名为 HelloMessage：

    function HelloMessage(props) {
    return 
    Hello World!
    ;
}
 
const element = ;
 
ReactDOM.render(
    element,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    实例解析：

    1、可以使用函数定义了一个组件：

    function HelloMessage(props) {
    return 
    Hello World!
    ;
}

    • 1
    • 2
    • 3

    也可以使用 ES6 class 来定义一个组件：

    class Welcome extends React.Component {
  render() {
    return 
    Hello World!
    ;
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5

    2、const element = ; 为用户自定义的组件。

    注意，原生 HTML 元素以小写字母开头，而自定义的 React 类名以大写字母开头，比如 HelloMessage 不能写成 helloMessage。除此之外还需要注意组件类只能包含一个顶层标签，否则也会报错。

    如果我们需要向组件传递参数，可以使用 this.props 对象，实例如下：

    function HelloMessage(props) {
    return 
    Hello {props.name}!
    ;
}
 
const element = ;
 
ReactDOM.render(
    element,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    以上实例中 name 属性通过 props.name 来获取。

    注意，在添加属性时，class 属性需要写成 className，for 属性需要写成 htmlFor，这是因为 class 和 for 是 JavaScript 的保留字。

    复合组件

    可以通过创建多个组件来合成一个组件，即把组件的不同功能点进行分离。

    以下示例我们实现了输出网站名字和网址的组件。

    function Name(props) {
    return 
    网站名称：{props.name}
    ;
}
function Url(props) {
    return 
    网站地址：{props.url}
    ;
}
function Nickname(props) {
    return 
    网站小名：{props.nickname}
    ;
}
function App() {
    return (
    
    
        
        
        
    
    
    );
}
 
ReactDOM.render(
     ,
    document.getElementById('example')

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    5. React State(状态)

    React 把组件看成是一个状态机 （State Machines）。通过与用户的交互，实现不同状态，然后渲染 UI，让用户界面和数据保持一致。

    React里，只需要更新组件的state，然后根据新的 state 重新渲染用户界面（不要操作 DOM）。

    以下示例创建一个名称扩展为 React.Component 的 ES6 类，在 render() 方法中使用 this.state 来修改当前的时间。添加一个类构造函数来初始化状态 this.state，类组件应始终使用 props 调用基础构造函数。

    class Clock extends React.Component {
  constructor(props) {
    super(props);
    this.state = {date: new Date()};
  }
 
  render() {
    return (
      
    
        
    Hello, world!
    
        
    现在是 {this.state.date.toLocaleTimeString()}.
    
      
    
    );
  }
}
 
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    下面，将使 Clock 设置自己的计时器并每秒更新一次。

    将生命周期方法添加到类中

    在具有许多组件的应用程序中，在销毁时释放组件所占用的资源非常重要。

    每当 Clock 组件第一次加载到 DOM 中的时候，我们都想成成定时器。这在 React 中被称为 挂载。

    同样，每当Clock 生成的这个 DOM 被移除的时候，我们也会想要清除定时器，这在 React 中被称为 卸载。

    我们可以在组件类上声明特殊的方法，当组件挂载或卸载时，来运行一些代码：

    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!
    
        
    现在是 {this.state.date.toLocaleTimeString()}.
    
      
    
    );
  }
}
 
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    实例解析：

    componentDidMount() 与 componentWillUnmount 方法被称作生命周期钩子。

    在组件输出到 DOM 后会执行 componentDidMount() 钩子，我们就可以在这个钩子上设置一个定时器。 this.timerID 为定时器的 ID，我们可以在 componentWillUnmount() 钩子中卸载定时器。

    代码执行顺序：

    1. 当 被传递给ReactDOM.render() 时，React 调用 Clock 组件的构造函数。由于 Clock 需要显示当前时间，所以使用包含当前时间的对象来初始化 this.state。我们稍后会更新此状态。
    2. React 然后调用 Clock 组件的 render() 方法。这是 React 了解屏幕上应该显示什么内容，然后 React 更新 DOM 以匹配 Clock 的渲染输出。
    3. 当 Clock 的输出插入到 DOM 中时，React 调用 componentDidMount() 生命周期钩子，在其中，Clock 组件要求浏览器设置一个定时器，每秒钟调用一次 tick()。
    4. 浏览器每秒钟调用 tick() 方法。在其中，Clock 组件通过使用包含当前时间的对象调用 setState() 来调度 UI 更新。通过调用 setState()，React 知道状态已经改变，并再次调用 render() 方法来确定屏幕上应当显示什么。这一次，render() 方法中的 this.state.date 将不同，所以渲染输出将包含更新的时间，并相应地更新 DOM。
    5. 一旦 Clock 组件被从 DOM 中移除，React 会调用 componentWillUnmount() 这个钩子函数，定时器也就会被清除。

    数据自顶向下流动

    父组件或子组件都不能知道某个组件是有状态还是无状态，并且它们不应该关心某组件是被定义为一个函数还是一个类。

    这就是为什么状态通常被称为局部或封装。除了拥有并设置它地组件外，其它组件不可访问。

    以下示例中 FormattedDate 组件将在其属性中接受到 date 值，并且不知道它是来自 Clock 状态、还是来自 Clock 的 属性、亦或手工输入：

    function FormattedDate(props) {
  return 
    现在是 {props.date.toLocaleTimeString()}.
    ;
}
 
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!
    
        
      
    
    );
  }
}
 
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    这通常被称为自顶向下或单向数据流。任何状态始终由某些特定组件所有，并且从该状态导出的任何数据或 UI 只能影响树中下方的组件。

    如果你想象一个组件树作为属性的瀑布，每个组件的状态就像一个额外的水源，它连接在一个任意点，但也流下来。为了表明所有组件都是真正隔离的，我们可以创建一个 App 组件，它渲染三个 Clock：

    function FormattedDate(props) {
  return 
    现在是 {props.date.toLocaleTimeString()}.
    ;
}
 
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!
    
        
      
    
    );
  }
}
 
function App() {
  return (
    
    
      
      
      
    
    
  );
}
 
ReactDOM.render(, document.getElementById('example'));

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    以上实例中每个 Clock 组件都建立了自己的定时器并且独立更新。

    在 React 应用程序中，组件是有状态还是无状态被认为是可能随时间而变化的组件的实现细节。

    我们可以在有状态组件中使用无状态组件，也可以在无状态组件中使用有状态组件。

    6. React Props

    state 和 props 主要的区别在于 props 是不可变的，而 state 可以根据与用户交互来改变。这就是为什么有写容器组件需要定义 state 来更新和修改数据。而子组件只能通过 props 来传递数据。

    使用 Props

    以下实例演示了如何在组件中使用 props：

    function HelloMessage(props) {
    return 
    Hello {props.name}!
    ;
}
 
const element = ;
 
ReactDOM.render(
    element,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    实例中 name 属性通过 props.name 来获取。

    默认 Props

    可以通过组件类的 defaultProps 属性为 props 设置默认值 ，实例如下：

    class HelloMessage extends React.Component {
  render() {
    return (
      
    Hello, {this.props.name}
    
    );
  }
}
 
HelloMessage.defaultProps = {
  name: 'Runoob'
};
 
const element = ;
 
ReactDOM.render(
  element,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    State 和 Props

    以下实例演示了如何在应用中组合使用 state 和 props。我们可以在父组件中设置 state，并通过在子组件上使用 props 将其传递到子组件上。在 render 函数中，我们设置name 和 site 来获取父组件传递过来的数据。

    class WebSite extends React.Component {
  constructor() {
      super();
 
      this.state = {
        name: "菜鸟教程",
        site: "https://www.runoob.com"
      }
    }
  render() {
    return (
      
    
        
        
      
    
    );
  }
}
 
 
 
class Name extends React.Component {
  render() {
    return (
      
    {this.props.name}
    
    );
  }
}
 
class Link extends React.Component {
  render() {
    return (
      
        {this.props.site}
      
    );
  }
}
 
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    Props 验证

    React.PropTypes 在 React v15.5 版本后已经移到了 prop-types 库。

    

    • 1

    Props 验证使用 propTypes，它可以保证我们的应用组件被正确使用，React.PropTypes 提供很多验证器（validator）来验证传入数据是否有效。当向 props 传入无效数据时，JavaScript 控制台会跑出警告。

    以下实例创建一个 Mytitle 组件，属性 title 是必须的且是字符串，非字符串类型会自动转换为字符串：

    React 16.4 实例：

    var title = "菜鸟教程";
// var title = 123;
class MyTitle extends React.Component {
  render() {
    return (
      
    Hello, {this.props.title}
    
    );
  }
}
 
MyTitle.propTypes = {
  title: PropTypes.string
};
ReactDOM.render(
    ,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    React 15.4 实例：

    var title = "菜鸟教程";
// var title = 123;
var MyTitle = React.createClass({
  propTypes: {
    title: React.PropTypes.string.isRequired,
  },
 
  render: function() {
     return 
     {this.props.title} 
    ;
   }
});
ReactDOM.render(
    ,
    document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    更多验证器说明如下：

    更多验证器说明如下：

MyComponent.propTypes = {
    // 可以声明 prop 为指定的 JS 基本数据类型，默认情况，这些数据是可选的
   optionalArray: React.PropTypes.array,
    optionalBool: React.PropTypes.bool,
    optionalFunc: React.PropTypes.func,
    optionalNumber: React.PropTypes.number,
    optionalObject: React.PropTypes.object,
    optionalString: React.PropTypes.string,
 
    // 可以被渲染的对象 numbers, strings, elements 或 array
    optionalNode: React.PropTypes.node,
 
    //  React 元素
    optionalElement: React.PropTypes.element,
 
    // 用 JS 的 instanceof 操作符声明 prop 为类的实例。
    optionalMessage: React.PropTypes.instanceOf(Message),
 
    // 用 enum 来限制 prop 只接受指定的值。
    optionalEnum: React.PropTypes.oneOf(['News', 'Photos']),
 
    // 可以是多个对象类型中的一个
    optionalUnion: React.PropTypes.oneOfType([
      React.PropTypes.string,
      React.PropTypes.number,
      React.PropTypes.instanceOf(Message)
    ]),
 
    // 指定类型组成的数组
    optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
 
    // 指定类型的属性构成的对象
    optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
 
    // 特定 shape 参数的对象
    optionalObjectWithShape: React.PropTypes.shape({
      color: React.PropTypes.string,
      fontSize: React.PropTypes.number
    }),
 
    // 任意类型加上 `isRequired` 来使 prop 不可空。
    requiredFunc: React.PropTypes.func.isRequired,
 
    // 不可空的任意类型
    requiredAny: React.PropTypes.any.isRequired,
 
    // 自定义验证器。如果验证失败需要返回一个 Error 对象。不要直接使用 `console.warn` 或抛异常，因为这样 `oneOfType` 会失效。
    customProp: function(props, propName, componentName) {
      if (!/matchme/.test(props[propName])) {
        return new Error('Validation failed!');
      }
    }
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56

    7. React 事件处理

    React 元素的事件处理和 DOM 元素 类似。但是有一点语法上的不同：

    • React 事件绑定属性的命名采用驼峰式写法，而不是小写。
    • 如果采用 JSX 的语法你需要传入一个函数作为事件处理函数，而不是一个 字符串（DOM 元素的写法）

    HTML 通常写法是：

    

    • 1
    • 2
    • 3

    React 中写法为：

    

    • 1
    • 2
    • 3

    在 React 中另一个不同是你不能使用返回 false 的方式阻止默认行为，你必须明确使用 preventDefault。例如，通常我们在 HTML 中阻止链接默认打开一个新页面，可以这样写：

    
  点我


    • 1
    • 2
    • 3

    在 React 的写法为：

    function ActionLink() {
  function handleClick(e) {
    e.preventDefault();
    console.log('链接被点击');
  }
 
  return (
    
      点我
    
  );
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    实例中 e 是一个合成事件。

    使用 React 的时候通常你不需要使用 addEventListener 为一个已创建的 DOM 元素添加监听器。你仅仅需要在这个元素初始渲染的时候提供一个监听器。

    当你使用 ES6 class 语法来定义一个组件的时候，事件处理器会成为类的一个方法。例如，下面的 Toggle 组件渲染一个让用户切换开关状态的按钮：

    class Toggle extends React.Component {
  constructor(props) {
    super(props);
    this.state = {isToggleOn: true};
 
    // 这边绑定是必要的，这样 `this` 才能在回调函数中使用
    this.handleClick = this.handleClick.bind(this);
  }
 
  handleClick() {
    this.setState(prevState => ({
      isToggleOn: !prevState.isToggleOn
    }));
  }
 
  render() {
    return (
      
    );
  }
}
 
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    必须谨慎对待 JSX 回调函数中的 this，类的方法默认是不会绑定 this 的。如果你忘记绑定this.handleClick 并把它传入 onClick，当你调用这个函数的时候 this 的值会是 undefined。

    这并不是 React 的特殊行为：它是函数如何在 JavaScript 中运行的一部分。通常情况下，如果你没有在方法后面添加()，例如 onClick={this.handleClick} ，你应该为 这个方法绑定 this。

    如果使用 bind 让你很烦，这里有两种方式可以解决。如果你正在使用实验性的属性初始化器语法，你可以使用属性初始化器来正确的绑定回调函数：

    class LoggingButton extends React.Component {
  // 这个语法确保了 `this` 绑定在  handleClick 中
  // 这里只是一个测试
  handleClick = () => {
    console.log('this is:', this);
  }
 
  render() {
    return (
      
    );
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    如果你没有使用属性初始化器语法，你可以在回调函数中使用箭头函数：

    class LoggingButton extends React.Component {
  handleClick() {
    console.log('this is:', this);
  }
 
  render() {
    //  这个语法确保了 `this` 绑定在  handleClick 中
    return (
      
    );
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    使用这个语法有个问题就是每次 LoggingButton 渲染的时候都会创建一个不同的回调函数。在大多数情况下，这没有问题。然而如果这个回调函数作为一个属性值传入低阶组件，这些组件可能会进行额外的重新渲染。我们通常建议在构造函数中绑定或使用属性初始化器语法来避免这类性能问题。

    向事件处理程序传递参数

    通常我们会为事件处理程序传递额外的参数。例如，若是 id 是你要删除的那一行的 id，以下两种方式都可以向事件处理程序传递参数：

    


    • 1
    • 2

    上述两种方式是等价的。

    上面两个例子中，参数 e 作为 React 事件对象将会被作为第二个参数进行传递。通过箭头函数的方式，事件对象必须显示的进行传递，但是通过 bind 的方式，事件对象以及更多的参数将会被隐式的进行传递。

    值得注意的是，通过 bind 方式向监听函数传参，在类组件中定义的监听函数，事件对象 e 要排在所传递参数的后面，例如：

    class Popper extends React.Component{
    constructor(){
        super();
        this.state = {name:'Hello world!'};
    }
    
    preventPop(name, e){    //事件对象e要放在最后
        e.preventDefault();
        alert(name);
    }
    
    render(){
        return (
            
    
                
    hello
    
                {/* 通过 bind() 方法传递参数。 */}
                Click
            
    
        );
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    8. React 条件渲染

    在 React 中，你可以创建不同的组件来封装各种你需要的行为。然后还可以根据应用的状态变化只渲染其中的一部分。

    React 中的条件渲染和 JavaScript 中的一致，使用 JavaScript 操作符 if 或条件运算符来创建表示当前状态的元素，然后让 React 根据它们来更新 UI。

    先来看两个组件：

    function UserGreeting(props) {
  return 
    欢迎回来!
    ;
}

function GuestGreeting(props) {
  return 
    请先注册。
    ;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    我们将创建一个 Greeting 组件，它会根据用户是否登录来显示其中之一：

    function Greeting(props) {
  const isLoggedIn = props.isLoggedIn;
  if (isLoggedIn) {
    return ;
  }
  return ;
}
 
ReactDOM.render(
  // 尝试修改 isLoggedIn={true}:
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    元素变量

    可以使用变量来储存元素。它可以帮助你有条件的渲染组件的一部分，而输出的其它部分不会更改。

    在下面的例子中，我们将要创建一个名为 LoginControl 的有状态的组件。

    它会根据当前的状态来渲染 或 ，它也将渲染前面例子中的 。

    class LoginControl extends React.Component {
  constructor(props) {
    super(props);
    this.handleLoginClick = this.handleLoginClick.bind(this);
    this.handleLogoutClick = this.handleLogoutClick.bind(this);
    this.state = {isLoggedIn: false};
  }
 
  handleLoginClick() {
    this.setState({isLoggedIn: true});
  }
 
  handleLogoutClick() {
    this.setState({isLoggedIn: false});
  }
 
  render() {
    const isLoggedIn = this.state.isLoggedIn;
 
    let button = null;
    if (isLoggedIn) {
      button = ;
    } else {
      button = ;
    }
 
    return (
      
    
        
        {button}
      
    
    );
  }
}
 
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    与运算符 &&

    你可以通过用花括号包裹代码在 JSX 中嵌入任何表达式，也包括 JavaScript 的逻辑与 && ，它可以方便地条件渲染一个元素。

    function Mailbox(props) {
  const unreadMessages = props.unreadMessages;
  return (
    
    
      
    Hello!
    
      {unreadMessages.length > 0 &&
        
    
          您有 {unreadMessages.length} 条未读信息。
        
    
      }
    
    
  );
}
 
const messages = ['React', 'Re: React', 'Re:Re: React'];
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    在 JavaScript 中，true && expression 总是返回 expression，而 false && expression 总是返回 false。因此，如果条件是 true，&& 右侧地元素就会被渲染，如果是 false，React 会忽略并跳过它。

    三目运算符

    条件渲染的另一种方法是使用 JavaScript 的条件运算符：

    condition ? true : false。

    • 1

    在下面的例子中，我们用它来有条件的渲染一小段文本。

    render() { 
    const isLoggedIn = this.state.isLoggedIn; 
    return (
The user is {isLoggedIn ? 'currently' : 'not'} logged in.
); }

    • 1
    • 2
    • 3
    • 4
    • 5

    同样它也可以用在较大的表达式中，虽然不太直观：

    render() {
  const isLoggedIn = this.state.isLoggedIn;
  return (
    
    
      {isLoggedIn ? (
        
      ) : (
        
      )}
    
    
  );
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    阻止组件渲染

    在极少数情况下，你可能希望隐藏组件，即使它被其它组件渲染。让 render 方法返回 null 而不是它的渲染结果即可实现。

    在下面的例子中， 根据属性 warn 的值条件渲染。如果 warn 的值是 false，则组件不会渲染：

    function WarningBanner(props) {
  if (!props.warn) {
    return null;
  }
 
  return (
    
    
      警告!
    
    
  );
}
 
class Page extends React.Component {
  constructor(props) {
    super(props);
    this.state = {showWarning: true}
    this.handleToggleClick = this.handleToggleClick.bind(this);
  }
 
  handleToggleClick() {
    this.setState(prevState => ({
      showWarning: !prevState.showWarning
    }));
  }
 
  render() {
    return (
      
    
        
        
      
    
    );
  }
}
 
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    9. React 列表 & Keys

    我们可以使用 JavaScript 的 map()方法来创建列表。

    使用 map() 方法遍历数组生成了一个 1 到 5 的数字列表：

    const numbers = [1, 2, 3, 4, 5];
const listItems = numbers.map((numbers) =>
  
  • {numbers}
    • 
);
 
ReactDOM.render(
  
      {listItems}
    ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    可以将以上实例重构成一个组件，组件接受数组参数，每个列表元素分配一个 key，不然会出现警告 a key should be provided for list items，意思就是需要包含 key：

    function NumberList(props) {
  const numbers = props.numbers;
  const listItems = numbers.map((number) =>
    
  • 
      {number}
    
    • 
  );
  return (
    
      {listItems}
    
  );
}
 
const numbers = [1, 2, 3, 4, 5];
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    Keys

    Keys 可以在 DOM 中的某些元素被增加或删除的时候帮助 React 识别那些元素发生了变化。因此你应当给数组中的每一个元素赋予一个确定的标识。

    const numbers = [1, 2, 3, 4, 5];
const listItems = numbers.map((number) =>
  
  • 
    {number}
  
    • 
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    一个元素的 key 最好是这个元素在列表中拥有的一个独一无二的字符串。通常，我们使用来自数据的 id 作为元素的 key：

    const todoItems = todos.map((todo) =>
  
  • 
    {todo.text}
  
    • 
);

    • 1
    • 2
    • 3
    • 4
    • 5

    当元素没有确定的 id 时，你可以使用他的序列号索引 index 作为 key：

    const todoItems = todos.map((todo, index) =>
  // 只有在没有确定的 id 时使用
  
  • 
    {todo.text}
  
    • 
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    如果列表可以重新排序，我们不建议使用索引来进行排序，因为这会导致渲染变得很慢。

    用keys提取组件

    元素的 key 只有在它和它的兄弟节点对比时才有意义。

    比方说，如果你提取出一个 ListItem 组件，你应该把 key 保存在数组中的这个 元素上，而不是放在 ListItem 组件中的

  • 元素上。

    错误的示范

    function ListItem(props) {
  const value = props.value;
  return (
    // 错啦！你不需要在这里指定key:
    
  • 
      {value}
    
    • 
  );
}

function NumberList(props) {
  const numbers = props.numbers;
  const listItems = numbers.map((number) =>
    //错啦！元素的key应该在这里指定：
    
  );
  return (
    
      
      {listItems}
    
    
  );
}

const numbers = [1, 2, 3, 4, 5];
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    key的正确使用方式

    function ListItem(props) {
  // 对啦！这里不需要指定key:
  return 
  • {props.value}
    • ;
}
 
function NumberList(props) {
  const numbers = props.numbers;
  const listItems = numbers.map((number) =>
    // 又对啦！key应该在数组的上下文中被指定
    
 
  );
  return (
    
      
      {listItems}
    
    
  );
}
 
const numbers = [1, 2, 3, 4, 5];
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    当你在 map() 方法的内部调用元素时，你最好随时记得为每一个元素加上一个独一无二的key。

    元素的 key 在他的兄弟元素之间应该唯一

    数组元素中使用的 key 在其兄弟之间应该是独一无二的。然而，它们不需要是全局唯一的。当我们生成两个不同的数组时，我们可以使用相同的键。

    function Blog(props) {
  const sidebar = (
    
      
      {props.posts.map((post) =>
        
    • 
          {post.title}
        
      • 
      )}
    
    
  );
  const content = props.posts.map((post) =>
    
    
      
    {post.title}
    
      
    {post.content}
    
    
    
  );
  return (
    
    
      {sidebar}
      
    
      {content}
    
    
  );
}
 
const posts = [
  {id: 1, title: 'Hello World', content: 'Welcome to learning React!'},
  {id: 2, title: 'Installation', content: 'You can install React from npm.'}
];
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    key 会作为给 React 的提示，但不会传递给你的组件。如果您的组件中需要使用和 key 相同的值，请将其作为属性传递 ：

    const content = posts.map((post) =>
  
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    上面例子中，Post 组件可以读出 props.id，但是不能读出 props.key。

    在 jsx 中嵌入 map()

    在上面的例子中，我们声明了一个单独的 listItems 变量并将其包含在 JSX 中：

    unction NumberList(props) {
  const numbers = props.numbers;
  const listItems = numbers.map((number) =>
    

  );
  return (
    
      
      {listItems}
    
    
  );
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    JSX 允许在大括号中嵌入任何表达式，所以我们可以在 map() 中这样使用：

    function NumberList(props) {
  const numbers = props.numbers;
  return (
    
      
      {numbers.map((number) =>
        
 
      )}
    
    
  );
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    这么做有时可以使你的代码更清晰，但有时这种风格也会被滥用。就像在 JavaScript 中一样，何时需要为了可读性提取出一个变量，这完全取决于你。但请记住，如果一个 map() 嵌套了太多层级，那你就可以提取出组件。

    10. React 组件API

    主要讲解如下 7 个方法：

    • 设置状态：setState
    • 替换状态：replaceState
    • 设置属性：setProps
    • 替换属性：replaceProps
    • 强制更新：forceUpdate
    • 获取DOM节点：findDOMNode
    • 判断组件挂载状态：isMounted

    设置状态：setState

    setState(object nextState[, function callback])

    • 1

    参数说明

    • nextState，将要设置的新状态，该状态回合当前的 state 合并
    • callback，可选参数，回调函数。该函数会在 setState 设置成功，且组件重新渲染后调用。

    合并 nextState 和当前 state，并重新渲染组件。setState是React 事件处理函数中和请求回调函数中触发 UI 更新的主要方法。

    实例

    class Counter extends React.Component{
  constructor(props) {
      super(props);
      this.state = {clickCount: 0};
      this.handleClick = this.handleClick.bind(this);
  }
  
  handleClick() {
    this.setState(function(state) {
      return {clickCount: state.clickCount + 1};
    });
  }
  render () {
    return (
    点我！点击次数为: {this.state.clickCount}
    );
  }
}
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    上述实例中通过点击 h2 标签来使得点击计数器加 1。

    替换状态：replaceState

    replaceState(object nextState[, function callback])

    • 1
    • nextState，将要设置的新状态，该状态会替换当前的 state。
    • callback，可选参数，回调函数。该函数会在 replaceState 设置成功，且组件重新渲染后调用。

    replaceState() 方法与 setState() 类似，但是方法只会保留 nextState 中状态，原 state 不在 nextState 中的状态都会被删除。

    设置属性：setProps

    setProps(object nextProps[, function callback])

    • 1
    • nextProps，将要设置的新属性，该状态会和当前的 props 合并
    • callback，可选参数，回调函数。该函数会在 setProps 设置成功，且组件重新渲染后调用。

    设置组件属性，并重新渲染组件。

    props 相当于组件的数据流，它总是会从父组件向下传递至所有的子组件中。当和一个外部的 javaScript 应用集成时，我们可能会需要向组件传递数据或通知 React.render() 组件需要重新渲染，可以使用 setProps()。

    更新组件，可以在节点上再次调用 React.render()，也可以通过 setProps 方法改变组件属性，触发组件重新渲染。

    替换属性：replaceProps

    replaceProps(object nextProps[, function callback])

    • 1
    • nextProps，将要设置的新属性，该属性会替换当前的 props。
    • callback，可选参数，回调函数。该函数会在 replaceProps 设置成功，且组件重新渲染后调用。

    replaceProps() 方法与 setProps 类似，但它会删除原有 props。

    强制更新：forceUpdate

    forceUpdate([function callback])

    • 1

    参数说明

    • callback，可选参数，回调函数。该函数会在组件 render() 方法调用后调用。

    forceUpdate() 方法会使组件调用自身的 render() 方法重新渲染组件，组件的子组件也会调用自己的 render()。但是，组件重新渲染时，依然会读取 this.props 和 this.state，如果状态没有改变，那么 React 只会更新 DOM。

    forceUpdate() 方法适用于 this.props 和 this.state 之外的组件重绘（如：修改了this.state后），通过该方法通知 React 需要调用 reander()

    一般来说，应该尽量避免使用 forceUpdate()，而仅从 this.props 和 this.state 中读取状态并由 React 触发 render() 调用。

    获取DOM 节点：findDOMNode

    DOMElement findDOMNode()

    • 1
    • 返回值：DOM元素DOMElement

    如果组件已经挂载到DOM中，该方法返回对应的本地浏览器 DOM 元素。当 render 返回 null 或 false 时，this. findDOMNode() 也会返回 null。从 DOM 中读取值得时候，该方法很有用，如：获取表单字段得值和做一些 DOM 操作。

    判断组件挂载状态：isMounted

    bool isMounted()

    • 1
    • 返回值：true 或 false，表示组件是否已挂载到 DOM中

    isMounted() 方法用于判断组件是否已挂载到DOM 中。可以使用该方法保证了 setState() 和forceUpdate() 在异步场景下得调用不会出错。

    11. React 组件生命周期

    组件的生命周期可分成三个状态：

    • Mounting(挂载)：已插入真实 DOM
    • Updating(更新)：正在被重新渲染
    • Unmounting(卸载)：已移出真实 DOM

    挂载

    当组件实例被创建并插入 DOM 中时，其生命周期调用顺序如下：

    • constructor()：在React 组件挂载之前，会调用它的构造函数。
    • getDerivedStateFromProps()：在调用 render 方法之前调用，并且在初始挂载及后续更新时都会被调用。
    • render()：render 方法是 class 组件中唯一必须实现的方法。
    • componentDidMount()：在组件挂载后（插入 DOM 树中） 立即调用。

    render() 方法是 class 组件中唯一必须实现的方法，其它方法可以根据自己的需要来实现。

    更新

    每当组件的 state 或 props 发生变化时，组件就会更新。

    当组件的 props 或 state 发生变化时会触发更新。组件更新的生命周期调用顺序如下：

    • getDerivedStateFromProps()：在调用 render 方法之前调用，并且在初始挂载及后续更新时都会被调用。根据 shouldComponentUpadate() 的返回值，判断 React 组件的输出是否受当前 state 或 props 更改的影响。
    • shouldCOmponentUpdate()：当 props 或 state 发生变化时，shouldComponentUpdate() 会在渲染执行之前被调用。
    • render()：render() 方法是 class 组件中唯一必须实现的方法。
    • getSnapshotBeforeUpdate()：在最近一次渲染输出（提交到 DOM 节点）之前调用。
    • componentDidUpdate()：在更新后会被立即调用。

    render() 方法是 class 组件中唯一必须实现的方法，其他方法可以根据自己的需要来实现。

    卸载

    当组件从 DOM 中移除时会调用如下方法：

    • componentWillUnmount()：在组件卸载及销毁之前直接调用。

    12. React AJAX

    React 组件的数据可以通过 componentDidMount 方法中的 Ajax来获取，当从服务端获取数据时可以将数据存储在State 中，再用this.setState 方法重新渲染 UI。

    当使用异步加载数据时，在组件卸载前使用 componentWillUnmount 来取消未完成的请求。

    class UserGist extends React.Component {
  constructor(props) {
      super(props);
      this.state = {username: '', lastGistUrl: ''};
  }
 
 
  componentDidMount() {
    this.serverRequest = $.get(this.props.source, function (result) {
      var lastGist = result[0];
      this.setState({
        username: lastGist.owner.login,
        lastGistUrl: lastGist.html_url
      });
    }.bind(this));
  }
 
  componentWillUnmount() {
    this.serverRequest.abort();
  }
 
  render() {
    return (
      
    
        {this.state.username} 用户最新的 Gist 共享地址：
        {this.state.lastGistUrl}
      
    
    );
  }
}
 
ReactDOM.render(
  ,
  document.getElementById('example')
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    13. React 表单与事件

    HTML 表单元素与 React 中的其他 DOM 元素有所不同，因为表单元素生来就保留一些内部状态。

    在 HTML 当中， 像 ，