React

介绍

react 用于构建用户界面的 JavaScript 库
react 是一个将数据渲染为 HTML 视图的开源 JavaScript 库

react的特点:

  • 声明式编码
  • 组件化编码
  • React Native 编写原生应用
  • 高效（优秀的Diffing算法）

命令式编码, 就像准备晚餐, 你需要购买食材、切割食材、烹饪、调味、上菜等, 最后才能吃上饭
声明式编码, 就像去一家餐厅, 只需要告诉服务员, 我想要吃啥, 服务员就会让厨师给你准备好, 直接吃饭

入门

babel的作用:
ES6 => ES5
js => jsx
import => require

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
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>hello_react</title>
</head>
<body>
    <!-- 准备好一个"容器" -->
    <div id="test"></div>

    <!-- 引入 react 核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入 react-dom, 用于支持 react 操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入 babel, 用于将 jsx 转为 js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        // 1.创建虚拟DOM
        const VDOM = <h1>Hello, React</h1> /* 此处一定不要写引号, 因为不是字符串 */
        // 2.渲染虚拟DOM到页面
        ReactDOM.render(VDOM, document.getElementById('test'))
    </script>
</body>
</html>

虚拟DOM的两种创建方式

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
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>1_使用jsx创建虚拟DOM</title>
</head>
<body>
    <!-- 准备好一个"容器" -->
    <div id="test"></div>

    <!-- 引入 react 核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入 react-dom, 用于支持 react 操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入 babel, 用于将 jsx 转为 js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        // 1.创建虚拟DOM
        const VDOM = ( /* 此处一定不要写引号, 因为不是字符串 */
            <h1 id="title">
                <span>Hello, React</span>
            </h1>
        ) 
        // 2.渲染虚拟DOM到页面
        ReactDOM.render(VDOM, document.getElementById('test'))
    </script>
</body>
</html>
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
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>2_使用js创建虚拟DOM</title>
</head>
<body>
    <!-- 准备好一个"容器" -->
    <div id="test"></div>

    <!-- 引入 react 核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入 react-dom, 用于支持 react 操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>

    <script type="text/javascript">
        // 1.创建虚拟DOM
        const VDOM = React.createElement('h1', {id: 'title'}, React.createElement('span', {}, 'Hello,React'))
        // 2.渲染虚拟DOM到页面
        ReactDOM.render(VDOM, document.getElementById('test'))
    </script>
</body>
</html>

当如果嵌套的标签多了, 使用原生的js, 实现起来就比较麻烦了
这时候采用jsx看起来就比较简洁

在使用jsx语法写标签的时候, 可以采用()进行包裹多个标签

虚拟DOM与真实DOM

虚拟DOM其实就是一个普通的Object对象

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
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>3_虚拟DOM与真实DOM</title>
</head>
<body>
    <!-- 准备好一个"容器" -->
    <div id="test"></div>
    <div id="demo"></div>

    <!-- 引入 react 核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入 react-dom, 用于支持 react 操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入 babel, 用于将 jsx 转为 js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        // 1.创建虚拟DOM
        const VDOM = ( /* 此处一定不要写引号, 因为不是字符串 */
            <h1 id="title">
                <span>Hello, React</span>
            </h1>
        ) 
        // 2.渲染虚拟DOM到页面
        ReactDOM.render(VDOM, document.getElementById('test'))

        const TDOM = document.getElementById('demo')
        console.log('虚拟DOM', VDOM);
        console.log('真实DOM', TDOM);
        debugger
        console.log(typeof VDOM);
        console.log(VDOM instanceof Object);

        /* 
            关于虚拟DOM: 
            1.本质是Object类型的对象
            2.虚拟DOM比较“轻”，真实DOM比较“重”，因为虚拟DOM是React内部在用，无需真实DOM上那么多的属性。
            3.虚拟DOM最终会被React转化为真实DOM，呈现在页面上。
        */
    </script>
</body>
</html>

jsx语法规则

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
57
58
59
60
61
62
63
64
65
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>jsx语法规则</title>
    <style>
        .title {
            background-color: orange;
            width: 200px;
        }
    </style>
</head>

<body>
    <!-- 准备好一个"容器" -->
    <div id="test"></div>

    <!-- 引入 react 核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入 react-dom, 用于支持 react 操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入 babel, 用于将 jsx 转为 js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">

        const myId = 'aTgUiGu'
        const myData = 'HeLlo,rEaCt'

        // 1.创建虚拟DOM
        const VDOM = (
            <div>
                <h2 className="title" id={myId.toLocaleLowerCase()}>
                    <span style={{ color: 'white', fontSize: '29px' }}>{myData.toLocaleLowerCase()}</span>
                </h2>
                <h2 className="title" id={myId.toLocaleLowerCase()}>
                    <span style={{ color: 'white', fontSize: '29px' }}>{myData.toLocaleLowerCase()}</span>
                </h2>
                <input type="text" />
                {/* <good>123</good>  */}
            </div>
        )
        // 2.渲染虚拟DOM到页面
        ReactDOM.render(VDOM, document.getElementById('test'))

		/* 
				jsx语法规则：
						1.定义虚拟DOM时，不要写引号。
						2.标签中混入JS表达式时要用{}。
						3.样式的类名指定不要用class，要用className。
						4.内联样式，要用style={{key:value}}的形式去写。
						5.只有一个根标签
						6.标签必须闭合
						7.标签首字母
								(1).若小写字母开头，则将该标签转为html中同名元素，若html中无该标签对应的同名元素，则报错。
								(2).若大写字母开头，react就去渲染对应的组件，若组件没有定义，则报错。

		 */
    </script>
</body>

</html>

这段代码中, 外层{}表示里头是一个js表达式 , 里头{}表示的是一个js对象
fontSize需要使用小驼峰的形式表示
<span style={{ color: 'white', fontSize: '29px' }}></span>

jsx小练习

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
57
58
59
60
61
62
63
64
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>jsx语法规则</title>
    <style>
        .title {
            background-color: orange;
            width: 200px;
        }
    </style>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
		/* 
			一定注意区分：【js语句(代码)】与【js表达式】
					1.表达式：一个表达式会产生一个值，可以放在任何一个需要值的地方
								下面这些都是表达式：
										(1). a
										(2). a+b
										(3). demo(1)
										(4). arr.map() 
										(5). function test () {}
					2.语句(代码)：
								下面这些都是语句(代码)：
										(1).if(){}
										(2).for(){}
										(3).switch(){case:xxxx}
		
	 */
        // 模拟一些数据
        const data = ['Angular', 'React', 'Vue']
        // 1.创建虚拟DOM
        const VDOM = (
            <div>
                <h1>前端js框架列表</h1>
                <ul>
                    {
                        data.map((item, index) => {
                            return <li key={index}>{item}</li>
                        })
                    }
                </ul>
            </div>
        )
        // 2.渲染虚拟DOM到页面
        ReactDOM.render(VDOM, document.getElementById('test'))
    </script>
</body>

</html>

开发者工具安装

安装路径:
https://chromewebstore.google.com/search/react

浏览美团官网

Components 观察网页有多少个组件和组件的属性
Profiler 记录网站的一些性能, 渲染用了多久, 哪一个组件加载最慢

函数名就是组件名
类式名就是组件名

react中定义组件

函数式组件

babel在进行翻译的时候, 会开启严格模式, 禁止自定义的函数中的this指向window
this输出得到的是undefined, 这是因为严格模式下, this的指向不再是window了, this指向的是undefined

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
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>1_函数式组件</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        // 1.创建函数式组件
        function MyComponent() {
            console.log(this); // undefined
            return <h2>我是用函数定义的组件(适用于【简单组件】的定义)</h2>
        }
        // 2.渲染组件到页面
        ReactDOM.render(<MyComponent/>, document.getElementById('test'))
		/* 
			执行了ReactDOM.render(<MyComponent/>.......之后，发生了什么？
					1.React解析组件标签，找到了MyComponent组件。
					2.发现组件是使用函数定义的，随后调用该函数，将返回的虚拟DOM转为真实DOM，随后呈现在页面中。
		*/
    </script>
</body>

</html>

类的基本知识(复习)

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
57
58
59
60
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>1_类的基本知识</title>
</head>

<body>
    <script type="text/javascript">
        class Person {
            constructor(name, age) {
                // 构造器中的this是谁? -- 类的实例对象
                this.name = name
                this.age = age
            }
            // 一般方法
            speak() {
                //speak方法放在了哪里？——类的原型对象上，供实例使用
                //通过Person实例调用speak时，speak中的this就是Person实例
                console.log(`我叫${this.name}, 我的年龄是${this.age}`);
            }
        }

        // 创建一个Student类, 继承与Person类
        class Student extends Person {
            constructor(name, age, grade) {
                super(name, age)
                this.grade = grade
                this.school = '尚硅谷'
            }

            // 重写从父类继承过来的方法
            speak() {
                console.log(`我叫${this.name}, 我的年龄是${this.age}, 我读的是${this.grade}年级`);
                this.study()
            }
            study() {
				//study方法放在了哪里？——类的原型对象上，供实例使用
				//通过Student实例调用study时，study中的this就是Student实例
				console.log('我很努力的学习');
            }
        }

        /* const p1 = new Person('tom', 18)
        const p2 = new Person('jerry', 19)
        console.log(p1);
        console.log(p2);
        p1.speak()
        p2.speak() */

        const s1 = new Student('小张', 15, '高一')
        console.log(s1);
        s1.speak()
        s1.study()

    </script>
</body>

</html>

类式组件

函数名就是组件名
类式名就是组件名

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
<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>2_类式组件</title>
</head>
<body>
	<!-- 准备好一个“容器” -->
	<div id="test"></div>
	
	<!-- 引入react核心库 -->
	<script type="text/javascript" src="../js/react.development.js"></script>
	<!-- 引入react-dom，用于支持react操作DOM -->
	<script type="text/javascript" src="../js/react-dom.development.js"></script>
	<!-- 引入babel，用于将jsx转为js -->
	<script type="text/javascript" src="../js/babel.min.js"></script>

	<script type="text/babel">
        //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，随后呈现在页面中。
		*/
	</script>
</body>
</html>

有状态称为复杂组件, 无状态的称为简单组件

组件三大核心属性

原生事件绑定(复习)

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
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>2_原生事件绑定</title>
</head>
<body>
    <button id="btn1">按钮1</button>
    <button id="btn2">按钮2</button>
    <button onclick="demo()">按钮3</button>

    <script type="text/javascript">
        
        const btn1 = document.getElementById('btn1')
        btn1.addEventListener('click', () => {
            alert('按钮1被点击了')
        })

        const btn2 = document.getElementById('btn2')
        btn2.onclick = () => {
            alert('按钮2被点击了')
        }

        function demo() {
            alert('按钮3被点击了')
        }

    </script>
</body>
</html>

类方法中的this指向(复习)

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
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script type="text/javascript">
        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
    </script>
</body>

</html>

state

react中的事件绑定

严格模式下的, 普通函数this指向的是undefined

解决类中this指向问题

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
57
58
59
60
61
62
63
64
65
66
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>state</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        // 1.创建组件
        class Weather extends React.Component {
            constructor(props) {
                super(props)
                this.state = { isHot: true }
                // 解决changeWeather中this指向问题
                this.changeWeather = this.changeWeather.bind(this)
                // this.changeWeather.bind(this)是放在了原型对象上
                // this.changeWeather 是在实例对象上
                // onClick={this.changeWeather} 需要调用的实例对象身上的
            }
            render() {
                const { isHot } = this.state
                return (
                    // 注意 onClick={demo()} 表示调用了一次函数, 将函数的回调undefined复制给了onClick
                    // onClick={demo} 表示将回调函数赋值给了onClick
                    <h2 id="title" onClick={this.changeWeather}>今天天气很{isHot ? '炎热' : '凉爽'}</h2>
                )
            }
            changeWeather() {
                // changeWeather放在哪里? -- Weather的原型对象上, 供实例使用
                // 由于changeWeather是作为onClick的回调, 所以不是通过实例调用的, 是直接调用
                // 类中的方法默认开启了局部的严格模式, 所以changeWeather中的this为undefined
                console.log(this);
            }
        }
        // 2.渲染组件到页面
        ReactDOM.render(<Weather />, document.getElementById('test'))

        /* const title = document.getElementById('title')
        title.addEventListener('click', () => {
            console.log('标题被点击了');
        }) */

        /* const title = document.getElementById('title')
        title.onclick = () => {
            console.log('标题被点击了');
        } */

        /* function demo() {
            console.log('标题被点击了');
        } */
    </script>
</body>

</html>

state的用法

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
57
58
59
60
61
62
<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>state</title>
</head>
<body>
	<!-- 准备好一个“容器” -->
	<div id="test"></div>
	
	<!-- 引入react核心库 -->
	<script type="text/javascript" src="../js/react.development.js"></script>
	<!-- 引入react-dom，用于支持react操作DOM -->
	<script type="text/javascript" src="../js/react-dom.development.js"></script>
	<!-- 引入babel，用于将jsx转为js -->
	<script type="text/javascript" src="../js/babel.min.js"></script>

	<script type="text/babel">
		//1.创建组件
		class Weather extends React.Component{
			
			//构造器调用几次？ ———— 1次
			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 //这是错误的写法
			}
		}
		//2.渲染组件到页面
		ReactDOM.render(<Weather/>,document.getElementById('test'))
				
	</script>
</body>
</html>

在类中直接编写赋值语句, 会将该属性放在实例对象身上

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Car {
    constructor(name, price) {
        this.name = name
        this.price = price
        // this.wheel = 4
    }
    // 类中可以直接写赋值语句, 如下代码的含义是: 给Car的实例对象添加一个属性, 名为a, 值为1
    a = 1
    wheel = 4
}
const c1 = new Car('奔驰c63', 199)
const c2 = new Car('宝马', 299)
console.log(c1);
console.log(c2);

state的简写

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
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>state</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        // 1.创建组件
        class Weather extends React.Component {
            // 初始化状态
            state = { isHot: true, wind: '微风' }

            render() {
                const { isHot, wind } = this.state
                return (
                    <h2 id="title" onClick={this.changeWeather}>今天天气很{isHot ? '炎热' : '凉爽'}, {wind}</h2>
                )
            }

            // 自定义方法 -- 要用赋值语句的形式 + 箭头函数
            changeWeather = ()=>{
                console.log(this);
                const isHot = this.state.isHot
                this.setState({isHot: !isHot})
            }
        }
        // 2.渲染组件到页面
        ReactDOM.render(<Weather />, document.getElementById('test'))
    </script>
</body>

</html>

总结:

理解
1.state是组件对象最重要的属性, 值是对象(可以包含多个key-value的组合)
2.组件被称为”状态机”, 通过更新组件的state来更新对应的页面显示(重新渲染组件)

强烈注意
1.组件中render方法中的this为组件实例对象
2.组件自定义的方法中this为undefined，如何解决？
(a)强制绑定this: 通过函数对象的bind()
(b)箭头函数
3.状态数据，不能直接修改或更新

props

props的基本使用

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
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>1_props基本使用</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test1"></div>
    <div id="test2"></div>
    <div id="test3"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        //创建组件
        class Person extends React.Component {
            render() {
                // console.log(this);
                const { name, sex, age } = this.props
                return (
                    <ul>
                        <li>姓名: {name}</li>
                        <li>性别: {sex}</li>
                        <li>年龄: {age+1}</li>
                    </ul>
                )
            }
        }

        const p = {name: '张三', age: 20, sex: '男'}
        // console.log('@', ...p); // 展开语法只能在 <Person {...p} /> 标签上使用, 不能直接输出, 输出了也是空白

        //渲染组件到页面
        // ReactDOM.render(<Person name="张三" age="20" sex="男" />, document.getElementById('test1'))
        ReactDOM.render(<Person name="张4" age={22} sex="女" />, document.getElementById('test2'))
        ReactDOM.render(<Person name="张叼毛" age={52} sex="男" />, document.getElementById('test3'))

        // 批量传递props, <Person {...p} /> 中的{}表示是一段js表达式, ...p表示展开运算符
        ReactDOM.render(<Person {...p} />, document.getElementById('test1'))
    </script>
</body>

</html>

对props进行限制

注意prop是不可以修改的

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>2_对props进行限制</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test1"></div>
    <div id="test2"></div>
    <div id="test3"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>
	<!-- 引入prop-types，用于对组件标签属性进行限制 -->
	<script type="text/javascript" src="../js/prop-types.js"></script>

    <script type="text/babel">
        //创建组件
        class Person extends React.Component {
            render() {
                // console.log(this);
                const { name, sex, age } = this.props
				//props是只读的
				// this.props.name = 'jack' //此行代码会报错，因为props是只读的
                return (
                    <ul>
                        <li>姓名: {name}</li>
                        <li>性别: {sex}</li>
                        <li>年龄: {age+1}</li>
                    </ul>
                )
            }
        }

        // 对标签属性进行类型, 必要性的限制
        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
        }

        const p = {name: '张三', age: 20, sex: "男"}
        // console.log('@', ...p); // 展开语法只能在 <Person {...p} /> 标签上使用, 不能直接输出, 输出了也是空白

        //渲染组件到页面
        // ReactDOM.render(<Person name="张三" age="20" sex="男" />, document.getElementById('test1'))
        ReactDOM.render(<Person name="张4" age={22} sex="女" speak={speak} />, document.getElementById('test2'))
        ReactDOM.render(<Person name="张叼毛" age={52} sex="男" />, document.getElementById('test3'))

        // 批量传递props, <Person {...p} /> 中的{}表示是一段js表达式, ...p表示展开运算符
        ReactDOM.render(<Person {...p} />, document.getElementById('test1'))

        function speak() {
            console.log('说话');
        }
    </script>
</body>

</html>

使用propTypes进行类型限制的时候, 需要在代码中引入prop-types.js

当name没有传递时

性别设置数值11

props的简写方式
将 propTypes 写入到 class 中, 使用 static 关键字, 给 class 类添加属性

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>3_props的简写方式</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test1"></div>
    <div id="test2"></div>
    <div id="test3"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>
    <!-- 引入prop-types，用于对组件标签属性进行限制 -->
    <script type="text/javascript" src="../js/prop-types.js"></script>

    <script type="text/babel">
        //创建组件
        class Person extends React.Component {

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

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

        const p = { name: '张三', age: 20, sex: "男" }
        // console.log('@', ...p); // 展开语法只能在 <Person {...p} /> 标签上使用, 不能直接输出, 输出了也是空白

        //渲染组件到页面
        // ReactDOM.render(<Person name="张三" age="20" sex="男" />, document.getElementById('test1'))
        ReactDOM.render(<Person name="张4" age={22} sex="女" speak={speak} />, document.getElementById('test2'))
        ReactDOM.render(<Person name="张叼毛" age={52} sex="男" />, document.getElementById('test3'))

        // 批量传递props, <Person {...p} /> 中的{}表示是一段js表达式, ...p表示展开运算符
        ReactDOM.render(<Person {...p} />, document.getElementById('test1'))

        function speak() {
            console.log('说话');
        }
    </script>
</body>

</html>

关于构造器中的props

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
    //创建组件
    class Person extends React.Component {

        constructor(props) {
//构造器是否接收props，是否传递给super，取决于：是否希望在构造器中通过this访问props
// console.log(props);
            super(props)
            console.log('constructor', this.props);
        }

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

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

super不传递props
this.props的输出是undefined
但是如果想使用props的话
props都传入进来了
为啥不直接使用props
类中的构造器能省略就省略, 无所叼谓

函数组件使用props

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
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>4_函数组件使用props</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test1"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>
    <!-- 引入prop-types，用于对组件标签属性进行限制 -->
    <script type="text/javascript" src="../js/prop-types.js"></script>

    <script type="text/babel">
        //创建组件
        function Person(props) {
            console.log(props);
            const {name, sex, age} = props
            return (
                <ul>
                    <li>姓名: {name}</li>
                    <li>性别: {sex}</li>
                    <li>年龄: {age + 1}</li>
                </ul>
            )
        }
        // 对标签属性进行类型, 必要性的限制
        Person.propTypes = {
            name: PropTypes.string.isRequired, // 限制name必传，且为字符串
            sex: PropTypes.string, //限制sex为字符串
            age: PropTypes.number, //限制age为数值
        }
        // 指定默认标签属性值
        Person.defaultProps = {
            sex: '男', // sex默认值为男
            age: 18    //age默认值为18
        }

        //渲染组件到页面
        ReactDOM.render(<Person name="张三" age={22} sex="女" />, document.getElementById('test1'))
    </script>
</body>

</html>

总结:
理解
1. 每个组件对象都会有props(properties的简写)属性
2. 组件标签的所有属性都保存在props中

作用
1. 通过标签属性从组件外向组件内传递变化的数据
2. 注意: 组件内部不要修改props数据

编码操作
1. 内部读取某个属性值
this.props.name

  1. 对props中的属性值进行类型限制和必要性限制
    第一种方式（React v15.5 开始已弃用）： 
    1
    2
    3
    4
    5
    Person.propTypes = {
     name: React.PropTypes.string.isRequired,
     age: React.PropTypes.number
    }

第二种方式（新）：使用prop-types库进限制（需要引入prop-types库）

1
2
3
4
5
6
7
8
Person.propTypes = {
  name: PropTypes.string.isRequired,
  age: PropTypes.number. 
}

```	 

3.	扩展属性: 将对象的所有属性通过props传递

<Person {…person}/>

1
2

4.	默认属性值：

Person.defaultProps = {
age: 18,
sex:’男’
}

1
2

5.	组件类的构造函数

constructor(props){
super(props)
console.log(props)//打印所有属性
}

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



#### refs

字符串形式的ref
> 不推荐使用字符串形式的ref, 因为效率不高
```html
<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>1_字符串形式的ref</title>
</head>
<body>
	<!-- 准备好一个“容器” -->
	<div id="test"></div>
	
	<!-- 引入react核心库 -->
	<script type="text/javascript" src="../js/react.development.js"></script>
	<!-- 引入react-dom，用于支持react操作DOM -->
	<script type="text/javascript" src="../js/react-dom.development.js"></script>
	<!-- 引入babel，用于将jsx转为js -->
	<script type="text/javascript" src="../js/babel.min.js"></script>

	<script type="text/babel">
        //创建组件
        class Demo extends React.Component {
            //展示左侧输入框的数据
            showData = () => {
                console.log(this);
                const {input1} = this.refs
                alert(input1.value)
            }
            
            //展示右侧输入框的数据
            showData2 = () => {
                const {input2} = this.refs
                alert(input2.value)
            }

            render() {
                return (
                    <div>
                        <input ref="input1" type="text" placeholder="点击按钮提示数据" />&nbsp;
                        <button onClick={this.showData}>点我提示左侧的数据</button>&nbsp;
                        <input onBlur={this.showData2} ref="input2" type="text" placeholder="失去焦点提示数据" />
                    </div>
                )
            }
        }
        //渲染组件到页面
        ReactDOM.render(<Demo />, document.getElementById('test'))
	</script>
</body>
</html>

回调函数形式的ref

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
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>2_回调函数形式的ref</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        //创建组件
        class Demo extends React.Component {
            //展示左侧输入框的数据
            showData = () => {
                const { input1 } = this
                alert(input1.value)
            }

            //展示右侧输入框的数据
            showData2 = () => {
                const { input2 } = this
                alert(input2.value)
            }

            render() {
                return (
                    <div>
                        { /*  c 表示 currentNode  */}
                        <input ref={c => this.input1 = c} type="text" placeholder="点击按钮提示数据" />&nbsp;
                        <button onClick={this.showData}>点我提示左侧的数据</button>&nbsp;
                        <input onBlur={this.showData2} ref={c => this.input2 = c} type="text" placeholder="失去焦点提示数据" />
                    </div>
                )
            }
        }
        //渲染组件到页面
        ReactDOM.render(<Demo />, document.getElementById('test'))
    </script>
</body>

</html>

在编写内联函数的时候, 不能随便写回调函数, 一定是要在ref中

1
2
<input ref={(c) => {this.input1 = c; console.log('@', c);}} 
haha={() => {console.log('#');}} type="text" /> <br /><br />

回调ref中回调执行次数的问题

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
57
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>3_回调ref中回调执行次数的问题</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        //创建组件
        class Demo extends React.Component {
            state = {isHot: false}
            showInfo = () => {
                const {input1} = this
                alert(input1.value)
            }
            changeWeather = () => {
                const {isHot} = this.state
                this.setState({isHot: !isHot})
            }
            render() {
                const {isHot} = this.state
                return (
                    <div>
                        <h2>今天天气很{isHot ? '炎热' : '寒冷'}</h2>
                        {/* 如果以 ref 使用内联函数时, 在更新过程中它会执行两次
                            第一次传入的参数null, 第二次传入参数DOM元素
                            console.log 先输出null, 然后输出当前的DOM元素
                            每次渲染都会创建一个新函数实例, 所以React清空旧的ref并且设置新的
                            通过将 ref 的回调函数定义成 class 的绑定函数的方法可以避免这种问题
                            大多情况下, 这是无关紧要的
                        */}
                        <input ref={(c) => {this.input1 = c; console.log('@', c);}} type="text" /> <br /><br />
                        <button onClick={this.showInfo}>点我提示输入的数据</button>
                        <button onClick={this.changeWeather}>点我切换天气</button>
                    </div>
                );
            }
        }

        //渲染组件到页面
        ReactDOM.render(<Demo />, document.getElementById('test'));
    </script>
</body>

</html>

初始化的时候, 内联函数被调用了一次, 当按钮点击, 页面进行了更新操作, 内联函数被调用了两次,

createRef的使用

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
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>4_createRef的使用</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        //创建组件
        class Demo extends React.Component {
            /*
            React.createRef 调用后可以返回一个容器, 该容器可以存储被ref所标识的节点, 该容器是"专人专用"(跟id一样要保存唯一)的
            */
            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="失去焦点提示数据" />
                    </div>
                )
            }
        }
        //渲染组件到页面
        ReactDOM.render(<Demo />, document.getElementById('test'))
    </script>
</body>

</html>

总结:

  1. 理解
    组件内的标签可以定义ref属性来标识自己

  2. 编码

(1).字符串形式的ref
<input ref="input1"/>
(2).回调形式的ref
<input ref={(c)=>{this.input1 = c}}/>
(3).createRef创建ref容器·

1
2
myRef = React.createRef() 
<input ref={this.myRef}/>

事件处理

当触发事件的DOM跟回调函数在同一个的时候, 可以省略ref的用法
通过event.target的方式传递DOM

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
<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>事件处理</title>
</head>
<body>
	<!-- 准备好一个“容器” -->
	<div id="test"></div>
	
	<!-- 引入react核心库 -->
	<script type="text/javascript" src="../js/react.development.js"></script>
	<!-- 引入react-dom，用于支持react操作DOM -->
	<script type="text/javascript" src="../js/react-dom.development.js"></script>
	<!-- 引入babel，用于将jsx转为js -->
	<script type="text/javascript" src="../js/babel.min.js"></script>

	<script type="text/babel">
		//创建组件
		class Demo extends React.Component{
			/* 
				(1).通过onXxx属性指定事件处理函数(注意大小写)
						a.React使用的是自定义(合成)事件, 而不是使用的原生DOM事件 —————— 为了更好的兼容性
						b.React中的事件是通过事件委托方式处理的(委托给组件最外层的元素) ————————为了的高效
				(2).通过event.target得到发生事件的DOM元素对象 ——————————不要过度使用ref
			 */
			//创建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>
				)
			}
		}
		//渲染组件到页面
		ReactDOM.render(<Demo a="1" b="2"/>,document.getElementById('test'))
	</script>
</body>
</html>

react中收集表单数据

非受控组件是: 现用现取
通过按钮触发了点击事件, 获取了表单中的数据

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
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>1_非受控组件</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        // 创建组件
        class Login extends React.Component {

            handlerSubmit = (event) => {
                event.preventDefault(); // 阻止表单提交
                const {username, password} = this
                alert(`你输入的用户名是: ${username.value}, 你输入的密码是: ${password.value}`);
            }

            render() {
                return (
                    <form action="" onSubmit={this.handlerSubmit}>
                        用户名: <input ref={c => this.username = c} type="text" name="username" />
                        密码: <input ref={c => this.password = c} type="password" name="password" />
                        <button>登录</button>
                    </form>
                )
            }
        }
        // 渲染组件
        ReactDOM.render(<Login />, document.getElementById('test'))
    </script>
</body>

</html>

受控组件相比于非受控组件区别在于, 表单中的输入DOM没有绑定一个ref
受控组件是通过state状态进行数据的关联的

onChange 中必须要将一个函数的回调交给onChange

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
57
58
59
60
61
62
63
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>2_受控组件</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        // 创建组件
        class Login extends React.Component {

            // 初始化状态
            state = {
                username: '',
                password: ''
            }

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

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

            // 表单提交的回调
            handlerSubmit = (event) => {
                event.preventDefault(); // 阻止表单提交
                const { username, password } = this.state
                alert(`你输入的用户名是: ${username}, 你输入的密码是: ${password}`);
            }

            render() {
                return (
                    <form action="" onSubmit={this.handlerSubmit}>
                        用户名: <input onChange={this.saveUsername} type="text" name="username" />
                        密码: <input onChange={this.savePassword} type="password" name="password" />
                        <button>登录</button>
                    </form>
                )
            }
        }
        // 渲染组件
        ReactDOM.render(<Login />, document.getElementById('test'))
    </script>
</body>

</html>

高阶函数_函数柯里化

对象相关的知识

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8" />
		<title>Document</title>
	</head>
	<body>
        <script type="text/javascript">
            let a = 'name'
            let obj = {} // {name: 'tom'}
            obj[a] = 'tom'
            console.log(obj);
        </script>
	</body>
</html>

演示函数的柯里化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8" />
		<title>Document</title>
	</head>
	<body>
        <script type="text/javascript">
            /* function sum(a,b,c) {
                return a + b + c;
            } */
            function sum(a) {
                return (b) => {
                    return (c) => {
                        return a + b + c;
                    }
                }
            }
            // let result = sum(1, 2, 3)
            let result = sum(1)(2)(3)
            console.log(result);
        </script>
	</body>
</html>

1_高阶函数_函数柯里化

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>1_高阶函数_函数柯里化</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        
		//#region 
				/* 
					高阶函数：如果一个函数符合下面2个规范中的任何一个，那该函数就是高阶函数。
									1.若A函数，接收的参数是一个函数，那么A就可以称之为高阶函数。
									2.若A函数，调用的返回值依然是一个函数，那么A就可以称之为高阶函数。
									常见的高阶函数有：Promise、setTimeout、arr.map()等等
                                    Promise(() => {})
                                    setTimeout(() => {})

					函数的柯里化：通过函数调用继续返回函数的方式，实现多次接收参数最后统一处理的函数编码形式。 
						function sum(a){
							return(b)=>{
								return (c)=>{
									return a+b+c
								}
							}
						}
					*/
		//#endregion

        // 创建组件
        class Login extends React.Component {

            // 初始化状态
            state = {
                username: '',
                password: ''
            }

            // 保存用户名到状态中
            saveFormData = (dataType) => {
                return () => {
                    console.log(dataType, event.target.value);
                    this.setState({[dataType]: event.target.value})
                }
            }

            // 表单提交的回调
            handlerSubmit = (event) => {
                event.preventDefault(); // 阻止表单提交
                const { username, password } = this.state
                alert(`你输入的用户名是: ${username}, 你输入的密码是: ${password}`);
            }

            render() {
                return (
                    <form action="" onSubmit={this.handlerSubmit}>
                        用户名: <input onChange={this.saveFormData('username')} type="text" name="username" />
                        密码: <input onChange={this.saveFormData('password')} type="password" name="password" />
                        <button>登录</button>
                    </form>
                )
            }
        }
        // 渲染组件
        ReactDOM.render(<Login />, document.getElementById('test'))
    </script>
</body>

</html>

2_不用函数柯里化的实现

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
57
58
59
60
61
62
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>2_不用函数柯里化的实现</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">

        // 创建组件
        class Login extends React.Component {

            // 初始化状态
            state = {
                username: '',
                password: ''
            }

            // 保存用户名到状态中
            saveFormData = (dataType, event) => {
                // console.log(dataType, event.target.value);
                this.setState({ [dataType]: event.target.value })
            }

            
            // 表单提交的回调
            handlerSubmit = (event) => {
                event.preventDefault(); // 阻止表单提交
                const { username, password } = this.state
                alert(`你输入的用户名是: ${username}, 你输入的密码是: ${password}`);
            }

            render() {
                return (
                    <form action="" onSubmit={this.handlerSubmit}>
                    {/* 这行代码是将this.saveFormData()函数的返回值给了onChange */ }
                    {/* 而不是将this.saveFormDate的回调给了onChange */}
                        用户名: <input onChange={event => this.saveFormData('username', event)} type="text" name="username" />
                        密码: <input onChange={event => this.saveFormData('password', event)} type="password" name="password" />
                        <button>登录</button>
                    </form>
                )
            }
        }
        // 渲染组件
        ReactDOM.render(<Login />, document.getElementById('test'))
    </script>
</body>

</html>

组件的生命周期

组件渲染到DOM的时候, 叫做挂载(组件挂载到页面上)

引出生命周期

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>1_引出生命周期</title>
</head>

<body>
    <!-- 准备好一个“容器” -->
    <div id="test"></div>

    <!-- 引入react核心库 -->
    <script type="text/javascript" src="../js/react.development.js"></script>
    <!-- 引入react-dom，用于支持react操作DOM -->
    <script type="text/javascript" src="../js/react-dom.development.js"></script>
    <!-- 引入babel，用于将jsx转为js -->
    <script type="text/javascript" src="../js/babel.min.js"></script>

    <script type="text/babel">
        //创建组件
        //生命周期回调函数 <=> 生命周期钩子函数 <=> 生命周期函数 <=> 生命周期钩子
        class Life extends React.Component {

            state = { opacity: 1 }

            death = () => {
                //卸载组件
                ReactDOM.unmountComponentAtNode(document.getElementById('test'))
            }

            // 组件挂完毕
            componentDidMount() {
                this.timer = setInterval(() => {
                    console.log('#');
                    let { opacity } = this.state
                    // 减小0.1
                    opacity -= 0.1
                    // 获取原状态
                    if (opacity <= 0) opacity = 1
                    // 设置新的透明度
                    this.setState({ opacity })
                }, 200);
            }

            // 组件将要卸载
            componentWillUnmount() {
                // 清除定时器
                clearInterval(this.timer)
            }

            // 初始化渲染、状态更新之后
            render() {
                // 定时器每次修改了状态之后, 就会触发render()
                // 每调用一次render()就开启一个新的定时器
                /* this.timer = setInterval(() => {
                    console.log('#');
                    let { opacity } = this.state
                    // 减小0.1
                    opacity -= 0.1
                    // 获取原状态
                    if (opacity <= 0) opacity = 1
                    // 设置新的透明度
                    this.setState({ opacity })
                }, 200); */
                return (
                    <div>
                        <h2 style={{ opacity: this.state.opacity }}>react学不会, 怎么办?</h2>
                        <button onClick={this.death}>不活了</button>
                    </div>
                )
            }
        }

        // 渲染组件
        ReactDOM.render(<Life />, document.getElementById('test'))
    </script>
</body>

</html>

10-7 1-10
10-8 11-20
10-10 21-29
10-11 29-

行云般流水

前端
#React #前端
React
https://xiamu.icu/前端/React/
作者
肉豆蔻吖
发布于
2023年10月7日
许可协议