前端基础学习笔记

一、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}
})

 

posted on 2026-11-20 16:21  爱文(Iven)  阅读(17)  评论(0)    收藏  举报

导航