react入门

hello react

HTML代码如下

<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>hello_react</title>
</head>
<body>
	<!-- 1. 准备好一个“容器” -->
	<div id="test"></div>

	<!-- 2. 引入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" > /* 此处一定要写babel */
		// 3.创建虚拟DOM
		const VDOM = <h1>Hello,React</h1> /* 此处一定不要写引号，因为不是字符串 */
		// JSX可以将HTML和JS混用
		// 4.渲染虚拟DOM到页面 
		// ReactDOM.render(虚拟DOM,容器) 你把哪个虚拟DOM渲染到哪个容器中 ReactDOM操作虚拟DOM
		ReactDOM.render(VDOM,document.getElementById('test'))
	</script>
</body>
</html>

创建虚拟DOM的两种方式

为什么要用JSX：JSX可以让程序员更简单的创建虚拟DOM 假如我们要实现下面的结构
在这里插入图片描述

JS创建虚拟DOM：

<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<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 React.createElement(标签名，标签属性，标签内容)创建虚拟DOM document.createElement创建真实DOM
		const VDOM = React.createElement('h1',{id:'title'},React.createElement('span',{},'Hello,React'))
		//2.渲染虚拟DOM到页面
		ReactDOM.render(VDOM,document.getElementById('test'))
	</script>
</body>
</html>

JSX创建虚拟DOM：

<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<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" > /* 此处一定要写babel */
		// Babel就是将你这里面的代码翻译成了原生JS的代码：
		// const VDOM = React.createElement('h1',{id:'title'},React.createElement('span',{},'Hello,React'))

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

关于虚拟DOM：
（1）本质是Object类型的对象（一般对象）
（2）虚拟DOM身上的属性比较少，真实DOM身上的属性比较多，因为虚拟DOM是React内部在用，无需真实DOM上那么多的属性。
（3）虚拟DOM最终会被React转化为真实DOM，呈现在页面上。

JSX语法

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

一定注意区分：【js语句(代码)】与【js表达式】

表达式：一个表达式会产生一个值，可以放在任何一个需要值的地方
下面这些都是表达式：（你拿一个变量在左侧接能接到值他就是表达式）
(1). a
(2). a+b
(3). demo(1)
(4). arr.map()
(5). function test () {}
语句(代码)：
下面这些都是语句(代码)：（控制代码走向没有值不属于表达式）
(1).if(){}
(2).for(){}
(3).switch(){case:xxxx}

组件与模块

模块
（1）理解：向外提供特定功能的js程序, 一般就是一个js文件
（2）为什么要拆成模块：随着业务逻辑增加，代码越来越多且复杂。
（3）作用：复用js, 简化js的编写, 提高js运行效率
组件
（1）理解：用来实现局部功能效果的代码和资源的集合(html/css/js/image等等)
（2）为什么要用组件：一个界面的功能更复杂
（3）作用：复用编码, 简化项目编码, 提高运行效率
模块化：当应用的js都以模块来编写的, 这个应用就是一个模块化的应用
组件化：当应用是以多组件的方式实现, 这个应用就是一个组件化的应用

React面向组件编程

使用react开发者调试工具
在这里插入图片描述

定义组件的两种方式

函数式组件

<!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(){
			// 此处的this是undefined，因为babel编译后开启了严格模式 
			// 严格模式下禁止自定义函数里的this指向window
			console.log(this); 
			// 2. 函数必须有返回值
			return <h2>我是用函数定义的组件(适用于【简单组件】的定义)</h2>
		}
		// 3.渲染组件到页面 ReactDOM.render(组件的标签（必须闭合）,要渲染进的容器)
		ReactDOM.render(<MyComponent/>,document.getElementById('test'))
	</script>
</body>
</html>

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

React解析组件标签，找到了MyComponent组件。
发现组件是使用函数定义的，随后调用该函数，将返回的虚拟DOM转为真实DOM，随后呈现在页面中。

类式组件

复习类的基本知识

类中的构造器不是必须要写的，要对实例进行一些初始化的操作，如添加指定属性时才写。
如果A类继承了B类，且A类中写了构造器，那么A类构造器中的super是必须要调用的。
类中所定义的方法，都放在了类的原型对象上，供实例去使用。

<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>1_类的基本知识</title>
</head>
<body>
	<script type="text/javascript" >
		//创建一个Person类
		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('我很努力的学习');
			}
		}
		
		class Car {
			constructor(name,price){
				this.name = name
				this.price = price
				// this.wheel = 4
			}
			//类中可以直接写赋值语句,如下代码的含义是：给Car的实例对象添加一个属性，名为a，值为1
			a = 1
			wheel = 4
			static demo = 100
		}
		const c1 = new Car('奔驰c63',199)
		console.log(c1);
		console.log(Car.demo);
	</script>
</body>
</html>

类式组件

<!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.创建类式组件
		// 必须继承React.Component 必须定义render()函数 render()函数中必须有返回值
		class MyComponent extends React.Component {
			render(){
				//render是放在哪里的？—— MyComponent的原型对象上，供实例使用。
				//render中的this是谁？—— MyComponent的实例对象 <=> MyComponent组件实例对象。
				console.log('render中的this:',this);
				return <h2>我是用类定义的组件(适用于【复杂组件】的定义)</h2>
			}
		}
		//2.渲染组件到页面 这里的render和上面的render不是同一个东西 只是重名了而已
		ReactDOM.render(<MyComponent/>,document.getElementById('test'))
	</script>
</body>
</html>

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

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

state

<!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){// 借助构造器初始化state
				console.log('constructor');
				super(props)// 只要你写了构造器 这个一定要写
				//初始化状态 state必须是个对象
				this.state = {isHot:false,wind:'微风'}
				//解决changeWeather中this指向问题
				this.changeWeather = this.changeWeather.bind(this)
				//构造函数里的this都指向实例对象
				// this.changeWeather.bind(this)拿到了实例对象上的changeWeather方法 然后通过bind函数将该方法的this改为了实例对象
				// bind做了两件事：1. 给你生成一个新的函数 2. 改变函数里的this指向
				// this.changeWeather.bind(this)执行完了你得到了一个新的changeWeather函数 这个函数的this指向实例对象
				// 然后你把你得到的这个函数赋值给了实例对象的changeWeather属性
				// this.changeWeather是给实例对象赋值了一个changeWeather属性
				// 以后 你调用changeWeather就是调用changeWeather函数
			}

			//render调用几次？ ———— 1+n次 1是初始化的那次 n是状态更新的次数
			render(){
				console.log('render');
				//读取状态
				const {isHot,wind} = this.state
				// 注意这里是this.changeWeather 而不是this.changeWeather()
				// 后者是调用changeWeather()函数 将其返回值赋值给onClick
				// 前者是将changeWeather()函数赋值给onClick 当你点击的时候 会执行onClick 就会执行changeWeather()函数
				// 由于类给类中所有自定义方法都自动开启了严格模式（局部） 这里的this是undefined
				// 所以如果你不写this.changeWeather = this.changeWeather.bind(this) 会报错
				// 写了之后 this.changeWeather指的就是实例对象的属性 这个属性中保存了一个方法
				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>

简写：

<!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
			//初始化状态
			state = {isHot:false,wind:'微风'}

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

			//自定义方法————要用赋值语句的形式+箭头函数
			/*
			changeWeather = function() {
				// 这也相当于 给实例对象赋值了一个属性changeWeather 该属性指向一个函数
				// 但是这样写的话 你还是要在构造函数中修改this的指向
				// 但是如果你把changeWeather写成箭头函数 就可以不修改this指向了
				// 因为构造函数的this在这里就指向实例对象
				const isHot = this.state.isHot
				this.setState({isHot:!isHot})
			}
			 */
			changeWeather = ()=>{
				// 这里的this指向实例对象
				const isHot = this.state.isHot
				this.setState({isHot:!isHot})
			}
		}
		//2.渲染组件到页面
		ReactDOM.render(<Weather/>,document.getElementById('test'))
				
	</script>
</body>
</html>