React 基础
# JS 基础
# JS 语法
什么是 JS
- 脚本语言,语法与 java 类似
- ECMAScript:JS 标准,最新为 ES6,普遍为 ES5
引入:在 html 内部使用,一般定义在 html 末尾(其实放哪无所谓)
<script>
var num = 1;
alert(num);
</script>
2
3
4
外部引用
<script src="javascript/hello.js"></script>
基础语法:与 java 基本保持一致,无数据类型(Go)
<!-- 语法和java基本保持一致 -->
<script>
//定义变量
var score = 71;
var name = "hello";
//条件控制
if(score > 60){
alert("successed");
} else {
alert("failed");
}
</script>
2
3
4
5
6
7
8
9
10
11
12
控制台操作:可以直接输入执行 js 代码,类似于 python 的解释性编程
console.log(value); //在控制台打印一个变量value
JS 基础语法:数值,文本,图形,音频,视频......
比较运算符:在 js 中绝大部分判断等于时使用 === 绝对等于
= 赋值
== 等于(类型不一样,值一样会判断为true,如1和'1')
=== 绝对等于(类型一样&&值一样)
2
3
这属于 javascript 的缺陷,须知
- NaN 与所有数据都不相等,包括自己
- 可通过 isNaN() 函数判断是否为 NaN
- 浮点数问题
// 值为false,不相等,浮点数会有精度损失,尽量避免使用浮点数进行运算
console.log((1/3) === (1-2/3));
2
null 和 undefined
- null:空
- undefined:用了不存在的变量
strict 模式:用严格检查模式,避免一些太过于不规范的代码风格,例如
i = 1;
为了预防这种操作,在 script 的第一行启用就会对上述代码进行编译报错
'use strict';
另外,在 js 中,用 var 定义的均为全局变量,当一个 html 引入多个 js 文件时很不安全,我们用 let 定义局部变量,只作用于当前 js 文件(ES6 支持)
let a = 1;
if 判断
let age = 3;
if(age < 3){
console.log("呜呜呜");
} else if(age >= 3 && age <= 19){
console.log("哈哈哈");
} else {
console.log("...");
}
2
3
4
5
6
7
8
while 循环
while(age < 60){
age = age+1;
console.log(age);
}
2
3
4
for 循环
for(let i = 0; i < 9; i++){
console.log(i + " wdnmd");
}
2
3
数组遍历
- 在不知道数组大小时,使用 for-in 循环比较稳妥
- 更多时候我们使用函数遍历
//数组循环
let arr = [1,2,3,4,5,6,7,8,9];
// 函数
arr.forEach(function(value){
console.log(value);
})
// for-in:index为索引
for(let index in arr){
console.log(arr[index]);
}
2
3
4
5
6
7
8
9
10
注意在使用 for-in 时,如给数组新增属性,x 会输出 "hahaha",bug 属于是
arr.name = "hahaha";
for(let x in arr){
console.log(x);
}
2
3
4
# 数据类型
字符串
// 多行编写
`多行编写\n我遍尼玛`
// 模板字符串 ${}
let name = xzt;
let hello = wdnmd;
let msg = `我${name},${hello}`;
// 定义与判断
// 严格检查模式
'use strict';
let a = "hahaha";
let d = "wdnmd";
// 内建函数
let l = a.length;
let b = a[0];
let c = a.charAt(0);
let f = a.substring(0, 4);
console.log(a + '\n');
console.log(l + '\n');
if(b === c){
console.log("他们一样噢~");
}
// 多行编写 模板字符串
let msg = `${a}\n${d}`;
console.log(msg);
console.log(f);
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
数组
let arr = [1,2,3,4,5,a,b]
- arr.length()
- arr.indexOf(9):越界将报undefined
- slice(0, 5):切割,同subString
- push(...):追加,可追加无限元素
- pop():弹出末尾元素
- unshift(...):头插
- shift():弹出头部元素
- sort()
- reverse()
- concat("hahaha"):拼接,返回拼接结果,不修改原数组
- join('-'):用 - 连接数组中元素,返回字符串
- fill('+'):用+填充数组
- find(1):查找元素
多维数组
let arr = [[a,2], ['hahaha',1],["wdnmd",'hello']];
对象定义
let person = {
name: "xzt",
age: 3,
socre: 59.5,
tag: fw
}
2
3
4
5
6
使用不存在的属性:报错 undefined
person.hahaha;
动态删减属性
delete person.tag;
动态添加属性
person.hahaha = "wdnmd";
一些函数
'age' in person //true
'toString' in person //true
person.hasOwnProperty('toString') //false
2
3
toString是对象继承而来的方法,使用 in 为 truehasOwnProperty()只检查对象自己的方法,为 false
Map 和 Set
// ======== map ========
var map = new Map([["tom", 60], ["jack", 90], ["hahaha", 100]]);
// 通过key获得value
let score = map.get("tom");
map.set("admin", 123456);
map.delete("hahaha");
// 判断键是否存在
console.log(map.has("jack"));
// ======== set =========
var set = new Set([3,1,1,1,1,1,2]); //Set可以去重
set.add(3);
set.delete(1);
// 以数组形式输出Set
let arr = Array.from(set);
console.log(set.has(3));
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Iterator:遍历器,ES6 新特性,
'use strict';
// 遍历数组
let arr = [99,2,3,4,5];
// 遍历数组
for(let x of arr){
console.log(x);
}
// 遍历map
let map = new Map([["tom", 60], ["jack", 90], ["hahaha", 100]]);
for(let x of map){
console.log(x);
}
// 遍历set
let set = new Set([1,2,3,4,5]);
for(let x of set){
console.log(x);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 函数与对象
定义函数
function abs(x){
if(x < 0){
return -x;
} else {
return x;
}
}
let x = abs(-2);
2
3
4
5
6
7
8
9
或者定义 abs 为函数
var abs = function(x){
if(x < 0){
return -x;
} else {
return x;
}
}
2
3
4
5
6
7
参数
- 若
abs(1,2,3,4,5,6),将返回第一个参数的结果 - 若
abs()将返回undefined
不存在参数,手动抛出异常
typeof x:x的类型throw:抛出异常
function abs1(x){
if(typeof x !== 'number'){
throw "Not a Number";
}
return abs(x);
}
2
3
4
5
6
参数过多
- arguments:关键字 — 参数
- 可以通过 argument 拿到多余参数
- arguments 有自己的内置属性
function abs2(x){
for(let i = 0; i < arguments.length; i++){
console.log(arguments[i]);
}
// 手动抛出参数过多异常
if(arguments >= 2){
throw "Too much arguments";
}
return abs1(x);
}
2
3
4
5
6
7
8
9
10
11
12
作用域:内部函数能访问外部函数成员,反之不行
function ha(){
var x = 1;
x++;
function ha2(){
console.log(x);
var y = 0;
}
//console.log(y);将报错
}
2
3
4
5
6
7
8
9
当内部函数变量与外部函数重名,使用内部的 env 中函数,递归从内向外查找 env → fatherEnv
function ha(){
var x = 1;
x++;
function ha2(){
var x = 95;
console.log(x);
var y = 0;
}
console.log(x);
ha2();
//console.log(y);
}
ha();
2
3
4
5
6
7
8
9
10
11
12
13
提升作用域
function hei(){
var y;
var x = "x" + y;
console.log(x);
y = "y";
}
hei();
2
3
4
5
6
7
方法:对象中的函数
var xzt = {
name: "xzt",
birth: 2001,
age: function(){
let cur = new Date().getFullYear();
return cur-this.birth;
}
}
console.log(xzt.age()); //20
2
3
4
5
6
7
8
9
10
this:指向自己 → 可以这样调用,但还是要加括号,只要调用函数,必有括号
function getAge(){
let cur = new Date().getFullYear();
return cur-this.birth;
}
var xzt = {
name: "xzt",
birth: 2001,
age: getAge
}
console.log(xzt.age()); //20
2
3
4
5
6
7
8
9
10
11
不能直接 getAge(),因为此时 this 指向 window,window 无 birth 对象,将输出 NaN
apply(this, arugements)
let x = getAge.apply(xzt, [])
console.log(x); //20
2
apply 第一个参数为 this 指向对象,第二个参数为数组,即要调用的函数参数,如此实现外部函数对某一特定对象的使用
JS 标准对象
typeof 1 => "number"typeof "1" => "string"typeof true => "boolean"typeof [] => "object"typeof Math.abs => "function"
Date
var now = new Date();
now.getFullYear();
now.getDate(); //日期(几号)
now.getDay() //星期几
now.getMonth(); //0~11月
now.getHours();
now.getMinutes();
now.getSeconds();
//转化为当前地区时间
now.toLocaleDateString();
//获得时间戳,全世界统一,从1970.1.1 0:00:00到现在的毫秒数
let curTime = now.getTime();
for(let i = 0; i < 100000000; i++){
i *= i;
}
let time = now.getTime();
console.log(time-curTime);
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
JSON:轻量级的数据交换格式 —— 键值对数据
// JS字符串和JSON的转化
var person = {
name: "xzt",
age: 3,
gender: "男"
}
// 将对象转化为JSON
var jsonPerson = JSON.stringify(person);
// 字符串转化为对象
var obj = JSON.parse('{"hahaha": 1, "age": 3, "eihei": "wdnmd"}');
2
3
4
5
6
7
8
9
10
11
12
JSON 和 JS 对象的区别
var obj = {a: "hello", b: 123};
var json = "{"a":"hello", "b": "123"}"
2
Ajax
- 原生的js写法:xhr 异步请求
- jQury 封装好的方法 $("#name").ajax("")
- axios 请求
proto 继承
var person = {
name: "xzt",
age: 3,
gender: "男",
run: function(){
console.log(this.name + " is running");
}
}
var bird = {
fly: function(){
console.log(this.name + " is flying");
}
}
// 将对象转化为JSON
var jsonPerson = JSON.stringify(person);
// 字符串转化为对象
// var obj = JSON.parse({"hahaha": 1, "age": 3, "eihei": 99});
var xiaoming = {
name: "xiaoming"
}
// 另类的继承,proto指模板,即xiaoming的模板为person
xiaoming.__proto__ = person;
xiaoming.run();
xiaoming.__proto__ = bird;
xiaoming.fly();
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
class 继承(ES6)
class Student{
constructor(name){
this.name = name;
}
hello(){
alert("wdnmd");
}
}
class XiaoStudent extends Student{
constructor(name, grade){
// super实现父类同名方法
super(name);
this.grade = grade;
}
myHello(){
alert("我是一个小学生")
}
}
var xiaoming = new Student("xiaoming");
var xiaohong = new XiaoStudent("xiaohong", 86);
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
在 JS 中,每一个函数都有一个 prototype 属性,指向函数的原型对象,当 Object.prototype 为 null 停止查找,等价于 JDK 的 Object 对象
# BOM 和 DOM
BOM(Browser Object Model):浏览器对象模型
window
// window
let windowInnerWidth = window.innerWidth;
let windowInnerHeight = window.innerHeight;
let windowOuterWidth = window.OuterWidth;
let windowOuterHeight = window.outerHeight;
2
3
4
5
navigator:储存了浏览器信息,可被修改,不推荐使用
// navigator:浏览器信息 ——> 可被修改
let appName = navigator.appName;
let version = navigator.version;
let userAgent = navigator.userAgent;
let platform = navigator.platform;
2
3
4
5
screen:屏幕
// screen:屏幕大小 ——> 电脑分辨率
let screenWidth = screen.width;
let screenHeight = screen.height;
2
3
location:网页地址
// location
let host = location.host;
let href = location.href;
let protocal = location.protocal;
// 重新加载函数
location.reload();
// 重定向函数
location.assign("http://www.baidu.com");
2
3
4
5
6
7
8
history:主要控制网页前进 / 后退
// history:网页历史
history.back(); //后退
history.forward(); //前进
2
3
document:html 网页文档
// ducoment ——> 当前HTML页面文档树
document.getElementsByClassName("hahaha");
document.getElementById("app");
document.getElementsByTagName("span");
document.cookie;
2
3
4
5
DOM(Document Object Model)文本对象模型
获取结点
// 获取结点
var ul = document.getElementById("oh");
var a = document.getElementsByClassName("hahaha");
var p = document.getElementById("ah")
2
3
4
删除结点
// 删除结点
var father = ul.parentElement;
father.removeChild(ul);
father.removeChild(father.children[0]);
2
3
4
更新结点:要用 id 获取唯一结点
// 修改结点内容,注意必须要用id获得的结点才能生效
p.innerText = "hahaha";
p.innerHTML = "<h1>wdnmd</h1>"
2
3
添加结点
// 添加结点
father.append(ul);
2
创建添加结点
// 创建结点,参数为标签名
var btn = document.createElement("button");
// 创建文本结点
var text = document.createTextNode("wdnmd");
btn.append(text);
father.append(btn);
2
3
4
5
6
# 表单提交
onsubmit:在提交时可以设置 js 动作,一个函数
<form action="https://www.baidu.com" method="post" onsubmit="return aaa()"></form>
onclick:与onsubmit同理,在点击提交时,设置一个js动作
<button type="submit" onclick="aaa()">提交</button>
利用md5和hidden框进行加密
引入md5库,或下载下来用相对路径引用
<!-- 引入md5 ——> 加密 -->
<script src="https://cdn.bootcdn.net/ajax/libs/blueimp-md5/2.18.0/js/md5.js"></script>
2
加密:设置隐藏输入框;md5 加密明文内容
<input type="password" id="pwd"><br>
<input type="hidden" id="hidden-pwd" name="password">
前端的 payload 有效负载将根据 name 属性接收识别其 value,我们让真正的密码框没有 name,在后台通过 id 调用真正的密码
同时将真正的密码用 md5 加密后赋值给后者,即给前端展示的 name=password 的虚假密码,实现加密
<script>
function aaa() {
alert(1);
var username = document.getElementById("name");
var pwd = document.getElementById("pwd");
var md5Pwd = document.getElementById("hidden-pwd");
md5Pwd.value = md5(pwd.value);
return true;
}
</script>
2
3
4
5
6
7
8
9
10
11
12
13
前端加密展示效果
一键东秦教评,全部好评,建议为空
let inputs = document.querySelectorAll("input");
for (i in inputs) if (inputs[i].value == 0) inputs[i].checked = true;
document.querySelector("textarea").value = "无";
document.querySelector("#sub").click();
2
3
4
# 网络通信
# JQuery
获取和使用:使用 CDN 引入
<!-- 引入jQuery CDN-->
<script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.js"></script>
2
或者下载在目录下,相对路径引用
<script src="jquery-3.6.0/jquery-3.6.0.min.js"></script>
公式:$(selector).action()
//id选择器
$('#a').click(function(){
alert("康nm呢");
});
2
3
4
选择器:与 css 选择器类似,用单引号或双引号括起来
- 标签选择器:
$('p') - id 选择器:
$("#id") - 类选择器:
$(".class") - 层次选择器:
$("div p"),div 后的 p 标签 - 子选择器:
$("ul>li"),ul 后的第一代 li 标签 - 相邻兄弟选择器:
$("#hahaha + p"),id 为 hahaha 元素的同级的下一个 p 标签 - 通用兄弟选择器:
$("#hahaha~p"),id 为 hahaha 元素的同级向下所有 p 标签、 - 结构伪类选择器:
$("a:hover")
鼠标事件
- mousedown:鼠标按下
- mouseleave:离开
- mouseover:点击结束
- mousemove:移动
鼠标移动
$(document).ready(function(){
$("#app").mousemove(function(e){
$("#app").text("x:" + e.pageX + ", y:" + e.pageY);
})
})
2
3
4
5
鼠标点击
$('#a').click(function(){
alert("康nm呢");
$("body").append(h);
});
2
3
4
DOM 操作:文本操作
$("#text-ul").text(); //获得值
$("#text-ul").text("hahaha"); //设置值
$("#text-ul li[name=java]").html(); //获得值
$("#text-ul li[name=java]").html("<span>123</span>");//设置值
2
3
4
5
CSS 操作
使消失,本质 display: none
$("#app").show()
$("#app").hidden()
2
# Ajax
基于 JQuery 封装的网络通信框架
$("#from").ajax();
$.ajax({url: "text.html", context: document.body, success: function(){$(this).addClass("done")}});
2
3
# Mantis React
文档:Documentation | Mantis MUI React (opens new window)
# React 基础
React 是一个 用于构建用户界面(UI) 的 JS 库,由 Facebook 开发维护,核心特点为
- 组件化开发(组件即函数)
- 鼓励声明式编程和单向数据流
function Hello(props) {
return <h1>Hello, {props.name}</h1>;
}
2
3
JSX 语法:React 推荐使用 JSX,一种在 JavaScript 中写 HTML 的语法糖,这看起来像 HTML,其实是被 Babel 编译为React.createElement()的 JavaScript 调用
const element = <h1>Hello World</h1>;
声明式 UI:例如你不需要自己操作 DOM 来更新count,React 自动帮你更新
const [count, setCount] = useState(0);
return <button onClick={() => setCount(count + 1)}>Clicked {count} times</button>
2
3
状态和 Hooks:使用useState、useEffect等 Hook 来管理组件状态和生命周期
const [count, setCount] = useState(0);
useEffect(() => {
console.log("组件渲染了");
}, [count]);
2
3
4
虚拟 DOM:React 在内存中维护一个“虚拟 DOM”,对比前后变化后,只更新必要的部分以提升性能
React 可用于
- Web 应用(配合 React Router)
- 移动端应用(React Native)
- 桌面应用(Electron + React)
- 服务端渲染(Next.js)
注意:React 不是全能框架,它只负责“视图层”,需要根据项目需求搭配
说白了,就是一个 JS 库,通过 JSX 语法糖支持 JS 和 HTML 的混合编写,而后通过 JS 函数返回前端组件(所谓函数式编程),经过一层层嵌入实现一个完整的 HTML 页面,而页面上的数据请求逻辑在函数中就已经写好了,最后返回的组件是封装完好的
- 这是 JS 和 HTML 混合编写的好处,即在一个函数中实现完整的组件开发:包括后端请求和前端渲染
Vue 和 React 对比
| 特性 | Vue | React |
|---|---|---|
| 框架类型 | 渐进式框架 | 库(Library)更偏向 UI 层 |
| 哲学思想 | MVVM 模式,关注“响应式” | 函数式编程 + 单向数据流 |
| 核心驱动 | 模板语法 + 响应式系统 | JSX + 虚拟 DOM |
| 官方维护 | Vue 全家桶(Vuex、Vue Router、Vue CLI) | React 核心 + 社区支持生态(Redux、React Router、Vite等) |
组件写法,React 采用函数式编程,函数即组件,而 Vue 是“模板语法”,例如一个简单的 Vue 组件
<template>
<div>{{ message }}</div>
</template>
<script>
export default {
data() {
return {
message: 'Hello Vue!'
}
}
}
</script>
2
3
4
5
6
7
8
9
10
11
12
13
对比一个简单的 React 组件
import { useState } from 'react';
function MyComponent() {
const [message, setMessage] = useState('Hello React!');
return <div>{message}</div>;
}
2
3
4
5
6
这本质上因为
- Vue 使用的是 SFC(Single File Component),有模板+逻辑+样式,是传统的前端思路
- React 是 JSX(JavaScript + XML),逻辑和模板写在一起,更自由,更代码化
- React 的函数组件是主流(类组件已不推荐),配合 Hook 实现状态和生命周期管理
生命周期对比
| 生命周期阶段 | Vue (3.x Composition API) | React (Hook) |
|---|---|---|
| 创建前 | setup() | useEffect(() => {}, []) |
| 更新时 | onUpdated | useEffect(() => { ... }, [deps]) |
| 卸载时 | onUnmounted | useEffect(() => { return () => {} }, []) |
React 通过useEffect模拟生命周期,不再是“声明式生命周期钩子”,而是函数内使用 Hook,可以将useEffect理解为 React 的钩子函数
状态管理
| 特性 | Vue | React |
|---|---|---|
| 简单状态管理 | reactive()、ref() | useState()、useReducer() |
| 全局状态管理 | Vuex / Pinia | Redux、Zustand、Recoil 等 |
其他差异
| 特性 | Vue | React |
|---|---|---|
| 模板逻辑 | 推荐模板中少写逻辑 | JSX中可写任意 JS 表达式 |
| 表单处理 | v-model 简洁 | 需手动 onChange + value |
| 条件渲染 | v-if / v-show | 三元表达式 condition ? ... : ... |
| 列表渲染 | v-for | map() 函数 |
Mantis React src 目录结构
主要改写的就是 pages 目录下的页面
# 表单提交
实现这样一个页面
/pages/authentication/Login.js
import { Link } from 'react-router-dom';
// material-ui
import { Grid, Stack, Typography } from '@mui/material';
// project import
import AuthLogin from './auth-forms/AuthLogin';
import AuthWrapper from './AuthWrapper';
// ================================|| LOGIN ||================================ //
const Login = () => (
<AuthWrapper>
<Grid container spacing={3}>
<Grid item xs={12}>
<Stack direction="row" justifyContent="space-between" alignItems="baseline" sx={{ mb: { xs: -0.5, sm: 0.5 } }}>
<Typography variant="h3">登录</Typography>
<Typography component={Link} to="#" variant="body1" sx={{ textDecoration: 'none' }} color="primary">
新用户自动注册
</Typography>
{/* <Typography component={Link} to="/register" variant="body1" sx={{ textDecoration: 'none' }} color="primary">
Don't have an account?
</Typography> */}
</Stack>
</Grid>
<Grid item xs={12}>
<AuthLogin />
</Grid>
</Grid>
</AuthWrapper>
);
export default Login;
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
很显然这里用到了组件 AuthLogin,来自/pages/authentication/AuthLogin.js
import React from 'react';
import { Link as RouterLink } from 'react-router-dom';
// material-ui
import {
Button,
Checkbox,
Divider,
FormControlLabel,
FormHelperText,
Grid,
Link,
IconButton,
InputAdornment,
InputLabel,
OutlinedInput,
Stack,
Typography,
MenuItem,
FormControl,
Select
} from '@mui/material';
// third party
import * as Yup from 'yup';
import { Formik } from 'formik';
// project import
import FirebaseSocial from './FirebaseSocial';
import AnimateButton from 'components/@extended/AnimateButton';
// assets
import { EyeOutlined, EyeInvisibleOutlined } from '@ant-design/icons';
// ============================|| FIREBASE - LOGIN ||============================
import { useNavigate } from 'react-router-dom';
import { userLoginService } from 'api';
const AuthLogin = () => {
const [checked, setChecked] = React.useState(false);
const [domain, setDomain] = React.useState('Adomain');
const [attributeList, setAttributeList] = React.useState('(2,4,5,6)');
const handleDomainChange = (event: SelectChangeEvent) => {
setDomain(event.target.value);
};
const handleChangeAttributeList = (event: SelectChangeEvent) => {
setAttributeList(event.target.value);
};
const [showPassword, setShowPassword] = React.useState(false);
const handleClickShowPassword = () => {
setShowPassword(!showPassword);
};
const handleMouseDownPassword = (event) => {
event.preventDefault();
};
const nav = useNavigate();
return (
<>
<Formik
initialValues={{
username: 'Alice',
domain: 'Adomain',
attributeset: '(2,4,5,6)'
}}
validationSchema={Yup.object().shape({
username: Yup.string().required('请填写用户名')
})}
onSubmit={async (values, { setErrors, setStatus, setSubmitting }) => {
const { username, domain, attributeset } = values;
localStorage.setItem('username', username);
localStorage.setItem('domain', domain);
let data = {
"username" : username,
"domain" : domain,
"attributeset" : attributeset
}
console.log(data)
userLoginService(data)
.then((res) => {
console.log(res);
setStatus({ success: true });
setSubmitting(false);
nav('/');
})
.catch((err) => {
console.log(err);
setStatus({ success: false });
setErrors({ submit: err.message });
setSubmitting(false);
});
}}
>
{({ errors, handleBlur, handleChange, handleSubmit, isSubmitting, touched, values }) => (
<form noValidate onSubmit={handleSubmit}>
<Grid container spacing={3}>
<Grid item xs={12}>
<Stack spacing={1}>
<InputLabel htmlFor="username-login">用户名</InputLabel>
<OutlinedInput
id="username-login"
type="text"
value={values.username}
name="username"
onBlur={handleBlur}
onChange={handleChange}
placeholder="请输入用户名"
fullWidth
error={Boolean(touched.username && errors.username)}
/>
{touched.username && errors.username && (
<FormHelperText error id="standard-weight-helper-text-username-login">
{errors.username}
</FormHelperText>
)}
</Stack>
</Grid>
<Grid item xs={12}>
<Stack spacing={1}>
{/* <InputLabel htmlFor="password-login">所属域</InputLabel> */}
<FormControl variant="standard" sx={{ m: 1, minWidth: 120 }}>
<InputLabel id="demo-simple-select-standard-label">所属域</InputLabel>
<Select
labelId="demo-simple-select-standard-label"
id="demo-simple-select-standard"
value={domain}
onChange={handleDomainChange}
label="domain"
>
<MenuItem value={'Adomain'}>Adomain</MenuItem>
<MenuItem value={'Bdomain'}>Bdomain</MenuItem>
</Select>
</FormControl>
</Stack>
</Grid>
<Grid item xs={12}>
<Stack spacing={1}>
<FormControl variant="standard" sx={{ m: 1, minWidth: 120 }}>
<InputLabel id="demo-simple-select-standard-label">属性集</InputLabel>
<Select
labelId="demo-simple-select-standard-label"
id="demo-simple-select-standard"
value={attributeList}
onChange={handleChangeAttributeList}
label="domain"
>
<MenuItem value={'(2,4,5,6)'}>(2,4,5,6)</MenuItem>
<MenuItem value={'(1,2,3)'}>(1,2,3)</MenuItem>
<MenuItem value={'(1,2,3,4)'}>(1,2,3,4)</MenuItem>
<MenuItem value={'(1,2,3,4,5)'}>(1,2,3,4,5)</MenuItem>
</Select>
</FormControl>
</Stack>
</Grid>
{errors.submit && (
<Grid item xs={12}>
<FormHelperText error>{errors.submit}</FormHelperText>
</Grid>
)}
<Grid item xs={12}>
<AnimateButton>
<Button disableElevation disabled={isSubmitting} fullWidth size="large" type="submit" variant="contained" color="primary">
登录
</Button>
</AnimateButton>
</Grid>
</Grid>
</form>
)}
</Formik>
</>
);
};
export default AuthLogin;
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
在这定义了登录按钮时间,通过 onSubmit 绑定 Formik 标签
<Formik
initialValues={{
username: 'Alice',
domain: 'Adomain',
attributeset: '(2,4,5,6)'
}}
validationSchema={Yup.object().shape({
username: Yup.string().required('请填写用户名')
})}
onSubmit={async (values, { setErrors, setStatus, setSubmitting }) => {
const { username, domain, attributeset } = values;
localStorage.setItem('username', username);
localStorage.setItem('domain', domain);
let data = {
"username" : username,
"domain" : domain,
"attributeset" : attributeset
}
console.log(data)
userLoginService(data)
.then((res) => {
console.log(res);
setStatus({ success: true });
setSubmitting(false);
nav('/');
})
.catch((err) => {
console.log(err);
setStatus({ success: false });
setErrors({ submit: err.message });
setSubmitting(false);
});
}}
>
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
# 点击事件
主页内容
由/pages/access-control/index.jsx定义:Ark-Blockchain-Archetype/frontend/src/pages/access-control/index.jsx at main · Arkrypto/Ark-Blockchain-Archetype (opens new window)
其实就是一个页面,通过不同的Dialog来控制Card展示,以文件上传弹窗为例
// 文件上传弹窗
const [isUploadShow, setIsUploadShow] = React.useState(false); // 控制弹窗显示
const [fileUploadParams, setFileUploadParams] = React.useState(FILEUPLOADPARAMS);
const setFileName = (val) => setFileUploadParams({ ...fileUploadParams, filename: val });
const setContent = (val) => setFileUploadParams({ ...fileUploadParams, content: val });
const setAccessTree = (val) => setFileUploadParams({ ...fileUploadParams, accesstree: val });
const handleFileUpload = () => {
const data = {
...fileUploadParams,
username: localStorage.getItem('username') || '',
domain: localStorage.getItem('domain') || ''
};
console.log("文件上传请求参数:")
console.log(data)
fileUploadService(data)
.then((res) => {
if (res.code === '200') {
setIsUploadShow(false);
handleMsgShow("文件上传成功")
} else {
setIsUploadShow(false);
handleMsgShow("文件上传失败")
}
})
.catch((e) => {
// console.log("nmsl")
console.log(e);
setIsUploadShow(false);
handleMsgShow(e.message)
});
};
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
其中fileUploadService函数在/api/file.js中定义,就是一个简单的 JS Post 请求
import request from '../utils/request';
// 文件上传
export const fileUploadService = (data) => request.post('/file/upload', data);
// 订阅外包服务
export const fileOutSourceService = (data) => request.post('/file/outsource/set', data);
// 域内文件下载
export const fileInDomainDlService = (data) => request.post('/file/indomain/download', data);
// 跨域访问服务(跨域文件下载)
export const fileCrossDomainDlService = (data) => request.post('/file/crossdomain/download', data);
// 密钥协商
export const getKeyService = () => request.get('/getKey');
2
3
4
5
6
7
8
9
10
11
12
# API 定义
在/api/xxx.js下定义方法接口,其请求的 URL 前缀定义在 craco.config.js 中
craco.config.js
const path = require('path');
module.exports = {
// webpack 配置
webpack: {
// 配置别名
alias: {
// 约定:使用 @ 表示 src 文件所在路径
'@': path.resolve(__dirname, 'src')
}
},
devServer: {
// 配置代理解决跨域
proxy: {
'/api': {
target: 'http://139.155.96.38:8080', // https://xxx.com
ws: true,
changeOrigin: true,
pathRewrite: {
'^/api': '/'
}
},
'/shit': {
target: 'http://139.155.96.38:5000', // https://xxx.com
ws: true,
changeOrigin: true,
pathRewrite: {
'^/shit': '/'
}
}
}
}
};
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
即前缀/api将会被自动解析为http://139.155.96.38:8080,同理/shit将会被自动解析为http://139.155.96.38:5000
- 为什么会单独有个
/shit前缀,因为之前这个项目的区块链部分后端是单独写的,用 Flask 跑在 5000,后来加了一层网关,就只有/api了
至于这个前缀的使用,在/src/utils/request.js中
import axios from 'axios';
import { contextType } from 'react-copy-to-clipboard';
// 创建 axios 实例
const instance = axios.create({
baseURL: '/api', //根路径,配置在 craco.config.js 中
// baseURL: 'http://139.155.96.38:8080', //根路径
timeout: 10000, //请求过期时间
contextType: "application/json"
});
//请求拦截器
instance.interceptors.request.use(
(config) => {
return config;
},
(err) => {
return Promise.reject(err);
}
);
//响应拦截器
instance.interceptors.response.use(
(res) => {
return res.data;
},
(err) => {
return Promise.reject(err);
}
);
export default instance;
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
通过request.post()/get()创建 axios 请求
# 钩子函数
在进入溯源页面时,需要对统计信息进行请求
/api/detect.js中该部分 API 请求定义
import request from '../utils/request';
// 异常分析
export const detectResultService = () => request.get('/detect/result');
export const detectResultListService = () => request.get('/detect/resultlist');
export const detectAllService = () => request.get('/detect/all');
export const detectIDService = (data) => request.post('/detect/id', data)
// 溯源
export const traceSourceService = (data) => request.post('/trace/source', data);
2
3
4
5
6
7
8
9
10
11
/pages/detect/index.js
import { useState, useEffect } from 'react';
import { Link as RouterLink, useNavigate } from 'react-router-dom';
import * as React from 'react';
// material-ui
import {
Avatar,
AvatarGroup,
Box,
Button,
Grid,
List,
ListItemAvatar,
ListItemButton,
ListItemSecondaryAction,
ListItemText,
MenuItem,
Stack,
TextField,
Typography
} from '@mui/material';
// project import
import OrdersTable from './OrdersTable';
import IncomeAreaChart from './IncomeAreaChart';
import MonthlyBarChart from './MonthlyBarChart';
import ReportAreaChart from './ReportAreaChart';
import SalesColumnChart from './SalesColumnChart';
import MainCard from 'components/MainCard';
import AnalyticEcommerce from 'components/cards/statistics/AnalyticEcommerce';
// assets
import { GiftOutlined, MessageOutlined, SettingOutlined } from '@ant-design/icons';
import avatar1 from 'assets/images/users/avatar-1.png';
import avatar2 from 'assets/images/users/avatar-2.png';
import avatar3 from 'assets/images/users/avatar-3.png';
import avatar4 from 'assets/images/users/avatar-4.png';
import { detectResultService, detectResultListService, detectAllService } from 'api/detect';
// avatar style
const avatarSX = {
width: 36,
height: 36,
fontSize: '1rem'
};
// action style
const actionSX = {
mt: 0.75,
ml: 1,
top: 'auto',
right: 'auto',
alignSelf: 'flex-start',
transform: 'none'
};
// sales report status
const status = [
{
value: 'today',
label: 'Today'
},
{
value: 'month',
label: 'This Month'
},
{
value: 'year',
label: 'This Year'
}
];
// ==============================|| DASHBOARD - DEFAULT
export const Detect = () => {
const [value, setValue] = useState('today');
const [slot, setSlot] = useState('week');
const [totalInfo, setTotalInfo] = useState({});
useEffect(() => {
// TOTAL_INFO.checkNum += 500
// alert("test")
// setTotalInfo(TOTAL_INFO);
let total_info = {
checkNum: null,
errorNum: null,
brokenNum: null
};
// detect/all
detectAllService()
.then((res) => {
if(!res.message){
alert("请求数据为空");
return;
}
total_info.checkNum = res.message[0];
total_info.errorNum = res.message[1];
total_info.brokenNum = res.message[2];
console.log(total_info);
setTotalInfo(total_info);
}).catch((e) => {
alert("请求数据总计失败")
})
}, []);
return (
<Grid container rowSpacing={4.5} columnSpacing={2.75}>
{/* row 1 */}
<Grid item xs={12} sx={{ mb: -2.25 }}>
<Typography variant="h5">数据总计</Typography>
</Grid>
<Grid item xs={12} sm={6} md={4} lg={4}>
<AnalyticEcommerce title="共检测次数" count={`${totalInfo.checkNum}次`} color="linear-gradient(120deg, #d4fc79 0%, #96e6a1 100%)" />
</Grid>
<Grid item xs={12} sm={6} md={4} lg={4}>
<AnalyticEcommerce title="异常行为" count={`${totalInfo.errorNum}次`} color="linear-gradient(120deg, #f093fb 0%, #f5576c 100%)" />
</Grid>
<Grid item xs={12} sm={6} md={4} lg={4}>
<AnalyticEcommerce title="设备故障" count={`${totalInfo.brokenNum}次`} color="linear-gradient(120deg, #e0c3fc 0%, #8ec5fc 100%)" />
</Grid>
<Grid item md={8} sx={{ display: { sm: 'none', md: 'block', lg: 'none' } }} />
{/* row 2 */}
{/* 数据记录和设备异常情况,写在IncomeAreaChart.js里 */}
<IncomeAreaChart slot={slot} />
{/* row 3 */}
{/* 设备信息,写在OrdersTable.js里 */}
<Grid item xs={12} md={12} lg={12}>
<Grid container alignItems="center" justifyContent="space-between">
<Grid item>
<Typography variant="h5">设备信息</Typography>
</Grid>
<Grid item />
</Grid>
<MainCard sx={{ mt: 2 }} content={false}>
<OrdersTable />
</MainCard>
</Grid>
</Grid>
);
};
export default Detect;
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
在这个页面载入时,就会触发useEffect中的函数,这是一个 axios 请求/detect/all接口,而后将本地变量赋值并展示
useEffect(() => {
// TOTAL_INFO.checkNum += 500
// alert("test")
// setTotalInfo(TOTAL_INFO);
let total_info = {
checkNum: null,
errorNum: null,
brokenNum: null
};
// detect/all
detectAllService()
.then((res) => {
if(!res.message){
alert("请求数据为空");
return;
}
total_info.checkNum = res.message[0];
total_info.errorNum = res.message[1];
total_info.brokenNum = res.message[2];
console.log(total_info);
setTotalInfo(total_info);
}).catch((e) => {
alert("请求数据总计失败")
})
}, []);
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
可以发现这个页面中还有一个 OrdersTable 组件,定义在/pages/detect/OrdersTable
// 导入、变量定义略 //
export default function OrderTable() {
const [order] = useState('asc');
const [orderBy] = useState('trackingNo');
const [selected] = useState([]);
const [deviceInfos, setDeviceInfos] = useState([]);
const isSelected = (trackingNo) => selected.indexOf(trackingNo) !== -1;
const nav = useNavigate();
const handleOpen = (ip) => {
// setOpen(true);
// console.log(ip)
localStorage.setItem("ip", ip);
nav('/history');
};
useEffect(() => {
setDeviceInfos(DEVICE_INFO);
// detect/resultlist
detectResultListService()
.then((res) => {
if(!res.message){
alert("请求数据为空");
return;
}
let map = res.message;
let device = [];
for(let i of Object.keys(map)){
let ip = i;
let error = map[ip][0];
let broken = map[ip][1];
device.push(createData(ip, error, broken));
}
console.log(device)
setDeviceInfos(device);
// DEVICE_INFO = DEVICE;
// setDeviceInfos(DEVICE_INFO);
}).catch((e) => {
alert("请求设备信息失败")
})
}, []);
return (
<>
<Box>
<TableContainer
sx={{
width: '100%',
overflowX: 'auto',
position: 'relative',
display: 'block',
maxWidth: '100%',
'& td, & th': { whiteSpace: 'nowrap' }
}}
>
<Table
aria-labelledby="tableTitle"
sx={{
'& .MuiTableCell-root:first-of-type': {
pl: 2
},
'& .MuiTableCell-root:last-of-type': {
pr: 3
}
}}
>
<OrderTableHead order={order} orderBy={orderBy} />
<TableBody>
{stableSort(deviceInfos, getComparator(order, orderBy)).map((row, index) => {
const isItemSelected = isSelected(row.trackingNo);
const labelId = `enhanced-table-checkbox-${index}`;
return (
<>
<TableRow
hover
role="checkbox"
sx={{ '&:last-child td, &:last-child th': { border: 0 } }}
aria-checked={isItemSelected}
tabIndex={-1}
key={row}
selected={isItemSelected}
>
<TableCell component="th" id={labelId} scope="row" align="center">
{row.deviceId}
</TableCell>
<TableCell align="center">{row.errorNum}</TableCell>
<TableCell align="center">{row.brokenNum}</TableCell>
<TableCell align="center">
<Button variant="contained" onClick={() => handleOpen(row.deviceId)}>查询</Button>
</TableCell>
</TableRow>
</>
);
})}
</TableBody>
</Table>
</TableContainer>
</Box>
</>
);
}
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
这里同样定义了useEffect函数,与上一个嵌套类似,也是一个 Get 请求
useEffect(() => {
setDeviceInfos(DEVICE_INFO);
// detect/resultlist
detectResultListService()
.then((res) => {
if(!res.message){
alert("请求数据为空");
return;
}
let map = res.message;
let device = [];
for(let i of Object.keys(map)){
let ip = i;
let error = map[ip][0];
let broken = map[ip][1];
device.push(createData(ip, error, broken));
}
console.log(device)
setDeviceInfos(device);
// DEVICE_INFO = DEVICE;
// setDeviceInfos(DEVICE_INFO);
}).catch((e) => {
alert("请求设备信息失败")
})
}, []);
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
可以明确的是,组件 OrdersTable 在 detect/index.js 中被调用时,也会触发他自身的钩子函数
# 路由注册与启动
在 routes 目录下的 index.js 中注册页面路由,/src/routes/index.js
import { useRoutes } from 'react-router-dom';
// project import
import LoginRoutes from './LoginRoutes';
import MainRoutes from './MainRoutes';
// ==============================|| ROUTING RENDER
export default function ThemeRoutes() {
return useRoutes([MainRoutes, LoginRoutes]);
}
2
3
4
5
6
7
8
9
10
11
/routes/LoginRoutes.js
import { lazy } from 'react';
// project import
import Loadable from 'components/Loadable';
import MinimalLayout from 'layout/MinimalLayout';
// render - login
const AuthLogin = Loadable(lazy(() => import('pages/authentication/Login')));
const AuthRegister = Loadable(lazy(() => import('pages/authentication/Register')));
// ==============================|| AUTH ROUTING ||==============================
const LoginRoutes = {
path: '/',
element: <MinimalLayout />,
children: [
{
path: 'login',
element: <AuthLogin />
},
{
path: 'register',
element: <AuthRegister />
}
]
};
export default LoginRoutes;
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
/routes/MainRoutes.js
import { lazy } from 'react';
// project import
import Loadable from 'components/Loadable';
import MainLayout from 'layout/MainLayout';
// render - dashboard
const DashboardDefault = Loadable(lazy(() => import('pages/dashboard')));
// render - sample page
const SamplePage = Loadable(lazy(() => import('pages/extra-pages/SamplePage')));
// render - utilities
const Typography = Loadable(lazy(() => import('pages/components-overview/Typography')));
const Color = Loadable(lazy(() => import('pages/components-overview/Color')));
const Shadow = Loadable(lazy(() => import('pages/components-overview/Shadow')));
const AntIcons = Loadable(lazy(() => import('pages/components-overview/AntIcons')));
// block-chain
const Welcome = Loadable(lazy(() => import('pages/welcome')));
const AccessControl = Loadable(lazy(() => import('pages/access-control')));
const KeyAgreement = Loadable(lazy(() => import('pages/key-agreement')));
const AbnormalTraffic = Loadable(lazy(() => import('pages/abnormal-traffic')));
const Trace = Loadable(lazy(() => import('pages/trace')));
const Detact = Loadable(lazy(() => import('pages/detect')));
const History = Loadable(lazy(() => import('pages/detect/history')));
// ==============================|| MAIN ROUTING ||==============================
const MainRoutes = {
path: '/',
element: <MainLayout />,
children: [
{
path: '/',
element: <Welcome />
},
{
path: 'color',
element: <Color />
},
{
path: 'dashboard',
children: [
{
path: 'default',
element: <DashboardDefault />
}
]
},
{
path: 'access',
element: <AccessControl />
},
{
path: 'auth',
element: <KeyAgreement />
},
{
path: 'detect',
element: <Detact />
},
{
path: 'history',
element: <History />
}
]
};
export default MainRoutes;
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
整个项目由/src/App.js启动
// project import
import Routes from 'routes';
import ThemeCustomization from 'themes';
import ScrollTop from 'components/ScrollTop';
// ==============================|| APP - THEME, ROUTER, LOCAL ||============================== //
const App = () => (
<ThemeCustomization>
<ScrollTop>
<Routes />
</ScrollTop>
</ThemeCustomization>
);
export default App;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
调用 Routes 引入路由页面,实现所有页面的加载
# Electron 基础
# npm 依赖
创建项目,安装electron依赖
mkdir my-electron-app && cd my-electron-app
npm init
npm install --save-dev electron
2
3
注意在脚本处添加启动命令"start": "electron ."
main.js
// main.js
// electron 模块可以用来控制应用的生命周期和创建原生浏览窗口
const { app, BrowserWindow } = require('electron')
const path = require('path')
const createWindow = () => {
// 创建浏览窗口
const mainWindow = new BrowserWindow({
width: 800,
height: 600,
webPreferences: {
preload: path.join(__dirname, 'preload.js')
}
})
// 加载 index.html
mainWindow.loadFile('index.html')
// 打开开发工具
// mainWindow.webContents.openDevTools()
}
// 这段程序将会在 Electron 结束初始化
// 和创建浏览器窗口的时候调用
// 部分 API 在 ready 事件触发后才能使用。
app.whenReady().then(() => {
createWindow()
app.on('activate', () => {
// 在 macOS 系统内, 如果没有已开启的应用窗口
// 点击托盘图标时通常会重新创建一个新窗口
if (BrowserWindow.getAllWindows().length === 0) createWindow()
})
})
// 除了 macOS 外,当所有窗口都被关闭的时候退出程序。 因此, 通常
// 对应用程序和它们的菜单栏来说应该时刻保持激活状态,
// 直到用户使用 Cmd + Q 明确退出
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') app.quit()
})
// 在当前文件中你可以引入所有的主进程代码
// 也可以拆分成几个文件,然后用 require 导入。
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
index.html
<!--index.html-->
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<!-- https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP -->
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'">
<title>你好!</title>
</head>
<body>
<h1>你好!</h1>
我们正在使用 Node.js <span id="node-version"></span>,
Chromium <span id="chrome-version"></span>,
和 Electron <span id="electron-version"></span>.
<!-- 您也可以此进程中运行其他文件 -->
<script src="./renderer.js"></script>
</body>
</html>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
preload.js
// preload.js
// 所有的 Node.js API接口 都可以在 preload 进程中被调用.
// 它拥有与Chrome扩展一样的沙盒。
window.addEventListener('DOMContentLoaded', () => {
const replaceText = (selector, text) => {
const element = document.getElementById(selector)
if (element) element.innerText = text
}
for (const dependency of ['chrome', 'node', 'electron']) {
replaceText(`${dependency}-version`, process.versions[dependency])
}
})
2
3
4
5
6
7
8
9
10
11
12
13
14
main.js:作为启动类,管理所有进程的开始和结束,相当于controller的角色index.html:作为view层直接和用户交互preload.js:中可以调用nodejs api实现后端功能,如动态改写html内容,数据库交互,api请求等等
总体可以理解为一个MVC框架的网页,其中controller和model均用js编写,view用前端三件套编写
# 预加载脚本
Electron 的主进程是一个拥有着完全操作系统访问权限的 Node.js 环境,出于安全原因,渲染进程preload.js默认跑在网页页面上,而并非 Node.js 里
为了将 Electron 的不同类型的进程桥接在一起,我们需要使用被称为预加载的特殊脚本
BrowserWindow 的预加载脚本运行在具有 HTML DOM 和 Node.js、Electron API 的有限子集访问权限的环境中
# preload.js
预加载,相当于加载页面前的钩子函数
如以下脚本preload.js,通过 versions 这一全局变量,将 Electron 的 process.versions 对象暴露给渲染器
const { contextBridge } = require('electron')
contextBridge.exposeInMainWorld('versions', {
node: () => process.versions.node,
chrome: () => process.versions.chrome,
electron: () => process.versions.electron,
// 能暴露的不仅仅是函数,我们还可以暴露变量
})
2
3
4
5
6
7
8
在主进程main.js中,在createWindow函数中(即BrowserWindow的构造器),将渲染脚本加入webPreferences元组,将主界面和渲染脚本相绑定
const { app, BrowserWindow } = require('electron')
const path = require('path')
const createWindow = () => {
const win = new BrowserWindow({
width: 800,
height: 600,
webPreferences: {
// 在这里绑定渲染脚本
preload: path.join(__dirname, 'preload.js'),
},
})
win.loadFile('index.html')
}
app.whenReady().then(() => {
createWindow()
})
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# renderer.js
渲染脚本,集合 DOM 操作
使用preload.js可以通过全局访问 versions 获取相关信息,要获取 DOM 操作,需要使用到脚本renderer.js
const information = document.getElementById('info')
information.innerText = `本应用正在使用 Chrome (v${versions.chrome()}), Node.js (v${versions.node()}), 和 Electron (v${versions.electron()})`
2
将相应index.html中标签 id 添加为 info
<h1>Hello from Electron renderer!</h1>
<p>👋</p>
<p id="info"></p>
2
3
将preload.js中添加数据信息
const { contextBridge } = require('electron');
contextBridge.exposeInMainWorld('versions', {
node: () => process.versions.node,
chrome: () => process.versions.chrome,
electron: () => process.versions.electron,
});
2
3
4
5
6
7
得到页面效果
# 进程通信
通过 IPC 进行变量和函数的传递
是这样的,在渲染器里绝对是不允许调用 nodejs 函数的,这样很不安全,即用户从前端可以直接操作底层数据,于是我们在 preload.js 中将函数暴露(声明函数),渲染器 renderer.js 只能调用声明过的函数,而这个函数实际是在 main.js 中(主进程中)被执行
# 渲染器请求主进程
在 preload.js 声明变量和函数
const { contextBridge, ipcRenderer } = require('electron')
contextBridge.exposeInMainWorld('versions', {
node: () => process.versions.node,
chrome: () => process.versions.chrome,
electron: () => process.versions.electron,
ping: () => ipcRenderer.invoke('ping'),
})
2
3
4
5
6
7
8
在 renderer.js 中调用函数
const func = async () => {
const response = await window.versions.ping()
console.log(response) // 打印 'pong'
}
func()
2
3
4
5
6
在主函数 main.js 中处理函数
const { app, BrowserWindow, ipcMain } = require('electron')
const path = require('path')
const createWindow = () => {
const win = new BrowserWindow({
width: 800,
height: 600,
webPreferences: {
preload: path.join(__dirname, 'preload.js'),
},
})
ipcMain.handle('ping', () => 'pong')
win.loadFile('index.html')
}
app.whenReady().then(createWindow)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
消息通过预加载脚本暴露给渲染器,渲染器触发,在主进程中执行并将结果返回给渲染器
通过 ipc 暴露带参函数
preload.js 声明
contextBridge.exposeInMainWorld('versions', {
send: (jsonData) => ipcRenderer.invoke('send', jsonData),
});
2
3
renderer.js 调用
const render_send = async () => {
const data = { name: 'John', age: 30 };
const jsonData = JSON.stringify(data);
const response = await window.versions.send(jsonData)
alert(response)
}
const btn = document.getElementById('test');
btn.onclick = render_send
2
3
4
5
6
7
8
9
main.js 处理
ipcMain.handle('send', async (event, jsonData) => {
// const result = await doSomeWork(jsonData)
return jsonData
})
2
3
4
# 主进程回送渲染器
main.js
通过 mainWindow 回送请求
mainWindow
const mainWindow = new BrowserWindow({
width: 800,
height: 600,
webPreferences: {
preload: path.join(__dirname, 'preload.js'),
webSecurity: false
// nodeIntegration: true,
// contextIsolation: false // 讓在 preload.js 的定義可以傳遞到 Render Process (React)
}
})
2
3
4
5
6
7
8
9
10
处理渲染器的 send 函数并通过 mainWindow.webContents.send 回送
// 通过 axios 请求后端,然后通过 mainWindow.webContents 回送消息给 preload.js 中的监听器
// preload.js 的监听器收到消息直接渲染前端页面
axios.defaults.baseURL = 'http://127.0.0.1:5000'
ipcMain.handle('send', async (event, jsonData) => {
// send(jsonData)
// response = await sleep();
console.log("request arise: " + jsonData)
axios.post('http://127.0.0.1:5000/chat', jsonData, {
headers: {
"Content-Type":"application/json"
},
}).then(response => {
data = response.data
console.log("receive data: " + data)
mainWindow.webContents.send('back', data)
}, error => {
error = error.message
console.log('error occur: ', error)
event.sender.send("back", error)
})
})
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
渲染器接收
//将消息显示在网页上
function setMessageInnerHTML(name, msg) {
document.getElementById("message").innerHTML += "<strong>" + name + ":</strong><br>"
document.getElementById('message').innerHTML += msg + '<br><br>';
}
ipcRenderer.on('back', (event, arg) => {
// console.log('渲染进程收到的消息:',arg)
setMessageInnerHTML('ChatGPT', arg)
})
2
3
4
5
6
7
8
9
10
# 网络请求
# net
使用 electron 内置的 net 进行网络请求,处理渲染器发送的 send 请求(真几把难用,但是也还行,配合 webContents.send 将处理结果返回给渲染器)
const request_chatgpt = (jsonData) => {
const { net } = require('electron')
const request = net.request({
headers: { 'Content-Type': 'application/json', },
method: 'POST',
url: 'http://127.0.0.1:5000/chat'
})
request.write(jsonData)
request.on('response', response => {
response.on('data', res => {
console.log(res.toString())
})
response.on('end', () => {
console.log('No more data in response.')
})
})
request.end()
}
ipcMain.handle('send', async (event, jsonData) => {
const result = request_chatgpt(jsonData)
return result
})
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# axios
比较熟悉,其实应该是一样的
npm install --save axios
在 main.js 中引入
const axios = require("axios").default;
post 请求
axios.defaults.baseURL = 'http://127.0.0.1:5000'
axios.post('http://127.0.0.1:5000/chat', jsonData, {
headers: {
"Content-Type":"application/json"
},
}).then(response => {
data = response.data
console.log("receive data: " + data)
mainWindow.webContents.send('back', data)
}, error => {
error = error.message
console.log('error occur: ', error)
event.sender.send("back", error)
})
2
3
4
5
6
7
8
9
10
11
12
13
14
# 跨平台构建
理论上 Electron 作为跨平台框架,执行三条命令即可生成 Windows、Mac、Linux 下的三种可执行包