React教程 第2章：React面向组件开发

开发插件

下载地址: https://chrome.google.com/webstore/detail/react-developer-tools/fmkadmapgofadopljbjfkapdkoienihi

控制台切换到Components查看

创建函数式组件

function MyComponent(){
  console.log(this); 
  return <h2>我是用函数定义的组件(适用于【简单组件】的定义)</h2>
}

创建类式组件

//1.创建类式组件
class MyComponent extends React.Component {
    render(){
        //render是放在哪里的？—— MyComponent的原型对象上，供实例使用。
        //render中的this是谁？—— MyComponent的实例对象 <=> MyComponent组件实例对象。
        console.log('render中的this:',this);
        return <h2>我是用类定义的组件(适用于【复杂组件】的定义)</h2>
    }
}
//2.渲染组件到页面
ReactDOM.render(<MyComponent/>,document.getElementById('test'))

执行了ReactDOM.render(<MyComponent/>……之后，发生了什么？

1.  React解析组件标签，找到了MyComponent组件。
2.  发现组件是使用类定义的，随后new出来该类的实例，并通过该实例调用到原型上的render方法。
3.  将render返回的虚拟DOM转为真实DOM，随后呈现在页面中。

渲染组件到页面

ReactDOM.render(<MyComponent/>,document.getElementById('test'))

执行了ReactDOM.render(…之后，发生了什么？

1. React解析组件标签，找到了MyComponent组件。

2. 发现组件是使用函数定义的，随后调用该函数，将返回的虚拟DOM转为真实DOM，随后呈现在页面中。

ES6 类

1. 类中的构造器不是必须要写的，要对实例进行一些初始化的操作，如添加指定属性时才写。

2. 如果A类继承了B类，且A类中写了构造器，那么A类构造器中的super是必须要调用的。

3. 类中所定义的方法，都放在了类的原型对象上，供实例去使用。

4. 子类可以重写父类的方法

组件三大核心属性1: state

1. state是组件对象最重要的属性, 值是对象(可以包含多个key-value的组合)

2. 组件被称为"状态机", 通过更新组件的state来更新对应的页面显示(重新渲染组件)

3. 组件中render方法中的this为组件实例对象

4. 组件自定义的方法中this为undefined，如何解决？

   • 强制绑定this: 通过函数对象的bind()

   • 箭头函数

5. 状态数据，不能直接修改或更新

标准使用

class Weather extends React.Component{

      //构造器调用几次？ ———— 1次
  // 构造器是否接收props，是否传递给super，取决于：是否希望在构造器中通过this访问props
      constructor(props){
          console.log('constructor');
          super(props)
          //初始化状态
          this.state = {isHot:false,wind:'微风'}
          //解决changeWeather中this指向问题
          this.changeWeather = this.changeWeather.bind(this)
      }

      //render调用几次？ ———— 1+n次 1是初始化的那次 n是状态更新的次数
      render(){
          console.log('render');
          //读取状态
          const {isHot,wind} = this.state
          return <h1 onClick={this.changeWeather}>今天天气很{isHot ? '炎热' : '凉爽'}，{wind}</h1>
      }

      //changeWeather调用几次？ ———— 点几次调几次
      changeWeather(){
          //changeWeather放在哪里？ ———— Weather的原型对象上，供实例使用
          //由于changeWeather是作为onClick的回调，所以不是通过实例调用的，是直接调用
          //类中的方法默认开启了局部的严格模式，所以changeWeather中的this为undefined

          console.log('changeWeather');
          //获取原来的isHot值
          const isHot = this.state.isHot
          //严重注意：状态必须通过setState进行更新,且更新是一种合并，不是替换。
          this.setState({isHot:!isHot})
          console.log(this);

          //严重注意：状态(state)不可直接更改，下面这行就是直接更改！！！
          //this.state.isHot = !isHot //这是错误的写法
      }
  }

简写形式, 调用赋值形式 + 函数

class Weather extends React.Component{
    //初始化状态
    state = {isHot:false,wind:'微风'}

    //自定义方法————要用赋值语句的形式+箭头函数,解决this的指向问题
    // 箭头函数的this是普通变量
    changeWeather = ()=>{
        const isHot = this.state.isHot
        this.setState({isHot:!isHot})
    }
}

组件三大核心属性2: props

1. 通过标签属性从组件外向组件内传递变化的数据,props收集标签属性

2. 注意: 组件内部不要修改props数据,props是只读的

3. 对props中的属性值进行类型限制和必要性限制

基本使用

//创建组件
    class Person extends React.Component{
        render(){
            // console.log(this);
            const {name,age,sex} = this.props
            return (
                <ul>
                    <li>姓名：{name}</li>
                    <li>性别：{sex}</li>
                    <li>年龄：{age+1}</li>
                </ul>
            )
        }
    }
    //渲染组件到页面
    ReactDOM.render(<Person name="jerry" age={19}  sex="男"/>,document.getElementById('test1'))
    ReactDOM.render(<Person name="tom" age={18} sex="女"/>,document.getElementById('test2'))

    const p = {name:'老刘',age:18,sex:'女'}
    ReactDOM.render(<Person {...p}/>,document.getElementById('test3'))

解构运算符

let arr1 = [1,3,5,7,9]
let arr2 = [2,4,6,8,10]

//展开一个数组, 得到数组当中的元素
console.log(...arr1); 

//连接n个数组
let arr3 = [...arr1,...arr2]

//在函数中使用,表示不定数量的参数,内部的numbers是一个数组
function sum(...numbers){
  return numbers.reduce((preValue,currentValue)=>{
    return preValue + currentValue
  })
}
console.log(sum(1,2,3,4));

//构造字面量对象时使用展开语法
let person = {name:'tom',age:18}
let person2 = {...person}

 //报错，原生展开运算符不能展开对象,在React中借助babel和react运行进可以进行对象的展开
//console.log(...person);
person.name = 'jerry'
console.log(person2);
console.log(person);

//合并
let person3 = {...person,name:'jack',address:"地球"}
console.log(person3);

批量传递props,使用属性的解构 {…properties对象实例},只适用于标签属性的运算符

<Person {...p}/> 等价于 <Person name={p.name} age={p.age} sex={p.sex}

对props的参数进行校验要使用到prop-types库

//对标签属性进行类型、必要性的限制
Person.propTypes = {
  name:PropTypes.string.isRequired, //限制name必传，且为字符串
  sex:PropTypes.string,//限制sex为字符串
  age:PropTypes.number,//限制age为数值
  speak:PropTypes.func,//限制speak为函数
}
//指定默认标签属性值
Person.defaultProps = {
  sex:'男',//sex默认值为男
  age:18 //age默认值为18
}

使用static组织props属性

class Person extends React.Component{

      constructor(props){
          super(props)
      }

      //对标签属性进行类型、必要性的限制
      static propTypes = {
          name:PropTypes.string.isRequired, //限制name必传，且为字符串
          sex:PropTypes.string,//限制sex为字符串
          age:PropTypes.number,//限制age为数值
      }

      //指定默认标签属性值
      static defaultProps = {
          sex:'男',//sex默认值为男
          age:18 //age默认值为18
      }

      render(){
          // console.log(this);
          const {name,age,sex} = this.props
          //props是只读的
          //this.props.name = 'jack' //此行代码会报错，因为props是只读的
          return (
              <ul>
                  <li>姓名：{name}</li>
                  <li>性别：{sex}</li>
                  <li>年龄：{age+1}</li>
              </ul>
          )
      }
  }

constructor(props)里面为什么要写super(props)? 在实例化对象时挂载props到实例的props上

组件三大核心属性3: refs

使用:组件内的标签可以定义ref属性来标识自己

1. 字符串形式的ref, 在节点上定义ref属性,通过this.refs收集节点实例,进一步获取节点的相关信息

class Demo extends React.Component{
    //展示左侧输入框的数据
    showData = ()=>{
        const {input1} = this.refs
        alert(input1.value)
    }
    //展示右侧输入框的数据
    showData2 = ()=>{
        const {input2} = this.refs
        alert(input2.value)
    }
    render(){
        return(
            <div>
                <input ref="input1" type="text" placeholder="点击按钮提示数据"/>
                <button onClick={this.showData}>点我提示左侧的数据</button>
                <input ref="input2" onBlur={this.showData2} type="text" placeholder="失去焦点提示数据"/>
            </div>
        )
    }
}

1. 回调形式的ref,ref属性值是一个回调函数 ,由react进行调用,回调接收的参数即为当前节点实例,可以挂载到当前的节点上

class Demo extends React.Component{
    //展示左侧输入框的数据
    showData = ()=>{
        const {input1} = this
        alert(input1.value)
    }
    //展示右侧输入框的数据
    showData2 = ()=>{
        const {input2} = this
        alert(input2.value)
    }
    render(){
        return(
            <div>
                <input ref={currentNode => this.input1 = currentNode } type="text" placeholder="点击按钮提示数据"/>
                <button onClick={this.showData}>点我提示左侧的数据</button>
                <input onBlur={this.showData2} ref={currentNode=> this.input2 = currentNode } type="text" placeholder="失去焦点提示数据"/>&nbsp;
            </div>
        )
    }
}

1. createRef()方法,React.createRef()创建一个容器,容器中存储节点的值通过访问组件实例属性的current.value值获取存储的节点实例

class Demo extends React.Component{
      /* 
          React.createRef调用后可以返回一个容器，该容器可以存储被ref所标识的节点,该容器是“专人专用”的
       */
      myRef = React.createRef()
      myRef2 = React.createRef()
      //展示左侧输入框的数据
      showData = ()=>{
          alert(this.myRef.current.value);
      }
      //展示右侧输入框的数据
      showData2 = ()=>{
          alert(this.myRef2.current.value);
      }
      render(){
          return(
              <div>
                  <input ref={this.myRef} type="text" placeholder="点击按钮提示数据"/>&nbsp;
                  <button onClick={this.showData}>点我提示左侧的数据</button>&nbsp;
                  <input onBlur={this.showData2} ref={this.myRef2} type="text" placeholder="失去焦点提示数据"/>&nbsp;
              </div>
          )
      }
      }

组件三大核心属性4: 事件处理

1. 通过onXxx属性指定事件处理函数(注意大小写)

• React使用的是自定义(合成)事件, 而不是使用的原生DOM事件

• React中的事件是通过事件委托方式处理的(委托给组件最外层的元素)

1. 通过event.target得到发生事件的DOM元素对象

class Demo extends React.Component{
		
      //创建ref容器
      myRef = React.createRef()
      myRef2 = React.createRef()

      //展示左侧输入框的数据
      showData = (event)=>{
          console.log(event.target);
          alert(this.myRef.current.value);
      }

      //展示右侧输入框的数据
      showData2 = (event)=>{
          alert(event.target.value);
      }

      render(){
          return(
              <div>
                  <input ref={this.myRef} type="text" placeholder="点击按钮提示数据"/>&nbsp;
                  <button onClick={this.showData}>点我提示左侧的数据</button>&nbsp;
                  <input onBlur={this.showData2} type="text" placeholder="失去焦点提示数据"/>&nbsp;
              </div>
          )
      }
}

类中的this指向

class Person {
  
        constructor(name,age){
            this.name = name
            this.age = age
        }
        study(){
            //study方法放在了哪里？——类的原型对象上，供实例使用
            //通过Person实例调用study时，study中的this就是Person实例
            console.log(this);
        }
    }

    const p1 = new Person('tom',18)
    p1.study() //通过实例调用study方法
    const x = p1.study
    x() // 类中默认开启了严格模式 返回值为undefined
}

作为事件的回调时 this 指向是windows, 类中默认开启了严格模式值为undefined

受控组件和非受控组件

受控组件

class Login extends React.Component{

    //初始化状态
    state = {
        username:'', //用户名
        password:'' //密码
    }

    //保存用户名到状态中
    saveUsername = (event)=>{
        this.setState({username:event.target.value})
    }

    //保存密码到状态中
    savePassword = (event)=>{
        this.setState({password:event.target.value})
    }

    //表单提交的回调
    handleSubmit = (event)=>{

        event.preventDefault() //阻止浏览器默认的表单提交行为
        const {username,password} = this.state
        alert(`你输入的用户名是：${username},你输入的密码是：${password}`)

    }

    render(){
        return(
            <form onSubmit={this.handleSubmit}>
                用户名：<input onChange={this.saveUsername} type="text" name="username"/>
                密码：<input onChange={this.savePassword} type="password" name="password"/>
                <button>登录</button>
            </form>
        )
    }
}

非受控组件

class Login extends React.Component{
    handleSubmit = (event)=>{
        event.preventDefault() //阻止表单提交
        const {username,password} = this
        alert(`你输入的用户名是：${username.value},你输入的密码是：${password.value}`)
    }
    render(){
        return(
            <form onSubmit={this.handleSubmit}>
                用户名：<input ref={c => this.username = c} type="text" name="username"/>
                密码：<input ref={c => this.password = c} type="password" name="password"/>
                <button>登录</button>
            </form>
        )
    }
}

受不受是指输入组件是否接受React的状态控制而言的

高阶函数和函数柯里化

高阶函数：如果一个函数符合下面2个规范中的任何一个，那该函数就是高阶函数。

1. 若A函数，接收的参数是一个函数，那么A就可以称之为高阶函数。

2. 若A函数，调用的返回值依然是一个函数，那么A就可以称之为高阶函数。

常见的高阶函数有：Promise、setTimeout、arr.map()等等

函数的柯里化：通过函数调用继续返回函数的方式，实现多次接收参数最后统一处理的函数编码形式。

function sum(a){
   return(b)=>{
          return (c)=>{
               return a+b+c
          }
      }
  }