前端基础学习笔记
一、HTML:
1、基础骨架:
<!-- 声明是 html5 --> <!DOCTYPE html> <html lang="zh-CN"> <!-- 看不见的配置(编码、标题、外部资源) --> <head> <!-- 字符集,防止中文乱码,必写 --> <meta charset="UTF-8"> <!-- 移动端适配,做后台管理页面也建议加上 --> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>页面标题</title> <!-- 引入css --> <link rel="stylesheet" href="style.css"> </head> <!-- 用户看到的内容区域 --> <body> <!-- 页面所有可见内容写在这里 --> hello html <!-- 引入js,放body末尾,优先加载页面结构 --> <script src="main.js"></script> </body> </html>
2、常用标签:
(1)、块级元素(独占一行,常用布局容器):
<!-- div 最常用,纯容器,无语义,业务开发万能盒子 --> <div class="card">通用容器</div>
<!-- h1~h6 标题,数字越小级别越高,且不能越级使用 --> <h1>一级标题</h1>
<p>段落文本</p>
<!-- `<ul> + <li>` 无序列表;`<ol> + <li>`有序列表 --> <ul> <li>无序列表项</li> </ul> <ol> <li>有序列表项</li> </ol>
<!-- 表单: 提交数据到服务器 --> <!-- name 属性是核心:表单提交时,传给后端的参数就是 name,没有 name,这个字段不会提交 --> <!-- value:传给后端的值 --> <!-- `form action`:提交地址;`method`:get/post --> <form action="/api/user/add" method="post"> <!-- 文本输入框 --> <input type="text" name="username" placeholder="请输入用户名"> <br> <!-- 密码框 --> <input type="password" name="password"> <br> <!-- 数字框 --> <input type="number" name="age"> <br> <!-- 单选框:同一组name必须一样 --> <input type="radio" name="gender" value="1">男 <input type="radio" name="gender" value="2">女 <br> <!-- 复选框,同一个name,后端接收数组 --> <input type="checkbox" name="role" value="admin">管理员 <input type="checkbox" name="role" value="user">普通用户 <br> <!-- 下拉选择框 --> <select name="deptId"> <option value="1">研发部</option> <option value="2">运营部</option> </select> <br> <!-- 文本域,大段文本,备注描述 --> <textarea name="remark" rows="3"></textarea> <br> <!-- 提交按钮 --> <button type="submit">提交</button> <!-- 普通按钮,只给js点击,不会自动提交表单!,主流不靠原生 form 提交来发请求 --> <!-- `type="submit"` 才会触发表单自动提交;`type="button"` 不会,如果不写 type,浏览器默认当作 type="submit" --> <button type="button" onclick="resetForm()">重置</button> </form>
<!-- 表格:列表页常用 --> <table border="1"> <thead> <tr> <!-- 行 --> <th>ID</th> <!-- 表头单元格 --> <th>用户名</th> </tr> </thead> <tbody> <tr> <td>1</td> <!-- 普通单元格 --> <td>zhangsan</td> </tr> </tbody> </table>
(2)、行内元素(不换行,并排显示):
<!-- span:span 是行内元素,它的"不换行"指的是"前后不强制换行、能和文字并排",不是"内容多了也不折行"。内容超宽时文字照样会折行(中文任意断、英文只在空格处断) --> <!-- 用 span:正常 --> <p>状态:<span style="color:red">禁用</span>,请检查。</p> <!-- 用 div:崩 --> <p>状态:<div style="color:red">禁用</div>,请检查。</p>
<a href="/users/1">链接</a> <a href="https://x.com" target="_blank" rel="noopener">外链</a> <strong>加粗:表示重要性、严重性或紧迫性</strong> <em>斜体:表示重读强调</em>
<!-- 媒体 --> <img src="/img/a.png" alt="图片描述" width="120">
二、CSS:
1、引入方式:
优先级:行内(内联) > style 标签 > 外部 css 文件
(1)、内联样式(行内样式):优先级最高,直接生效,少用
<template> <!-- 直接在标签上写 style,属性值是 CSS 键值对 --> <div style="color: red; font-size: 18px;"> 我是内联样式的文字 </div> </template>
(2)、内部样式(style 标签):优先级次之,作用域当前页面,可重复定义,最常用
<template> <!-- 结构层:写 HTML 标签,通过 class 关联样式 --> <div class="title">你好,CSS</div> </template> <style scoped> /* scoped:样式只会在当前组件生效,不会污染其他组件 */ /* 样式层:写 CSS 代码 */ .title { color: blue; font-size: 20px; } </style>
(3)、外部样式(独立 .css 文件):优先级最低,作用域全局,可重复定义,不常用,适用全局重置样式、公共主题样式、通用工具类
<!-- 公共样式放 main.js,私有样式放 scoped --> <!-- 方式一:全局引入(项目所有页面生效),在 `main.js` 里引入 --> // main.js import './assets/css/common.css' <!-- 方式二:组件内引入(仅当前组件生效,配合 scoped),非常不推荐 --> <style scoped> @import './assets/css/common.css'; </style>
2、选择器:
CSS 的灵魂,作用就是「精准选中想改样式的标签」
<!-- 语法规则 --> 选择器 { 属性名: 属性值; 属性名: 属性值; }
(1)、类选择器(最常用):一个标签可以加多个 class,用空格隔开,样式会叠加生效
<!-- 写法: . + class 名称 --> <template> <!-- 标签上加 class 属性,值对应选择器的名字 --> <div class="text-red">我是红色文字</div> <div class="text-red font-big">一个标签可以加多个 class,用空格隔开,样式会叠加生效</div> </template> <style scoped> /* 选中所有 class="text-red" 的标签 */ .text-red { color: red; } .font-big { /* font-size: 16px; 这条样式被注释了,不会生效,数值类属性大部分都要加单位,比如宽度、字号,单位是 `px`(像素) */ font-size: 24px; } </style>
(2)、标签选择器:选中页面上所有该标签,不管 class 是什么
<!-- 写法: 直接写标签名,不加点、不加 # --> <!-- 注意:范围太大,业务样式很少直接用,一般用于全局重置或基础排版 --> <template> <p>我是第一个 p,会变灰</p> <div>我是 div,不受 p 选择器影响</div> </template> <style scoped> /* 选中所有 p 标签 */ p { color: #666; /* 数值类属性要加单位,比如字号、宽度、高度 */ font-size: 14px; } </style>
(3)、ID 选择器(唯一标识):一个页面 id 应该唯一,用 # 选中
<!-- 写法: # + id 名称 --> <!-- 注意:权重太高,样式里少用,改起来不好覆盖,更多用于锚点或 JS 获取元素 --> <template> <!-- id 一般一个页面只出现一次 --> <div id="page-header">我是 id="page-header" 的元素</div> <div class="page-header">我是 class="page-header",不会被 #page-header 选中</div> </template> <style scoped> /* 选中 id="page-header" 的元素 */ #page-header { height: 60px; background: #f5f5f5; } </style>
(4)、后代选择器:选中「某个元素内部所有符合条件的后代」,不管嵌套多少层
<!-- 写法: 祖先选择器 空格 后代选择器 --> <!-- 作用:给样式加一个“只在某个区域内生效”的条件 --> <!-- 特点:中间隔任意层元素都匹配,不要求直接父子关系 --> <template> <div class="card"> <!-- 直接子元素,会选中 --> <p class="title">卡片里的标题,会变蓝</p> <div class="inner"> <!-- 深层嵌套,也会选中 --> <p class="title">深层嵌套的标题,也会变蓝</p> </div> </div> <!-- 不在 .card 里面,不会选中 --> <p class="title">外面的标题,不会变蓝</p> </template> <style scoped> /* 选中 .card 内部所有 .title,不管隔多少层 */ .card .title { color: blue; } </style>
(5)、子代选择器:只选中「某个元素的直接子元素」,只隔一层
<!-- 写法: 父选择器 空格 > 空格 子选择器 --> <!-- 特点:目标必须是直接子元素,中间隔其他元素就不匹配 --> <!-- 和后代的区别:后代隔多少层都选,子代只选直接子元素 --> <template> <div class="card"> <!-- 直接子元素,会选中 --> <p class="title">直接子元素标题,会加粗</p> <div class="inner"> <!-- 隔了一层 .inner,不会被 .card > .title 选中 --> <p class="title">深层标题,不会加粗</p> </div> </div> </template> <style scoped> /* 只选 .card 的直接子元素 .title */ .card > .title { font-weight: bold; } </style>
(6)、分组选择器:两个或多个选择器共用同一套样式
<!-- 写法: 选择器1, 选择器2 { } --> <!-- 注意:逗号不是后代关系,是“这几个都选中”,互相独立 --> <template> <div class="card">我是 .card,会有边框</div> <div class="panel">我是 .panel,也会有边框</div> <div class="other">我是 .other,不会有边框</div> </template> <style scoped> /* .card 和 .panel 都加边框,互相独立 */ .card, .panel { border: 1px solid #ddd; /* 数值类属性要加单位,1px 表示 1 像素 */ padding: 12px; } </style>
(7)、连写选择器:同一个元素必须同时满足多个 class 才选中,样式才生效
<!-- 写法: .类1.类2,中间没有空格 --> <!-- 注意:和 .类1 .类2 不同,有空格是后代,无空格是同一元素 --> <template> <!-- 同时有 btn 和 primary,会选中 --> <button class="btn primary">主按钮,蓝色背景</button> <!-- 只有 btn,不会选中 --> <button class="btn">普通按钮,没有蓝色背景</button> </template> <style scoped> /* 同一个元素同时有 .btn 和 .primary 才生效 */ .btn.primary { background: #1677ff; color: #fff; } </style>
(8)、伪类选择器:伪类(状态 / 位置,选中元素),不是选标签本身,是选【元素的某种状态、特定位置】
<!-- 写法: 选择器:伪类名 --> <!-- :hover 状态伪类(交互必用):鼠标悬停时生效 --> <!-- :focus / :disabled / :checked 表单状态伪类(表单常用):按输入框/复选框的状态选中 --> <!-- :first-child / :last-child / :nth-child(n) 结构伪类(列表常用):按元素在父元素里的位置选中 --> <!-- 作用:不用加 class,浏览器自带状态 --> <template> <button class="btn">鼠标移上来,背景会变灰</button> <button class="link">鼠标移上来,文字会变蓝</button> <!-- 聚焦时边框变蓝 --> <input class="input" type="text" placeholder="点我聚焦,边框会变蓝"/> <ul class="list"> <li>第一项,会变红</li> <li>第二项,奇数行有背景</li> <li>第三项,奇数行有背景</li> <li>第四项,会变蓝</li> </ul> </template> <style scoped> /* 鼠标悬停在 .btn 上时生效 */ .btn:hover { background: #eee; } /* 鼠标悬停在 .link 上时生效 */ .link:hover { color: blue; } .input:focus { border: 1px solid blue; outline: none; } /* 第一个 li */ .list li:first-child { color: red; } /* 最后一个 li */ .list li:last-child { color: blue; } /* 奇数行:1、3、5... */ .list li:nth-child(odd) { background: #fafafa; } </style>
(9)、伪元素 ::before / ::after(装饰常用):伪元素(生成一个看不见的新元素),在元素内容前/后插入一个虚拟元素
<!-- 写法: 选择器::before / ::after,双冒号 --> <!-- 注意:必须写 content 才生效,content 可以是空字符串 --> <template> <div class="divider">上面有一条分割线</div> <button class="btn">按钮前面有个箭头</button> </template> <style scoped> /* 在 .divider 内容后面插入一条分割线 */ .divider::after { content: ""; display: block; height: 1px; background: #eee; } /* 在 .btn 内容前面插入一个箭头 */ .btn::before { content: "→"; } </style>
(10)、嵌套写法 &(工程组织):把子规则写在父规则里面,& 代表父选择器
<!-- 写法: 父选择器 { 子规则 { } &:hover { } &::after { } } --> <!-- 注意:嵌套不增加权重,只是写法方便,原生 CSS、SCSS、Less 都支持 --> <template> <div class="card"> <p class="title">卡片标题</p> <button class="btn">按钮</button> </div> </template> <style scoped> .card { padding: 16px; /* 等价于 .card .title */ .title { font-size: 18px; } /* 等价于 .card > .btn */ > .btn { margin-top: 8px; } /* 等价于 .card:hover */ &:hover { box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1); } /* 等价于 .card::after */ &::after { content: ""; display: block; height: 1px; background: #eee; } /* 等价于 .card.active,同一元素加类 */ &.active { border-color: blue; } } </style>
3、盒模型:
任意元素都可以看成一个盒子,元素占多大、内容离边框多远、元素之间隔多远
盒子由四层组成(从内向外):content 内容区 → padding 内边距 → border 边框 → margin 外边距
盒模型分为两种:content-box(标准盒模型,默认)、border-box(IE盒模型)
- content-box(默认):width/height 只包括内容区,不包括内边距、边框、外边距,盒子实际宽度 = width + padding-left + padding-right + border-left + border-right
- border-box:width/height 包括内容区、内边距、边框,不包括外边距,内容区宽度 = width - padding-left - padding-right - border-left - border-right
<!-- box-sizing: border-box 让 width 包含 padding 和 border,项目里几乎必设 --> <template> <div class="box">我是盒子</div> </template> <style scoped> .box { /* 宽度 200px,包含 padding 和 border,不会撑大 */ width: 200px; height: 100px; /* 内边距:内容和边框的距离,数值要加单位 */ padding: 16px; /* 边框:粗细 样式 颜色 */ border: 1px solid #ddd; /* 外边距:和其他元素的距离 */ margin: 20px; /* 让 width 包含 padding 和 border,最常用 */ box-sizing: border-box; /* 背景色方便看范围 */ background: #f5f5f5; } </style>
4、Flex 布局:
一维排列,横向或纵向,用于项目布局
<template> <div class="flex-wrap"> <div class="item">左</div> <div class="item">中</div> <div class="item">右</div> </div> </template> <style scoped> .flex-wrap { /* 给父容器开启弹性布局;直接子元素自动变为flex子项 */ display: flex; /* 设置主轴方向 * row(默认):主轴水平,子项从左向右排;主轴=水平,交叉轴=垂直 * row-reverse:主轴水平,子项从右向左排 * column:主轴垂直,子项从上向下排;主轴=垂直,交叉轴=水平 * column-reverse:主轴垂直,子项从下向上排 */ flex-direction: row; /* 主轴对齐方式(沿着flex-direction那条轴生效) * flex-start:子项贴主轴起点(默认值) * flex-end:子项贴主轴终点 * center:子项在主轴居中 * space-between:首尾子项贴容器两端,中间空隙均分 * space-around:每个子项左右/上下空隙相等,两端会留白 * space-evenly:所有空隙(包括容器两端)大小完全一致 */ justify-content: center; /* 交叉轴对齐方式(和主轴垂直的那条轴),单行flex生效 * stretch:子项拉伸填满容器交叉轴方向尺寸(默认值) * flex-start:子项贴交叉轴起点 * flex-end:子项贴交叉轴终点 * center:子项在交叉轴居中 * baseline:按子元素文字基线对齐 */ align-items: center; /* 子项之间的间距,只存在于元素中间,不会在容器首尾产生间距 * gap: 12px; 行间距、列间距都为12px * gap: 10px 20px; row-gap:10px(垂直间隙),column-gap:20px(水平间隙) * 优势:相比margin,不会多出外边距、不会出现最后一个元素多余边距问题 */ gap: 12px; /* 补充:换行,默认 nowrap 不换行,子项会被挤压收缩 */ flex-wrap: nowrap; /* nowrap:不换行,空间不足子项压缩 * wrap:空间不够自动换行,从上往下换行 * wrap-reverse:自动换行,从下往上换行 */ } .item { flex: 1; /* flex: flex-grow flex-shrink flex-basis; * flex-grow:放大比例,0不放大 * flex-shrink:缩小比例,0不缩小 * flex-basis:基准尺寸,类似width,优先级高于width * flex:1 等价于 flex:1 1 0%; 均分剩余空间 * flex: 0 0 100px; 固定宽度,不放大不缩小 */ padding: 8px 16px; background: #1677ff; color: #fff; } </style>
5、position 定位:
让元素脱离正常文档流,或相对某个祖先定位,用于「悬浮在页面固定位置」「相对于父元素定位」等场景,不如 Flex 常用
<!-- relative:相对定位(不脱离文档流,作为 absolute 的父容器) --> <!-- absolute:绝对定位(脱离文档流,相对于最近的定位父元素) --> <!-- fixed:固定定位(相对于浏览器窗口,如回到顶部按钮) --> <template> <div class="card"> <span class="badge">NEW</span> 卡片内容 </div> </template> <style scoped> .card { /* 父元素 relative:给 absolute 子元素提供定位参照 */ position: relative; height: 120px; padding: 16px; background: #f5f5f5; } .badge { /* 子元素 absolute:相对最近的已定位祖先定位 */ position: absolute; /* 距离父元素右边 8px */ right: 8px; /* 距离父元素顶部 8px */ top: 8px; background: red; color: #fff; padding: 2px 6px; } </style>
三、ES6:
1、let/const 替代 var:
const:常量,不允许变量重新赋值(xxx = 新值),块级作用域
let:变量,块级作用域
默认用 const,需要重新赋值才用 let,var 有变量提升 + 函数作用域,容易出坑,新代码别用
<script> // -------------------------- // (1). 块级作用域对比 // -------------------------- { var a = 1; let b = 2; } console.log(a); // 1 // console.log(b); // ReferenceError: b is not defined // -------------------------- // (2). 重复声明对比 // -------------------------- var m = 1 var m = 2 let n = 3 // let n = 4 // Identifier 'n' has already been declared console.log(m) // 2 // console.log(n) // -------------------------- // (3). 变量提升对比 // -------------------------- console.log(x); // undefined var x = 10; // console.log(y); // ReferenceError: y is not defined let y = 20; // -------------------------- // (4). const 重点:const 如何改值 // -------------------------- const name = '张三'; // 基础类型字符串:不能重新赋值,改不了 // name = '李四' // 报错,禁止重新赋值 let count = 0; // 变量,块级作用域 // 情况A:const 是对象:不能给变量重新赋值,但可以改内部属性 const user = { username: "张三", age: 18 } console.log('修改前user', user) user.username = "李四" user.age = 20 console.log('修改后user', user) // user = {} // 报错,禁止重新赋值 // 情况B:const 是数组:不能给变量重新赋值,但可以增删改元素 const arr = [1, 2, 3] console.log('修改前arr', arr) arr.push(4) arr[0] = 99 console.log('修改后arr', arr) // arr = [100,200] // 报错 // 情况C:如果你想要真正不能修改(冻结对象) const person = Object.freeze({ name: "老王" }) // person.name = "老李" // 严格模式下报错,普通模式静默失败 console.log(person.name) </script>
2、函数 + this:
<!-- 普通函数 function (){}: 有独立 this,this 由【怎么调用它】决定 --> <!-- 箭头函数 ()=>{}:没有自己的 this,它的 this 继承自【定义它那一层作用域】的 this,即向外层【作用域】去找,不是往外找对象 --> <!-- 对象字面量 { ... } 仅描述键值,不产生作用域 --> <!-- 规则:对象方法,要用普通 function,不要箭头函数;方法里面传给别的 API(setTimeout、axios.then)的回调,不是对象方法,适合箭头函数 --> <script> // (1). 普通function:函数前面是谁,调用的时候 this 就是谁 const obj1 = { name: "obj1", fn: function () { console.log("普通函数this:", this.name) } } obj1.fn() // this -> obj1 输出 obj1 // (2). 箭头函数:没有自己this,继承外层 const obj2 = { name: "obj2", arrowFn: () => { console.log("箭头函数this:", this.name) } } // key-value 的对象字面量语法,仅描述键值,不产生作用域 // 这里外层是全局作用域,全局没有name,输出空/undefined! obj2.arrowFn() // -------------------------- // (3). 定时器经典场景 const obj3 = { msg: "hello", test1: function () { // setTimeout 的普通回调,是浏览器直接调用,不是 obj3 调用,所以 this 跑到全局 setTimeout(function () { console.log("普通回调this:", this.msg) // this是全局,undefined }, 100) }, // function,产生【函数作用域】 test2: function () { setTimeout(() => { console.log("箭头回调this:", this.msg) // this继承外层test2的this → obj3 }, 100) } } obj3.test1() obj3.test2() </script>
3、解构 + 默认值:
解构: 快速从对象 / 数组里面把值拆出来单独赋值
默认值: 拆不到、值为 undefined 的时候,用上预备的值
只有解构出来的值是 undefined,默认值才生效;null、0、''、false 都不会触发默认值
<script> // 原始接口返回对象 const res = { name: "张三", age: 24, // address 这个字段没有 } // 解构 + 默认值 const {name, age, address = "广州市"} = res console.log(name) // 张三 console.log(age) // 24 console.log(address) // 广州市,因为res里address是undefined,触发默认值 // 解构同时重命名 + 默认值 const {name: username, gender = "男"} = res console.log(username) // 张三 console.log(gender) // 男 </script>
4、模板字符串 ` 反引号:
<!-- 代替双引号 / 单引号,支持直接换行、${} 嵌入变量、表达式 --> <script> // 普通字符串,拼接麻烦,不能直接换行 const name = '张三' const str1 = '你好,' + name + ',今年' + 20 + '岁' // 模板字符串 const str2 = `你好,${name},今年${20}岁` console.log(str2) </script>
5、展开/剩余运算符 ...:
<!-- 展开(spread):`...` 把数组/对象拆成一个个独立项 --> <!-- 剩余(rest):`...` 把一堆东西打包成一个数组,只能放最后 --> <script> // (1). 对象合并,浅拷贝,后面相同key覆盖前面 const defaults = {pageSize: 10, sort: 'asc'} const options = {pageSize: 20, title: '列表'} const merged = {...defaults, ...options}; console.log('merged', merged) // (2). 数组追加,生成新数组,追加元素(不改动原数组arr1) const arr1 = [1, 2, 3] const newItem = 4 const arr2 = [...arr1, newItem]; console.log('arr2', arr2) // (3). 剩余参数,函数参数剩余,剩余只能放最后 function fn(a, b, ...other) { console.log(a) console.log(b) console.log(other) // other 是数组 } fn(1, 2, 3, 4, 5) </script>
6、模块化 import / export:
原生html直接运行 ESM 脚本: 使用时 script 标签必须加 type="module"
Vite/Vue 项目:底层 ESM,工具自动处理,开发者不用写这个属性
(1)、默认导出 export default:一个文件只能有一次默认导出,导入无{},名字自定义
<!-- 默认导出:export default xxx,导入 import 自定义名 from xxx --> // user.js const user = { name: "张三", age: 20 } export default user // main.js // 导入,名字随便写,比如 u / userInfo 都行 import u from './user.js' console.log(u.name)
(2)、命名导出 export:可多个,导出的时候要写名字;导入的时候名字必须一模一样,用 {}
// utils.js
export const add = (a,b) => a + b
export const sub = (a,b) => a - b
// main.js
// 花括号里面名字必须和导出的名字一致
import { add, sub } from './utils.js'
console.log(add(1,2))
(3)、命名导出,别名 as
// utils.js
export const add = (a,b) => a + b
export const sub = (a,b) => a - b
// main.js
import { add as myAdd } from './utils.js'
console.log(myAdd(1,2))
(4)、一次性全部导入 * as
// utils.js
export const add = (a,b) => a + b
export const sub = (a,b) => a - b
// main.js
import * as util from './utils.js'
console.log(util.add(1,2))
(5)、混合导出:
// utils.js
const msg = "hello"
export default msg
export const add = (a,b) => a + b
// main.js
import msg, { add } from './utils.js'
console.log(msg)
console.log(add(1,2))
7、数组高阶方法(替代 for 循环):
<!-- map、filter、reduce、forEach、find、some、every --> <script> const users = [{name: 'a', age: 20}, {name: 'b', age: 30}]; // (1).map: 一对一转换、组装数据、提取字段,返回新数组,长度不变 users.map(u => u.name); // ['a','b'] // (2).filter: 筛选,保留满足条件的元素 users.filter(u => u.age > 20); // [{ name: 'b', age: 30 }] // (3).find: 找到第一个符合条件的元素,找不到返回 undefined users.find(u => u.age === 20); // { name: 'a', age: 20 } // (4).some: 任意一个满足条件就返回 true,找到即停止 users.some(u => u.age > 25); // true // (5).every: 全部满足条件才返回 true,一个不满足立刻 false users.every(u => u.age >= 18); // true // (6).forEach: 单纯遍历,没有返回值,只用来做副作用 users.forEach(u => console.log(u.name)) // (7).reduce: 归并汇总,输出单个结果;acc累加器,存放上一轮计算结果,u当前遍历到的数组项,末尾0是初始值 users.reduce((acc, u) => acc + u.age, 0) // 50 </script>
8、可选链 ?. VS && + 空值合并 ?? VS ||
<!-- 可选链 ?.:读取对象属性时,如果前面是 null / undefined,直接停止、返回 undefined,不抛报错 --> <!-- 短路与运算符 &&:左边为真,才执行/返回右边;左边为假,直接返回左边(假值集合:0、''、null、undefined、false、NaN) --> <!-- 空值合并运算符 ??:只有左边的值是 null / undefined,才取右边默认值; 0、''、false 不会触发 --> <!-- 短路或运算符 ||:左边为真,直接返回左边;左边为假,才执行/返回右边(假值集合:0、''、null、undefined、false、NaN) --> <script> // ===================== 分组对比 ===================== // (1).安全取值:?. VS && const user = { name: 'a', // addr: { city:'广州' } 假设 addr 不存在 } // 老式写法(繁琐) if (user && user.addr && user.addr.city) { console.log(user.addr.city) } // 可选链简写 // user.addr 是 undefined → 直接返回 undefined,不报错 console.log(user.addr?.city) // (2).兜底默认值:?? VS || const height = 0 const h1 = height || 100 const h2 = height ?? 100 console.log(h1) // 100 || 坑,0被当成空 console.log(h2) // 0 ?? 正确,只有 null/undefined 才走右边 </script>
9、Promise + async/await:
(1)、Promise:异步任务容器
由于JS 是单线程,网络请求存在延迟,用Promise封装异步任务,包装一个未来才会完成的操作
一个 Promise 实例只会有三种状态,状态一旦改变就固定,无法二次变更:pending,fulfilled,rejected
- pending:等待中(初始状态,任务还没结束)
- fulfilled:成功,任务顺利完成 → 触发 .then()
- rejected:失败,任务报错(404、500、网络断开) → 触发 .catch()
Promise 内部两个回调参数:resolve()、reject()
- resolve(数据):把 Promise 状态改成 fulfilled,传出成功数据
- reject(错误对象):把 Promise 状态改成 rejected,传出错误信息
<script> // 模拟接口:先获取用户,拿到 userId,再拿该用户的订单(第二个接口依赖第一个的结果) function getUser() { return new Promise((resolve) => { setTimeout(() => { resolve({userId: 1001, name: 'a'}) }, 300) }) } function getOrder(userId) { return new Promise((resolve) => { setTimeout(() => { resolve({orderId: 888, uid: userId}) }, 300) }) } // 原生嵌套 then(不推荐) // 隐患不只是缩进难看:内层是独立Promise链条,外层 .catch 捕获不到内层报错 getUser().then(user => { getOrder(user.userId).then(order => { console.log('订单数据:', order) }) }) // 扁平链式 then(return Promise,整条链路合并,单个catch统一捕获整条链错误) // 缺点:后面的 then 无法访问前面 then 的变量(user 在第二个 then 里面拿不到) getUser() .then(user => getOrder(user.userId)) .then(order => console.log('订单数据:', order)) .catch(err => console.error('接口请求出错', err)) </script>
(2)、async/await(Promise 语法糖,项目推荐写法):
async/await 底层依旧是 Promise,没有新增功能;
优势:异步逻辑可以像同步代码一样从上到下顺序书写,告别回调嵌套
- async:写在函数前面,相当于通行证,只有标记 async 的函数内部才可以使用 await
- await:暂停当前代码执行,等待当前 Promise 任务执行完成,拿到成功结果之后,才继续执行下一行
注意:普通JS里 await 不能直接写在无 async 的函数内;Vue <script setup> 支持顶层 await,是特例
<!-- try catch:捕获 Promise reject 的异常,等价 .catch() --> <script> function getUser() { return new Promise((resolve) => { setTimeout(() => { resolve({userId: 1001, name: 'a'}) }, 300) }) } function getOrder(userId) { return new Promise((resolve) => { setTimeout(() => { resolve({orderId: 888, uid: userId}) }, 300) }) } async function loadData() { try { // 串行执行:先等 getUser 完成拿到 user,再用 user.userId 请求订单 const user = await getUser() const order = await getOrder(user.userId) console.log('订单数据:', order) } catch (err) { console.error('接口请求出错', err) } } loadData() </script>
(3)、Promise.all 并发请求:多个接口互不依赖,可以同时发起
特点:所有Promise一起同时执行;全部成功才返回结果数组;任意一个失败,整体直接失败
适合:接口之间没有依赖关系,并发可以节省总等待时间
<script> function getUser() { return new Promise((resolve) => { setTimeout(() => { resolve({userId: 1001, name: 'a'}) }, 300) }) } function getGoods() { return new Promise((resolve) => { setTimeout(() => { resolve({goodsId: 666, title: '商品'}) }, 300) }) } async function loadAll() { try { // 两个请求同时发出,并行执行 const [user, goods] = await Promise.all([getUser(), getGoods()]) console.log(user, goods) } catch (err) { console.error('并发请求出错', err) } } loadAll() </script>
四、VUE2/VUE3:
现代前端框架(以 Vue 为例)的整体设计思路,本质上是构建一套“以数据驱动视图为核心、以路由为枢纽的单页应用(SPA)运转体系”。整个项目从启动到展现,是一套高度工程化的流水线:工程化工具以 index.html 作为页面承载容器,以 main.js 作为应用启动入口,引入 Vue 并实例化,将根组件(如 App.vue)挂载到页面上。在底层,Vue 利用响应式系统(Vue 2 的 Object.defineProperty 或 Vue 3 的 Proxy)建立数据与视图的绑定,并通过虚拟 DOM(VNode)与 Diff 算法,将模板高效地转化为真实的浏览器 DOM,从而构建出一棵由无数小组件拼装而成的“组件树”。
在这套体系之上,前端路由(Vue Router)接管了“页面切换”的调度权。由于单页应用无需刷新请求新页面,我们需要定义一张“路由映射表(routes)”,将不同的 path 与具体的页面组件绑定。在实际布局中,我们用 HTML + CSS 画好页面骨架,并在内容区放置一个 <router-view> 作为动态组件的占位符。为了让路由同时服务于逻辑与界面,在企业级实战中通常会将“菜单”与“路由”解耦:单独定义一份“菜单骨架设计图(Menu 配置)”,通常带有 title、icon、权限标识等字段;前端拿到这份设计图后,利用 v-for 循环渲染成可视化的导航按钮,并把按钮的点击事件绑定到设计图中的 path 上。这样,菜单就成了一份直观的导航视图。
当用户点击菜单时,前端调用 router.push(path) 改变 URL 而不刷新页面。此时,前端会拿着这个 path 去查真正的“路由地图(routes)”。路由监听 URL 变化并匹配出对应组件后,<router-view> 所在区域会触发 Vue 的响应式更新,通过 Diff 算法销毁旧组件、挂载新组件,完成页面的局部更新。而如果是页面内部的状态切换(如“全部/待付款”Tab),则无需动用路由,直接通过 ref 定义状态变量,利用 v-if 或 v-show 配合点击事件,纯靠数据驱动局部的视图显隐即可。
总而言之,整个设计思路就是:以工程化工具为基石,以响应式数据为核心,用配置(Menu)生成导航按钮,用映射(Routes)匹配页面组件;通过点击按钮改变 URL,触发 <router-view> 的局部替换,最终实现流畅、高效且高度可维护的单页应用体验。
1、Vue 脚手架:
一套自动搭好项目骨架的工具(通过nvm进行node版本管理)
npm run xxx 本质就是读取 项目里package.json 中的 scripts 脚本配置,脚本名字可以自定义
scripts 是脚本字典,key就是 run 后面的名字,value是实际执行命令
dist 部署两种方案:
- 前后端分离:Nginx 直接托管整个 dist 目录
- 非前后端分离:将 dist 内所有文件复制到后端工程静态资源目录
(1)、vue-cli(基于 webpack):常用来生成 Vue2 项目
# 全局安装
npm install -g @vue/cli
# 创建项目
vue create 自定义项目名
# 安装依赖
npm install
# 启动(读取 package.json 的 scripts 脚本配置)
npm run serve
# 打包(产出dist文件夹,用于部署)
npm run build
(2)、Vite:Vue3 官方推荐新脚手架,速度更快,原生支持 ESM
# 创建项目(只勾选 Router + Pinia + ESLint + Prettier,其他全部 No,试验特性全不选,保留示例代码)
npm create vue@latest 自定义项目名
# 安装依赖
npm install
# 启动(读取 package.json 的 scripts 脚本配置)
npm run dev
# 打包(产出dist文件夹,用于部署)
npm run build
2、运行机制:先打包再运行 与 按需编译即时运行
核心差异:Webpack 预打包;Vite 依托浏览器原生 ESM,请求到来时按需编译
(1)、Vue2(Vue CLI+Webpack):先全量打包,再启动开发服务
遵循先打包后运行模式:开发阶段以 src/main.js 为入口,由 Webpack 将整个项目打包为 bundle,再经 HtmlWebpackPlugin 自动把产物脚本注入 public/index.html;浏览器加载后执行 main.js,通过 new Vue ({render: h => h (App) }).$mount ('#app') 创建 Vue 实例并挂载至 #app,Vue 引擎基于 Object.defineProperty 建立响应式系统,最终完成首次渲染。
(2)、Vue3(Vite):基于浏览器原生 ESM,按需编译、即时运行
利用浏览器原生 ESM,按需编译、即时运行:根目录 index.html 作为真实入口,直接通过 <script type="module" src="/src/main.js"> 引入;浏览器执行 main.js,调用 createApp (App).mount ('#app') 创建应用实例,Vite 开发服务器在请求到达时按需编译 .vue 文件,Vue3 基于 Proxy 建立响应式并完成渲染,vite.config.js 替代 vue.config.js,开发服务器启动速度远快于 Webpack。
3、组件语法:Options API 与 Composition API
(1)、Options API(Vue2):
<!-- 组织形式:按选项分类,data/computed/methods/watch/生命周期分开存放,同类代码放在同一个选项下 --> <!-- name:组件名称,用于调试、keep-alive、递归组件,规范大驼峰 --> <!-- components:局部注册子组件,注册后模板才可使用 --> <!-- props:接收父组件传递数据,支持类型校验、必填、默认值,单向数据流 --> <!-- data:声明响应式原始状态,组件必须是函数返回对象,防止多实例数据污染 --> <!-- computed:计算属性,基于依赖派生新值,自带缓存,适合同步计算、格式化展示 --> <!-- methods:业务方法,事件回调、接口请求、自定义动作,无缓存,通过this调用 --> <!-- watch:侦听器,监听数据变化执行副作用,适合异步请求、状态联动;支持deep、immediate --> <!-- 生命周期:实例创建完成、DOM挂载完成、组件销毁前 --> <!-- created:实例创建完成,data/methods就绪,DOM未生成,适合初始化接口请求 --> <!-- mounted:DOM挂载完成,可操作DOM、初始化第三方DOM插件 --> <!-- beforeDestroy:组件销毁前,清理定时器、订阅、事件监听,防止内存泄漏 --> <!-- 其他常用:mixins、provide/inject、emits、expose --> <!-- filters:过滤器,模板文本格式化(Vue3移除) --> <!-- directives:局部自定义指令,封装底层DOM操作 --> <template> <div class="container"> </div> </template> <script> export default { /** * 组件标识名 * 用途:VueDevtools调试、keep-alive按名称缓存、递归组件 * 规范约定:SFC文件名(Demo.vue) 和 name值(Demo)保持一致,大驼峰 */ name: 'Demo', /** * 局部组件注册 * 仅注册后的组件,可在当前模板中使用 */ components: {}, /** * Props 入参声明 * 用于接收父组件传递的数据,提供类型校验、必填控制、默认值 * 单向数据流:子组件禁止直接修改props */ props: {}, /** * 响应式原始数据 * 组件必须使用函数返回对象,避免多实例之间数据污染 * 存放独立、可直接修改的基础状态 */ data() { return {} }, /** * 计算属性 * 基于已有响应式依赖同步派生值,自带依赖缓存 * 依赖不变时,多次读取不会重复执行;适合模板格式化、数据聚合 * 禁止在内部执行异步、修改依赖等副作用 */ computed: {}, /** * 方法集合 * 用于事件回调、手动调用、接口请求、业务动作 * 无缓存,每次调用都会执行 */ methods: {}, /** * 侦听器 * 监听指定响应式数据变化,执行副作用逻辑 * 适合异步请求、状态联动、复杂变更处理;简单派生优先使用computed */ watch: {}, /** * 生命周期:实例创建完成 * data、methods 已完成初始化;DOM尚未挂载 * 推荐:初始化接口请求、前置数据预处理 */ created() { }, /** * 生命周期:DOM挂载完成 * 模板已渲染到页面,可以访问DOM节点、实例第三方DOM插件 */ mounted() { }, /** * 生命周期:组件销毁前 * 推荐资源清理:定时器、事件订阅、请求取消、websocket,防止内存泄漏 */ beforeDestroy() { } } </script> <style scoped> /** * scoped:样式隔离,仅作用于当前组件DOM,不污染全局样式 */ .container { } </style>
(2)、Composition API(Vue3 setup语法糖 <script setup>)
<!-- 组织形式:按业务逻辑聚合,相关的状态、计算、方法、监听写在一起 --> <!-- Vue3同时支持两种API,不是二选一;新项目优先<script setup> --> <!-- <script setup>:编译器帮你自动 return,省略样板代码 --> <template> <div class="container"> </div> </template> <script setup> /** * <script setup>:Vue3 Composition API 语法糖 * 逻辑按业务聚合,不再按data/methods/computed分类;顶层变量、函数模板可直接访问 * 无this,响应式API:ref、reactive、computed、watch */ import {ref, reactive, computed, watch, onMounted, onBeforeUnmount} from 'vue' /** * 响应式基础数据 * ref:基础类型(string/number/boolean),读取修改需要 .value * reactive:引用类型(object / array),不需要 .value */ const count = ref(0) const state = reactive({}) /** * 计算属性 * 基于响应式依赖派生值,自带缓存,适合同步计算、格式化展示 * 禁止内部写异步、修改依赖等副作用 */ const doubleCount = computed(() => { return count.value * 2 }) /** * 方法函数 * 业务动作、事件回调、接口请求,直接声明函数 */ const handleAdd = () => { count.value++ } /** * 侦听器 * 监听响应式数据变化,执行副作用逻辑(异步请求、状态联动) * 配置参数:{ deep: true, immediate: true } */ watch(count, (newVal, oldVal) => { }) /** * 生命周期钩子 * onMounted:DOM挂载完成,可操作DOM、初始化第三方DOM插件 */ onMounted(() => { }) /** * onBeforeUnmount:组件销毁前,清理定时器、订阅、事件监听,防止内存泄漏 */ onBeforeUnmount(() => { }) </script> <!-- 单独script块声明组件name:可选 --> <!-- 需要keep-alive缓存、递归组件、清晰调试名称时保留;简单组件可删除 --> <script> /** * 组件标识名 * 用途:VueDevtools调试、keep-alive按名称缓存、递归组件 * 规范:大驼峰 PascalCase,尽量和SFC文件名保持一致 */ export default { name: 'Demo' } </script> <style scoped> /** * scoped:样式隔离,仅作用于当前组件DOM,不污染全局样式 */ .container { } </style>
4、Vue 常用指令:
| 常用指令 | 说明 |
|---|---|
| v-bind | 动态绑定属性,简写 :,用于绑定 class、style、原生属性 |
| v-on | 绑定事件,简写 @,绑定点击、输入等事件 |
| v-model | 双向数据绑定,多用于表单元素 |
| v-if | 条件渲染,满足条件才渲染 DOM,销毁重建 |
| v-else | 搭配 v-if,不满足 v-if 时渲染 |
| v-else-if | 多分支条件渲染 |
| v-show | 条件显示隐藏,切换 display,DOM 始终存在 |
| v-for | 列表循环渲染,遍历数组 / 对象,必须绑定 key |
| v-text | 设置元素文本,等价插值 {{}} |
| v-html | 渲染原始 HTML,存在 XSS 风险,谨慎使用 |
| v-once | 元素只渲染一次,后续数据变化不再更新 |
5、Vue3 + vue-router@4路由:
前端路由是单页应用(SPA)的调度枢纽。其本质是建立 URL 路径(Path)与组件视图(包含 HTML 结构)的映射关系。在实际开发中,遵循“搭建 Layout 框架 -> 规划栏目 Path -> 配置路由映射”的开发流;在运转时,当 Path 发生改变,路由自动匹配对应组件,并将其动态渲染至 <router-view> 占位区,从而实现页面的无刷新局部替换。
(1)、路由基本配置:
1)、安装依赖:
npm install vue-router@4
2)、路由配置 src/router/index.js:
导入文件夹时,打包工具自动识别 index.js,import router from './router' 等价于导入该文件
配置流程:定义路由表routes → createRouter创建实例 → 导出router → main.js中app.use(router)挂载
// src/router/index.js
// createRouter:负责创建路由器实例
// createWebHistory:负责创建 history 模式的历史记录对象
import {createRouter, createWebHistory} from 'vue-router'
// 1. 定义路由映射表:路径与组件一一对应
const routes = [
{
// 路由路径:定义该路由匹配的 URL 路径,与浏览器地址栏的 pathname 对应
path: '/',
// 路由名称:唯一标识,用于命名路由跳转和避免硬编码路径
name: 'Home',
// 路由懒加载:访问时才加载组件,优化首屏性能
component: () => import('@/views/Home.vue'),
// 路由元信息:自定义扩展数据,用于菜单标题、权限标识等
meta: {title: '首页', requiresAuth: false}
},
{
path: '/login',
name: 'Login',
component: () => import('@/views/Login.vue'),
meta: {title: '登录页'}
},
// 404 兜底路由,必须放在最后
{
path: '/:pathMatch(.*)*',
name: 'NotFound',
component: () => import('@/views/404.vue'),
meta: {title: '页面不存在'}
}
]
// 2. 创建路由器实例
const router = createRouter({
// 路由模式:history 模式,URL 美观无#,部署需配置 Nginx 重定向
history: createWebHistory(),
// hash 模式:URL 带#,兼容性好,无需服务端配置
// history: createWebHashHistory(),
routes
})
// 3. 导出路由器实例
export default router
3)、路由挂载 src/main.js:
import {createApp} from 'vue'
import App from './App.vue'
import router from './router'
const app = createApp(App)
// 注册路由插件,全局可用 router-link、router-view
app.use(router)
app.mount('#app')
4)、根组件放置路由出口:
<!-- App.vue --> <template> <!-- 路由匹配到的组件,将渲染在此位置 --> <router-view/> </template>
(2)、嵌套路由:
适用于带侧边栏、顶部导航的布局页,子页面渲染在父布局的 <router-view> 中
1)、路由配置 src/router/index.js:
const routes = [
{
path: '/layout',
name: 'Layout',
component: () => import('@/layout/index.vue'),
// 子路由,路径自动拼接父路径
children: [
{
// 子路径前不加 /,相对路径;访问 /layout/user
path: 'user',
name: 'User',
component: () => import('@/views/user/index.vue'),
meta: {title: '用户管理'}
},
{
path: 'order',
name: 'Order',
component: () => import('@/views/order/index.vue'),
meta: {title: '订单管理'}
},
// 默认子路由:访问 /layout 时自动跳转
{
path: '',
redirect: '/layout/user'
}
]
}
]
2)、父布局组件示例:
router-view:路由页面的 “占位容器”,当路由匹配成功后,对应的页面组件,就渲染到 <router-view> 的位置
<!-- src/layout/index.vue --> <template> <div class="layout"> <aside class="sidebar">侧边栏菜单</aside> <main class="content"> <!-- 子页面渲染坑位,必须保留 --> <router-view/> </main> </div> </template>
(3)、页面跳转方式:
1)、声明式导航(模板内用):
<template> <!-- 1. 静态路由:默认渲染为 <a> 标签,点击不刷新页面 --> <router-link to="/">首页</router-link> <!-- 2. 命名路由:解耦硬编码路径,后续修改 path 不影响此处 --> <router-link :to="{ name: 'User' }">用户管理</router-link> <!-- 3. Params 传参:必须配合 name;需路由配置动态段(/:id),否则刷新丢参 --> <router-link :to="{ name: 'User', params: { id: 123 } }">用户 123</router-link> <!-- 4. Query 传参:拼接在 URL 后 (?id=123),刷新参数不丢失 --> <router-link :to="{ path: '/user', query: { id: 123 } }">查询用户</router-link> <!-- 5. Replace 模式:替换当前历史记录,跳转后无法通过浏览器后退返回 --> <router-link to="/login" replace>登录(禁止后退)</router-link> <!-- 6. Custom 自定义渲染:不用 <a> 标签,通过 v-slot 暴露跳转方法(isActive 判断激活) --> <router-link to="/home" custom v-slot="{ navigate, isActive }"> <button @click="navigate" :class="{ active: isActive }">自定义按钮</button> </router-link> </template>
2)、编程式导航(JS 代码中用):
<script setup> // useRouter:获取路由器实例(用于操作路由,如跳转) // useRoute:获取当前路由信息对象(用于读取路由,如获取参数) import {useRouter, useRoute} from 'vue-router' // 1. 获取路由操作实例:useRouter const router = useRouter() // push:跳转页面,并新增历史记录(按浏览器“后退”键可返回上一页,最常用) // 传参互斥:Vue Router 4 中 path 和 params 不能同时用,传 params 必须搭配 name // router.push({ path: '/user', params: { id: 1 } }) :错误,params 会被忽略 // router.push({ name: 'User', params: { id: 1 } }) :正确,使用命名路由 const goHome = () => { router.push('/') // 推荐使用命名路由,避免硬编码路径 router.push({name: 'Home'}) } // replace:跳转页面,但替换当前历史记录(按浏览器“后退”键无法返回上一页,常用于登录成功、404重定向) const goLogin = () => { router.replace('/login') } // go / back:基于历史栈进行页面前进或后退 const goBack = () => { router.go(-1) // 后退一页 router.go(1) // 前进一页 router.back() // 等价于 go(-1) } // 2. 读取路由参数:useRoute const route = useRoute() const id = route.query.id // 读取 Query 参数(URL 中的 ?id=123) const userId = route.params.id // 读取 Params 参数(动态路由 /user/123 中的 123) const title = route.meta.title // 读取 Meta 元信息(路由配置中的自定义数据) </script>
(4)、路由传参:Params 与 Query
// ========================================== // 1). 路由配置 // 位置:src/router/index.js const routes = [ // 动态路由:必须使用 :id 占位,否则 params 刷新会丢失 { path: '/user/:id', name: 'User', component: User } ] // ========================================== // 2). 传参方式 (两种) // 位置:在【跳转前】的组件内(<script setup>)或普通 .js 文件 // 传参互斥:Vue Router 4 中 path 和 params 不能同时用,传 params 必须搭配 name // 【Query 传参】:参数拼接在 URL 后 (?id=123),path /name 均支持 // 特点:刷新页面不丢失,兼容性最好(推荐) router.push({path: '/user', query: {id: 123}}) // 【Params 传参】:参数隐藏在 URL 路径中 (/user/123),仅支持 name // 特点:必须搭配 name 使用,且路由必须配置 :id 占位(有占位符刷新就不丢失) router.push({name: 'User', params: {id: 123}}) // ========================================== // 3). 接收参数 // 位置:在【跳转后】的目标页面组件内(<script setup>) import {useRoute} from 'vue-router' const route = useRoute() const queryId = route.query.id // 接收 Query 参数 const paramsId = route.params.id // 接收 Params 参数 // 在目标页面的模板中直接使用: // <div>{{ $route.query.id }}</div> // <div>{{ $route.params.id }}</div>
(5)、路由全局守卫:在路由跳转前后进行拦截处理
| 守卫 | 说明 |
|---|---|
| beforeEach | 全局前置守卫,最常用,所有路由跳转前执行,常用于登录鉴权、权限判断 |
| beforeResolve | 全局解析守卫,beforeEach 之后,异步路由组件全部加载完毕后,确保进入页面前所有数据都已就绪 |
| afterEach | 全局后置钩子,路由跳转已完成渲染,无返回值无法中断导航,常用于关闭进度条、页面访问埋点 |
| beforeEnter | 路由独享守卫,仅在路由配置中定义,只对当前指定路由生效,常用于单页面级别权限校验 |
| onBeforeRouteLeave | 组件内守卫,在离开当前组件对应的路由前触发,常用于弹出 “确认离开” 防误触提示框 |
| onBeforeRouteUpdate | 组件内守卫,当前路由参数变化但复用组件时触发,常用于监听参数变化并重新请求数据 |
// src/router/index.js // 全局前置守卫:beforeEach(最常用) // 作用:所有路由跳转前执行,常用于登录鉴权、权限判断 router.beforeEach((to, from) => { // to:即将进入的目标路由对象(可读取 path, meta, query 等) // from:正要离开的当前路由对象 // Vue 3 中去除了 next 参数,直接通过 return 控制导航 // 1. 设置页面标题 if (to.meta.title) { document.title = to.meta.title } // 2. 登录鉴权逻辑 const token = localStorage.getItem('token') // 如果该页面需要登录权限,且当前没有 token if (to.meta.requiresAuth && !token) { // 返回目标路径,中断当前导航并重定向到登录页 // 可携带当前路径参数,方便登录后跳回:return `/login?redirect=${to.fullPath}` return '/login' } // 不需要鉴权,或已有 token,返回 true 放行(或直接 return undefined) return true }) // ========================================== // Vue 2 写法对比 // router.beforeEach((to, from, next) => { // // to:即将进入的目标路由对象 // // from:正要离开的路由对象 // // next:放行控制函数(必须且只能调用一次) // // const token = localStorage.getItem('token') // if (to.meta.requiresAuth && !token) { // next('/login') // 重定向 // } else { // next() // 放行 // } // })
6、Vue3 + Axios前后端数据交互:
基于Promise的HTTP库,Vue项目主流接口请求方案,浏览器与Node环境通用
开发流:创建 Axios 实例 -> 配置请求/响应拦截器 -> 封装 API 模块 -> 组件内发起调用。
(1)、安装依赖:
npm install axios
(2)、封装 Axios 实例与拦截器:
位置:src/utils/request.js
请求拦截器(xx.interceptors.request.use):请求发出前统一处理,携带token、参数格式化、请求签名
响应拦截器(xx.interceptors.response.use):接口返回后统一处理,剥离业务数据、错误码拦截、token失效跳转
import axios from 'axios' import {ElMessage} from 'element-plus' import router from '@/router' /** * 创建 axios 实例 * 统一基础配置 */ const service = axios.create({ // Vite 环境读取环境变量,前缀必须为 VITE_ baseURL: import.meta.env.VITE_BASE_API, // 请求超时时间,单位毫秒 timeout: 10000 }) /** * 请求拦截器 * 请求发出前统一处理:携带token、设置请求头 */ service.interceptors.request.use( config => { const token = localStorage.getItem('token') if (token) { config.headers['Authorization'] = `Bearer ${token}` } return config // 必须 return config,否则请求发不出去 }, error => { // 请求发出失败处理 return Promise.reject(error) } ) /** * 响应拦截器 * 接口返回后统一处理:数据剥离、业务错误码拦截、token失效处理 */ service.interceptors.response.use( response => { const res = response.data if (res.code !== 200) { ElMessage.error(res.msg || '请求失败') // token 失效跳转登录 if (res.code === 401) { localStorage.removeItem('token') router.replace('/login') } return Promise.reject(new Error(res.msg || '请求失败')) } return res }, error => { ElMessage.error(error.message || '网络异常,请稍后重试') return Promise.reject(error) } ) export default service
(3)、统一管理 API 接口:
位置:src/api/user.js
GET 请求:参数必须放在 params (URL ? 后拼接) 中
POST/PUT 请求:参数必须放在 data (请求体body) 中
import request from '@/utils/request' /** * 查询用户信息 */ export const getUserInfo = (params) => { return request({ url: '/api/user/info', method: 'get', params // get 请求用 params,参数拼在 url 后 }) } /** * 新增用户 */ export const addUser = (data) => { return request({ url: '/api/user/add', method: 'post', data // post 请求用 data,参数放请求体 }) }
(4)、组件内调用:
<script setup> import {ref, onMounted} from 'vue' import {getUserInfo, addUser} from '@/api/user' const userInfo = ref({}) // 加载用户数据 const loadUserInfo = async () => { try { const res = await getUserInfo({userId: 1}) userInfo.value = res.data } catch (err) { console.error('用户信息加载失败', err) } } onMounted(() => { loadUserInfo() }) </script>
7、Vue 的全局共享数据仓库(状态管理库):Vuex 与 Pinia
(1)、Vue2 官方状态管理库(Vue3推荐Pinia替代):Vuex
| 成员 | 说明 |
|---|---|
| state | 全局共享状态,存放公共数据 |
| getters | 全局计算属性,缓存派生数据,类似组件 computed |
| mutations | 唯一修改 state 的地方,同步方法,必须是同步,用于修改状态 |
| actions | 业务动作,可同步可异步,放接口请求;通过 commit 调用 mutation 修改 state |
| modules | 模块拆分,解决单一仓库臃肿,开启 namespaced 实现命名空间隔离 |
| commit | 组件内调用 mutation |
| dispatch | 组件内调用 action |
|
mapState / mapGetters / mapMutations / mapActions |
辅助函数,简化组件内引入 |
// store/index.js import Vue from 'vue' import Vuex from 'vuex' Vue.use(Vuex) export default new Vuex.Store({ /** * state:全局共享状态 * 存放公共数据 */ state: { count: 0 }, /** * getters:全局计算属性 * 基于state派生数据,自带缓存,类似组件computed */ getters: { doubleCount(state) { return state.count * 2 } }, /** * mutations:修改state唯一入口 * 只能同步操作,不能写异步 * 通过commit调用 */ mutations: { SET_COUNT(state, val) { state.count = val } }, /** * actions:业务动作 * 支持同步、异步,接口请求放这里 * 通过dispatch调用,内部commit mutation改状态 */ actions: { async fetchCount({commit}) { // 模拟请求 const res = 10 commit('SET_COUNT', res) } }, /** * modules:模块拆分 * 拆分多个子仓库,namespaced开启命名空间隔离 */ modules: {} })
(2)、Vue3 官方状态管理库:Pinia
和Vuex区别:移除mutation,state可直接修改;天然模块化隔离,无需额外命名空间;TS类型支持友好
| 成员 | 说明 |
|---|---|
| defineStore | 定义仓库,第一个参数为唯一 id,作为 store 标识,全局唯一 |
| state | 全局共享状态,存放公共响应式数据,支持直接修改,不再需要 mutation |
| getters | 仓库内计算属性,自带缓存,依赖 state 派生数据,等价组件 computed |
| actions | 仓库业务方法,支持同步、异步逻辑,适合存放接口请求、复杂业务处理 |
| $patch | 批量修改 state,支持对象 / 函数两种写法,一次性更新多个字段,减少多次响应式触发 |
| $reset | 重置 state 为初始默认值,Option Store 原生支持;Setup Store 需要自行封装实现 |
| $state | 直接替换整个仓库 state,传入新对象覆盖全部状态 |
| $subscribe | 订阅 state 变化,state 发生变更时触发回调,常用于本地持久化存储(localStorage) |
| $onAction | 监听 action 执行生命周期,可捕获 action 开始、成功、异常回调,统一处理 loading、错误拦截 |
| storeToRefs | 解构 store 中的 state、getter,保留响应式;actions 可直接解构,不需要该工具函数 |
| useXxxStore | 组件内引入并获取仓库实例,多次调用拿到同一个单例仓库 |
1)、Vue3 — Pinia Option Store 模板:选项式,结构和Vuex很像,上手门槛低,适合从Vuex迁移过来的人
// stores/counter.js import {defineStore} from 'pinia' /** * Option Store 选项式写法,贴近Vuex习惯 * 第一个参数:store唯一id,全局不能重复 */ export const useCounterStore = defineStore('counter', { /** * state:全局共享状态 * 必须是函数返回对象,防止多实例污染 * 可以直接修改state,不需要mutation */ state: () => ({ count: 0 }), /** * getters:仓库计算属性 * 依赖state派生,自带缓存 */ getters: { doubleCount: (state) => state.count * 2 }, /** * actions:业务方法 * 支持同步、异步,可直接修改state */ actions: { add() { this.count++ } } })
2)、Vue3 — Pinia Setup Store 模板:组合式,和<script setup>写法一致,用ref/reactive/computed,灵活度更高
// stores/counter.js import {defineStore} from 'pinia' import {ref, computed} from 'vue' /** * Setup Store 组合式写法,和<script setup>风格统一 */ export const useCounterStore = defineStore('counter', () => { // state:ref定义基础响应式 const count = ref(0) // getters:computed实现派生缓存 const doubleCount = computed(() => count.value * 2) // actions:普通函数 const add = () => { count.value++ } // 必须return暴露出去 return {count, doubleCount, add} })
浙公网安备 33010602011771号