[Vue]Vue3从入门到精通-综合案例分析

一.Vue是什么：

概念：Vue是一个用于构建用户界面的渐进式的框架

以下的内容是自里向外的

声明式渲染(Vuejs核心包)
组件系统(Vuejs核心包)
客户端路由VueRouter
大规模状态管理Vuex
构建工具Webpack/Vite

Vue的两种使用方式：

Vue核心包开发->局部模块改造
Vue核心包&Vue插件工程化开发

二.创建Vue实例与初始化渲染

构建用户界面
创建Vue实例，初始化渲染
- 准备容器
- 引包-开发版本/生产版本
- 创建Vue new Vue();
- 指定配置项，渲染数据
  - el指定挂载点 -#id
  - data提供数据

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>
</head>

<body>
    <div id="app">
        <p>{{ message }}</p>
        <button v-on:click="changeMessage">改变消息</button>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
        const app = new Vue({
            el: '#app',
            data: {
                message: '这是一个简单的 Vue 实例'
            },
            methods: {
                changeMessage: function () {
                    this.message = '消息已改变！';
                }
            }
        });
    </script>
</body>

</html>

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

三.Vue指令

Vue指令的定义：有v-前缀的标签属性

Vue根据不同的【指令】，针对【标签】实现不同的【功能】

<!--Vue指令： v-前缀的标签属性 -->
<div v-html="str"></div>
<!--普通标签属性-->
<div class="box"></div>
<div title="小张"></div>

1.v-html

插值表达式：{{msg}} 其中msg是在data中定义的变量 vue会将其渲染到html标签中而{{msg}}插值表达式就在标签中

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>
</head>

<body>
    <div id="app" v-html="msg">
        
        
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            msg:`<a href="http://www.baidu.com">测试内容</a>`
        }
       })
    </script>
</body>

</html>

v-html=“data中的属性”
data中的属性要用``作为模板语法表示
v-html等价于js中的innerHTML
data中的属性必须是一个完整的html标签

2.v-show与v-if

v-show(条件渲染)

作用：控制元素显示隐藏
语法：v-show=“表达式” 表达式的值true显示 false隐藏
原理：display:none(本质控制的css样式-适合频繁切换显示隐藏的场景)

v-if(判断条件)

作用：控制元素显示隐藏
语法：v-if=“表达式” 表达式值true显示 false隐藏
原理：基于条件判断，是否创建或者移除元素节点（适合不频繁的场景）

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>
    <style>
.box {
    display: flex; /* 使用 flexbox 布局 */
    justify-content: center; /* 在主轴上居中 */
    align-items: center; /* 在交叉轴上居中 */
    height: 200px;
    width: 200px;
    text-align: center;
    border-radius: 5px;
    border: 2px solid black;
    background-color: white;
    padding: 10px;
    margin: 10px;
    box-shadow: none;
}

    </style>
</head>

<body>
    <div id ="app">
        <div v-show="flag" class="box">我是v-show控制的盒子</div>
        
        <div v-if="flag" class="box">我是v-if控制的盒子</div>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            flag:false
        }
       })
    </script>
</body>

</html>

3.v-else v-else-if

作用：辅助v-if进行判断渲染
v-else v-else-if=“表达式”
必须结合v-if使用

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>

</head>

<body>
    <div id ="app">
        <p v-if="gender==1">性别：男</p>
        <p v-if="gender==2">性别：女</p>
        <p v-if="score>=90">成绩评定为A等因为其>90</p>
        <p v-else-if="score>=70">成绩评定为B等，因为其>70</p>
        <p v-else-if="score>=60">成绩评定C等，因为其>60</p>
        <p v-else>成绩评定D等，你的问题很大</p>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            gender:2,
            score:89
        }
       })
    </script>
</body>

</html>

上述为完整例子，p可以是任意标签，接下来抽取抽象概念

<p v-if="">xxx</p>
<p v-else-if="xxx">xxx</p>
<p v-else>xxx</p>

4.v-on基础

作用：注册事件 = 添加监听+提供处理逻辑

语法：

v-on:事件名=”内联语句“
v-on:事件名=“methods中的函数名”
v-on：可以用@替代

<button v-on:click="count++">
    点我自增
</button>

<button @click-"count++">
    点我自增
</button>

实例一：内联语句

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>

</head>

<body>
    <div id ="app">
        <button v-on:click="count--">点我做减法</button>
        <br>
        <button v-on:click="count++">点我做加法</button>
        <br>
        <span>{{count}}</span>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            count:0
        }
       })
    </script>
</body>

</html>

实例二：methods函数

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>

</head>

<body>
    <div id ="app">
        <button @click="fn">切换显示隐藏</button>
        <h1 v-show="isShow">测试内容</h1>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            isShow:true
        },
        methods:{
            fn(){
                this.isShow=!this.isShow
            }
        }
       })
    </script>
</body>

</html>

5.v-on调用传参

场景需求：点击按钮购买道具需要扣除一定的资金
点击按钮发生响应可以通过v-on:事件=”命令“来实现
但是，如何传递扣除资金的参数呢？我们引入v-on调用传参来实现
v-on:click=“函数名(传入的参数)”
你是否会想：那我如果希望点击按钮传递input框的值呢？这个答案会在v-model中揭晓

售货机扣钱案例来学习调用传参

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>
    <style>
        .box{
            border: 2px solid black;
            width: 200px;
            height: 200px;
            text-align: center;
        }
    </style>
</head>

<body>
    <div id ="app">
        <div class="box">
            <h3>自动售货机</h3>
            <button @click="buy(5)">可乐5元</button>
            <button @click="buy(10)">咖啡10元</button>
        </div>
        <p>银行卡余额：{{deposit}}元</p>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            deposit:5000
        },
        methods:{
            buy(price){
                this.deposit=this.deposit-price
                window.alert("购买成功！您的余额是"+deposit);
            }
        }
       })
    </script>
</body>

</html>

6.v-bind

作用：动态的设置html的标签属性
语法： v-bind:属性名=“表达式”
省略语法：v-bind:src=“xxx” => :src=“xxx”

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>

</head>

<body>
    <div id ="app">
        <img v-bind:src="imgUrl">
        <img :src="imgUrl">
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            imgUrl: 'D:/desklop/OIP-C.jpg'
        },
       
       })
    </script>
</body>

</html>

7.数组概念-切换图片案例

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>

</head>

<body>
    <div id ="app">
        <button v-on:click="index++">下一张</button>
        <button v-on:click="index--">上一张</button>
        <br>
        <img v-bind:src="list[index]">
        
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            index:0,
            list:[
            'D:/desklop/OIP-C.jpg',
            'D:/desklop/testpng.png',
            'D:/desklop/OIP-C.jpg',
            'D:/desklop/testpng.png',
            ]
        },
       
       })
    </script>
</body>

</html>

8.v-for

作用：基于数据循环，多次渲染整个元素
语法：v-for=“(item,index) in 数组” ps:item是每一项
大多数时候和
- 与
- 一起使用

<p v-for="...">我是一个内容</p>

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>

</head>

<body>
    <div id ="app">
        <h3>水果店</h3>
        <ul>
            <li v-for="(item,index) in list">
                {{item}} --{{index}}
            </li>
            <li v-for="item in list">
                {{item}}
            </li>
        </ul>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            list:['西瓜','苹果','鸭梨','榴莲']
        },
       
       })
    </script>
</body>

</html>

9.v-for+v-on实战-书架

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>

</head>

<body>
    <div id ="app">
        <h3>书架</h3>
        <ul>
            <li v-for="(item,index) in booklist" :key="item.id">
                <span>{{item.name}}</span>
                <span>{{item.author}}</span>
                <button v-on:click="del(item.id)">删除</button>
            </li>
        </ul>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            booklist:[
                {id:1,name:"《红楼梦》",author:'曹雪芹'},
                {id:2,name:"《西游记》",author:'吴承恩'},
                {id:3,name:"《水浒传》",author:'施耐庵'},
                {id:4,name:"《三国演义》",author:'罗贯中'},
            ]
        },
        methods:{
            del(id){
                this.booklist = this.booklist.filter(item => item.id!==id)
            }
        }
       
       })
    </script>
</body>

</html>

这段代码是用来过滤掉 booklist 数组中 id 与给定 id 相同的元素。它使用了 JavaScript 中的数组 filter 方法，该方法会创建一个新数组，其中包含通过指定函数测试的所有元素。在这里，指定的函数是一个箭头函数，它会检查每个元素的 id 是否与给定的 id 不相同，如果不相同，则保留该元素。所以最终item.id==id的部分都保留下来了

10.v-for:key

 <ul>
            <li v-for="(item,index) in booklist" :key="item.id">
                <span>{{item.name}}</span>
                <span>{{item.author}}</span>
                <button v-on:click="del(item.id)">删除</button>
            </li>
        </ul>

语法：key属性=”唯一标识"
给列表项添加的唯一标识。便于Vue进行列表项的正确排序复用

如果不加key v-for默认行为是原地修改元素（就地复用）

给元素添加唯一标识，便于Vue进行列表的正确排序复用

key只能是字符串或者数字类型
key必须要有唯一性
推荐使用id作为key,不推荐使用index作为key(会变化不对应)

11.v-model

作用：给表单元素使用，双向数据绑定 ->可以快速获取或设置表单元素内容
语法：v-model=‘变量’

数据变化——>视图自动更新
视图变化——>数据自动更新

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>

</head>

<body>
    <div id ="app">
       账户:<input type="text" v-model="username"><br><br>
       密码:<input type="password" v-model="password"><br><br>
       <button @click="login">登陆</button>
       <button @click="reset">重置</button>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
           username:"",
           password:"",
        },
        methods:{
          login(){
            console.log(this.username,this.password)
          },
          reset(){
            this.username="",
            this.password=""
          }
        }
       
       })
    </script>
</body>

</html>

12.记事本项目

功能需求：
- 列表渲染
- 删除功能
- 添加功能
- 底部统计与清空

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<link rel="stylesheet" href="./css/index.css" />
<title>记事本</title>
</head>
<body>

<!-- 主体区域 -->
<section id="app">
  <!-- 输入框 -->
  <header class="header">
    <h1>小黑记事本</h1>
    <input v-model="todoName"  placeholder="请输入任务" class="new-todo" />
    <button @click="add" class="add">添加任务</button>
  </header>
  <!-- 列表区域 -->
  <section class="main">
    <ul class="todo-list">
      <li class="todo" v-for="(item, index) in list" :key="item.id">
        <div class="view">
          <span class="index">{{ index + 1 }}.</span> <label>{{ item.name }}</label>
          <button @click="del(item.id)" class="destroy"></button>
        </div>
      </li>
    </ul>
  </section>
  <!-- 统计和清空 → 如果没有任务了，底部隐藏掉 → v-show -->
  <footer class="footer" v-show="list.length > 0">
    <!-- 统计 -->
    <span class="todo-count">合 计:<strong> {{ list.length }} </strong></span>
    <!-- 清空 -->
    <button @click="clear" class="clear-completed">
      清空任务
    </button>
  </footer>
</section>

<!-- 底部 -->
<script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
<script>
  // 添加功能
  // 1. 通过 v-model 绑定 输入框 → 实时获取表单元素的内容
  // 2. 点击按钮，进行新增，往数组最前面加 unshift
  const app = new Vue({
    el: '#app',
    data: {
      todoName: '',
      list: [
        { id: 1, name: '跑步一公里' },
        { id: 2, name: '跳绳200个' },
        { id: 3, name: '游泳100米' },
      ]
    },
    methods: {
      del (id) {
        // console.log(id) => filter 保留所有不等于该 id 的项
        this.list = this.list.filter(item => item.id !== id)
      },
      add () {
        if (this.todoName.trim() === '') {
          alert('请输入任务名称')
          return
        }
        this.list.unshift({
          id: +new Date(),
          name: this.todoName
        })
        this.todoName = ''
      },
      clear () {
        this.list = []
      }
    }
  })

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

四:指令补充/计算属性/监听器

1.指令的修饰符

指令修饰符：通过"."指明的指令后缀，不同后缀封装了不同的处理操作->简化代码

按键修饰符

@keyup.enter ->键盘回车监听

<header class="header">
    <h1>记事本</h1>
    <input @keyup.enter="add" v-model="todoName"  placeholder="请输入任务" class="new-todo" />
    <button @click="add" class="add">添加任务</button>
  </header>
<!--输入框注册了事件 keyup按键弹起 enter为回车 实现在输入框内回车即可添加-->

我们思考v-on:keyup.enter的内在逻辑：=“”中的函数若空参，可以用e承接事件名，然后以事件来调用方法

<script>
    const app = new Vue({
        el:'#app',
        data:{
            username: ''
        },
        methods:{
            fn(e){
                console.log(e);
                console.log("键盘回车时候触发",this.username)
            }
        }
    })
    </script>

v-model修饰符
- v-model.trim ->去除首尾空格
- v-model.number->转数字

事件修饰符

@事件名.stop ->阻止冒泡
- 存在两个div嵌套，点击内部div命令会执行外部div方法与内部div方法，使用stop可以避免这种现象
@事件名.prevent ->阻止默认行为

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>
    <style>
        .father{
            width: 200px;
            height: 200px;
            background-color: aqua;
        }
        .son{
            width: 50px;
            height: 50px;
            background-color: blanchedalmond;
        }
    </style>
</head>

<body>
    <div id="app">
        <h3>v-model修饰符.trim .number</h3>
        姓名：<input v-model.trim="username" type="text"><br>
        年龄：<input v-model.number="age" type="text"><br>

        <h3>@事件名.stop ->阻止冒泡</h3>
        <div @click.stop ="fatherFn" class="father">
            <div @click.stop="sonFn" class="son">儿子</div>
        </div>

        <h3>@事件名.prevent ->阻止默认行为</h3>
        <a @click.prevent href="https://www.baidu.com">阻止默认行为</a>
        <!--在被.prevent修饰后 无法跳转链接 因为herf是a的一个默认行为-->

    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            username: '',
            age:'',
        },
        methods:{
            fatherFn(){
                alert("父亲被点击了")
            },
            sonFn(){
                alert("儿子被点击了")
            }

        }
       })
    </script>
</body>

</html>

2.v-bind操作class(样式控制增强)

语法:v-bind=“对象/数组”

对象->键就是类名，值是布尔值。如果值是true，有这个类，否则无这个类。第一类特征在于v-bind修饰的就是class本身，而非是class中的某个具体属性。在于决定某个class是否被启用
```
<div class="box" v-bind:class="{类名1:布尔值,类名2:布尔值}"></div>
```
```
<a :class="{active:index===activeIndex}" href="#">{{item.name}}
```
数组->数组中的所有类，都会添加到盒子上，本质是一个class列表.第二类是有特征的：第一个class样式是不绑定vue的，只有这个class里面的某个具体属性会绑定到vue。在于决定已经存在的class中的具体属性修改
```
<div class="box" v-bind:class="{类名1,类名2,类名3}"
```
```
 <div class="inner" v-bind:style="{width:percent + '%'}">
```
```
<div class:"box" :style="{width:'400px',height:'400px',background:'green'}"
```

A.导航栏案例->v-bind应用

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>
    <style>
        *{
            margin: 0;
            padding: 0;
        }
        ul{
            display: flex;
            border-bottom: 2px solid #e01222;
            padding: 0 10px;
        }
        li {
            width: 100px;
            height: 50px;
            line-height: 50px;
            list-style: none;
            text-align: center;
        }
        li a{
            display: block;
            text-decoration: none;
            font-weight: bold;
            color:#333333;
        }
        li a.active{
            background-color: #e01222;
            color: #fff;
        }
    </style>
</head>

<body>
    <div id="app">
       <ul>
        <li v-for="(item,index) in list" v-bind:key="item.id" @click="activeIndex = index">
            <a :class="{active:index===activeIndex}" href="#">{{item.name}}
        </li>
       </ul>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
       const app = new Vue({
        el:'#app',
        data:{
            activeIndex:1,
            list:[
                {Id:1,name:'秒杀窗口'},
                {id:2,name:'每日特价'},
                {id:3,name:'品类秒杀'}
            ]
        }
       })
    </script>
</body>

</html>

B.进度条案例-v-bind绑定样式

<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>简单的 Vue 实例</title>
    <style>
       .progress{
        height: 25px;
        width: 400px;
        border-radius: 15px;
        background-color: #272425;
        border: 3px solid #272425;
        box-sizing: border-box;
        margin-bottom: 30px;
       }
       .inner{
        width: 50%;
        height: 20px;
        border-radius: 10px;
        text-align: right;
        position: relative;
        background-color: #409eff;
        background-size: 20px,20px;
        box-sizing: border-box;
        transition: all 1s; 
       }
       .inner span{
        position: absolute;
        right: -20px;
        bottom: -25px;
       }
    </style>
</head>
<!--
.inner中的 transition:all 1s是丝滑变化的原理


-->
<body>
    <div id="app">
        <div class="progress">
            <div class="inner" v-bind:style="{width:percent + '%'}"><!--这里必须把%引用 因为width后面要接一个数值-->
                <span>{{percent}}</span>
            </div>
        </div>
        <button @click="percent = 25">设置25%</button>
        <button @click="percent=50">设置50%</button>
        <button @click="percent = 75">设置75%</button>
        <button @click="percent =100">设置100%</button>
    </div>
   

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
      const app = new Vue({
        el:'#app',
        data:{
            percent: 30
        }
      })
    </script>
</body>

</html>

3.v-model应用其他表单元素

作用：获取/设置表单元素的值

v-model会根据控件类型自动选择正确的方法来更新元素

input:text ->value
textarea ->value
intput:checkbox ->checked
input:radio ->checked
select ->value

前置理解：

1. name: 给单选框加上 name 属性可以分组 → 同一组互相会互斥

2. value: 给单选框加上 value 属性，用于提交给后台的数据

结合 Vue 使用 → v-model

前置理解：

1. option 需要设置 value 值，提交给后台

2. select 的 value 值，关联了选中的 option 的 value 值

结合 Vue 使用 → v-model

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
  <style>
    textare{
      display: block;
      width: 240px;
      height: 100px;
      margin: 10px 0;
    }
  </style>
</head>
<body>
  <div id="app">
    <h1>学习网站</h1>
    
    姓名：
    <input type="text" v-model="username">
    <br><br>

    是否单身:
    <input type="checkbox" v-model="isSingle">
    <br><br>
<!-- 
      前置理解：
        1. name:  给单选框加上 name 属性 可以分组 → 同一组互相会互斥
        2. value: 给单选框加上 value 属性，用于提交给后台的数据
      结合 Vue 使用 → v-model
    -->
    性别:
    <input v-model="gender" type="radio" name="gender" value="1">男
    <input v-model="gender" type="radio" name="gender" value="2">女
    <br><br>
<!-- 
      前置理解：
        1. option 需要设置 value 值，提交给后台
        2. select 的 value 值，关联了选中的 option 的 value 值
      结合 Vue 使用 → v-model
    -->
    所在城市：
    <select v-model="cityId">
      <option value="101">北京</option>
      <option value="102">上海</option>
      <option value="103">成都</option>
      <option value="104">南京</option>
    </select>
    <br><br>
    <button>立刻注册</button>
  </div>
  <script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
  <script>
    const app = new Vue({
      el: '#app',
      data: {
        username:'',
        isSingle:false,
        gender:"2",
        cityId:'102',
        desc:""
      }
    })
  </script>
</body>
</html>

4.计算属性computed

概念：基于现有的数据，计算出来的新属性。依赖的数据变化，自动重新计算。

语法：

1.声明在computed配置项中，一个计算属性对应一个函数

2.使用起来和普通属性一样 {{计算属性名}}

计算属性->可以将一段求值的代码进行封装

3.如果在computed写了 xxx()这个方法你就可以在html中{{xxx}} 至于xxx到底是怎么来的交给xxx() 这里通常是this来调用data中的值+回调函数进行计算

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
  <style>
    table {
      border: 1px solid #000;
      text-align: center;
      width: 240px;
    }
    th,td{
      border: 1px solid #000;
    }
    h3{
      position: relative;
    }
  </style>
</head>
<body>
  <div id="app">
    <h1>礼物清单</h1>
    <table>
      <tr>
        <th>名字</th>
        <th>数量</th>
      </tr>
      <tr v-for="(item,index) in list" :key="item.id">
        <td>{{item.name}}</td>
        <td>{{item.num}}</td>
      </tr>
    </table>
    <p>礼物总数 {{totalCount}}</p>
  </div>
  <script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
  <script>
    const app = new Vue({
      el: '#app',
      data: {
       list:[
        {id:1,name:'篮球',num:1},
        {id:2,name:'玩具',num:2},
        {id:3,name:'铅笔',num:5},
       ]
      },
      computed:{
        totalCount(){
          // 基于现有的数据，编写求值逻辑
          // 计算属性函数内部，可以直接通过 this 访问到 app 实例
          // console.log(this.list)

          // 需求：对 this.list 数组里面的 num 进行求和 → reduce
          let total=this.list.reduce((sum,item)=>sum+item.num,0)
          return total;
          /*this.list 是一个数组，其中包含了一些对象或元素。
reduce 方法是数组对象的一个高阶函数，用于将数组中的每个元素执行一个指定的回调函数，并将结果汇总成单个值。在这个例子中，reduce 会对 this.list 数组中的每个元素执行回调函数。
回调函数接受两个参数，第一个参数是累积值（通常命名为 accumulator，在这里命名为 sum），第二个参数是当前正在处理的元素（在这里命名为 item）。
回调函数执行的操作是将当前元素的 num 属性值加到累积值上。
初始值为 0，作为累积值的起始值。*/
        }
      }
    })
  </script>
</body>
</html>

5.computed计算属性vs方法methods

computed计算属性：

**作用：**封装了一段对于数据的处理，求得一个结果

语法：

1.写在computed的配置项中

2.作为属性，直接使用->this.计算属性{{计算属性}}

methods方法：

作用：给实例提供一个方法，调用以处理业务逻辑

语法：

1.写在methods配置项中

2.作为方法，需要调用 —> this.方法名() {{方法名()}} @事件名=“方法名”

八股部分：

计算属性会对计算出来的结果缓存，再次使用直接读取缓存

依赖项变化了，会自动重新计算 ->并且再次缓存（缓存特性-提升性能）

6.计算属性的完整写法

计算属性默认的简写，只能访问读取，不能修改

如果要修改，需要写计算属性的完整写法

一种常用逻辑：

1.Input中v-model绑定一个变量

2.展示部分以计算属性表示{{xxx}}

3.定义动态属性:xxx的get和set方法：return xxx (这里的xxx是data中的属性xxx)

以上操作完成就可以实现输入框的内容实时反馈到标签表现中

computed:{
    计算属性名(){
        代码逻辑(计算逻辑)
        return 结果
    }
}

computed:{
    计算属性名：{
        get(){
            一段代码逻辑(计算逻辑)
            return 结果
        },
         set(修改的值)
        一段代码逻辑(修改逻辑)
}

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
  <style>
    input{
      width: 30px;
    }
  </style>
</head>
<body>
  <div id="app">
   姓 <input type="text" v-model="firstName">+
   名 <input type="text" v-model="lastName">=
   <span>{{fullName}}</span><br><br>
   <button @click="changeName">改名卡</button>
  </div>
  <script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
  <script>
    const app = new Vue({
      el:'#app',
      data:{
        firstName:'刘',
        lastName:'备',
      },
      methods:{
        changeName(){
          this.fullName = '黄忠'
        }
      },
      computed:{
        fullName:{
          get(){
            return this.firstName+this.lastName
          },
          set(value){
            this.firstName = value.slice(0,1)
            this.lastName=value.slice(1)
          }
        }
      }
    })
  </script>
</body>
</html>

7.成绩案例

要点分析：

计算属性中的方法

this.list.reduce((sum,item)=>sum+list.score,0)
//是指 用sum来储存累加变量 item表示当前处理的数组元素 类似于增强for中定义的第三方变量 0表示从0开始积累
//这里是在对list数组中每个元素的score进行累加

函数中的方法

this.list=this.list.filter(item=>item.id!==id)
//非常经典的删除行
//filter实质上会生成一个新的数组，这个数组的元素是满足 第三方变量的id不等于id,也就是说 我传入的id不会被添加到新的数组中

this.list.unshift({
                    id:+new Date(),
                    subject : this.subject,
                    score: this.score
                })
this.subject='',
                this.score=''
//list.unshift作用是：修改数组更新视图 说白了就是往[]中添加一个{}
//这里是用作<tr>的v-for中的元素
//id用时间戳来代替 并且在标签中设定为:key
//subject和score都取data中的 最后记得重置为空

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link rel="stylesheet" href="./styles/index.css" />
    <title>Document</title>
  </head>
  <body>
   <div id="app" class="score-case">
    <div class="table">
        <table>
            <thead>
                <tr>
                    <th>编号</th>
                    <th>科目</th>
                    <th>成绩</th>
                    <th>操作</th>
                </tr>
            </thead>
            <tbody v-if="list.length>0">
                <tr v-for="(item,index) in list" v-bind:key="item.id">
                    <td>{{index+1}}</td>
                    <td>{{item.subject}}</td>
                    <td :class="{red:item.score<60}">{{item.score}}</td>
                    <td><a @click.prevent="del(item.id)" href="https://www.baidu.com">删除</td>
                </tr>
            </tbody>
            <tbody v-else>
                <tr>
                    <td colspan="5">
                        <span>总分：{{totalScore}}</span>
                        <span style="margin-left: 50px">平均分:{{averageScore}}</span>
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
    <div class="form">
        <div class="form-item">
            <div class="label">科目:</div>
            <div class="input">
                <input type="text"
                placeholder="请输入科目"
                v-model.trim="subject"/>
            </div>
        </div>
        <div class="form-item">
            <div class="label">分数：</div>
            <div class="input">
                <input type="text" placeholder="请输入分数"
                v-model.number="score">
            </div>
        </div>
        <div class="form-item">
            <div class="label"></div>
            <div class="input">
                <button @click="add" class="submit">添加</button>
            </div>
        </div>
    </div>
   </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>

    <script>
      const app = new Vue({
        el:'#app',
        data:{
            list:[
                {id:1,subject:'语文',score:62},
                {id:7,subject:'数学',score:89},
                {id:12,subject:'英语',score:70},
            ],
            subject:'',
            score:''
        },
        computed:{
            totalScore(){
                return this.list.reduce((sum,item)=>sum+list.score,0)
            },
            averageScore(){
                if(this.list.length==0){
                    return 0
                }
                return (this.totalScore/this.list.length).toFixed(2)
            }
        },
        methods:{
            del(id){
                this.list=this.list.filter(item=>item.id!==id)
            },
            add(){
                if(!this.subject){
                    alert("请输入科目")
                    return
                }
                if(typeof this.score!=='number'){
                    alert("请输入正确的成绩")
                    return
                }
                this.list.unshift({
                    id:+new Date(),
                    subject : this.subject,
                    score: this.score
                })

                this.subject='',
                this.score=''
            
            }
        }
      })
    </script>
  </body>
</html>

8.watch-简写-语法

作用：监视数据变化，执行业务逻辑或者异步操作

语法：

1.简单写法->简单类型数据，直接监视
2.完整写法->添加额外配置项
- deep:true 对复杂类型深度监视
- immediate:true 初始化立刻执行一次handler方法
- handler就是简单写法中的监视发生变化执行的代码

简单写法：

data:{
    words:'苹果',
    obj:{
        words:'苹果'
    }
     
},
    watch{
        //该方法会在数据变化时触发执行
        数据属性名(newValue,oldValue){
            //业务逻辑
        },
        '对象.属性名'(newValue,OldValue){
            //业务逻辑
        }
    }

完整写法：

const app = new Vue({
    el:'#app',
    data:{
        obj:{
            words:'苹果',
            lang:'italy'
        },
    },
    watch:{
        数据属性名:{
            deep:true//深度监视
            handler(newValue){
        console.log(newValue)
    }
        }
    }
})

9.watch-简写-业务实现

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
    <style>
      * {
        margin: 0;
        padding: 0;
        box-sizing: border-box;
        font-size: 18px;
      }
      #app {
        padding: 10px 20px;
      }
      .query {
        margin: 10px 0;
      }
      .box {
        display: flex;
      }
      textarea {
        width: 300px;
        height: 160px;
        font-size: 18px;
        border: 1px solid #dedede;
        outline: none;
        resize: none;
        padding: 10px;
      }
      textarea:hover {
        border: 1px solid #1589f5;
      }
      .transbox {
        width: 300px;
        height: 160px;
        background-color: #f0f0f0;
        padding: 10px;
        border: none;
      }
      .tip-box {
        width: 300px;
        height: 25px;
        line-height: 25px;
        display: flex;
      }
      .tip-box span {
        flex: 1;
        text-align: center;
      }
      .query span {
        font-size: 18px;
      }

      .input-wrap {
        position: relative;
      }
      .input-wrap span {
        position: absolute;
        right: 15px;
        bottom: 15px;
        font-size: 12px;
      }
      .input-wrap i {
        font-size: 20px;
        font-style: normal;
      }
    </style>
  </head>
  <body>
    <div id="app">
      <!-- 条件选择框 -->
      <div class="query">
        <span>翻译成的语言：</span>
        <select>
          <option value="italy">意大利</option>
          <option value="english">英语</option>
          <option value="german">德语</option>
        </select>
      </div>

      <!-- 翻译框 -->
      <div class="box">
        <div class="input-wrap">
          <textarea v-model="obj.words"></textarea>
          <span><i>⌨️</i>文档翻译</span>
        </div>
        <div class="output-wrap">
          <div class="transbox">{{ result }}</div>
        </div>
      </div>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
    <script>
      // 接口地址：https://applet-base-api-t.itheima.net/api/translate
      // 请求方式：get
      // 请求参数：
      // （1）words：需要被翻译的文本（必传）
      // （2）lang： 需要被翻译成的语言（可选）默认值-意大利
      // -----------------------------------------------
      
      const app = new Vue({
        el: '#app',
        data: {
          // words: ''
          obj: {
            words: ''
          },
          result: '', // 翻译结果
          // timer: null // 延时器id
        },
        // 具体讲解：(1) watch语法 (2) 具体业务实现
        watch: {
          // 该方法会在数据变化时调用执行
          // newValue新值, oldValue老值（一般不用）
          // words (newValue) {
          //   console.log('变化了', newValue)
          // }

          'obj.words' (newValue) {
            // console.log('变化了', newValue)
            // 防抖: 延迟执行 → 干啥事先等一等，延迟一会，一段时间内没有再次触发，才执行
            clearTimeout(this.timer)
            this.timer = setTimeout(async () => {
              const res = await axios({
                url: 'https://applet-base-api-t.itheima.net/api/translate',
                params: {
                  words: newValue
                }
              })
              this.result = res.data.data
              console.log(res.data.data)
            }, 300)
          }
        }
      })
    </script>
  </body>
</html>

10.watch-完整写法

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
    <style>
      * {
        margin: 0;
        padding: 0;
        box-sizing: border-box;
        font-size: 18px;
      }
      #app {
        padding: 10px 20px;
      }
      .query {
        margin: 10px 0;
      }
      .box {
        display: flex;
      }
      textarea {
        width: 300px;
        height: 160px;
        font-size: 18px;
        border: 1px solid #dedede;
        outline: none;
        resize: none;
        padding: 10px;
      }
      textarea:hover {
        border: 1px solid #1589f5;
      }
      .transbox {
        width: 300px;
        height: 160px;
        background-color: #f0f0f0;
        padding: 10px;
        border: none;
      }
      .tip-box {
        width: 300px;
        height: 25px;
        line-height: 25px;
        display: flex;
      }
      .tip-box span {
        flex: 1;
        text-align: center;
      }
      .query span {
        font-size: 18px;
      }

      .input-wrap {
        position: relative;
      }
      .input-wrap span {
        position: absolute;
        right: 15px;
        bottom: 15px;
        font-size: 12px;
      }
      .input-wrap i {
        font-size: 20px;
        font-style: normal;
      }
    </style>
  </head>
  <body>
    <div id="app">
      <!-- 条件选择框 -->
      <div class="query">
        <span>翻译成的语言：</span>
        <select v-model="obj.lang">
          <option value="italy">意大利</option>
          <option value="english">英语</option>
          <option value="german">德语</option>
        </select>
      </div>

      <!-- 翻译框 -->
      <div class="box">
        <div class="input-wrap">
          <textarea v-model="obj.words"></textarea>
          <span><i>⌨️</i>文档翻译</span>
        </div>
        <div class="output-wrap">
          <div class="transbox">{{ result }}</div>
        </div>
      </div>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
    <script>
      // 需求：输入内容，修改语言，都实时翻译

      // 接口地址：https://applet-base-api-t.itheima.net/api/translate
      // 请求方式：get
      // 请求参数：
      // （1）words：需要被翻译的文本（必传）
      // （2）lang： 需要被翻译成的语言（可选）默认值-意大利
      // -----------------------------------------------
   
      const app = new Vue({
        el: '#app',
        data: {
          obj: {
            words: '小黑',
            lang: 'italy'
          },
          result: '', // 翻译结果
        },
        watch: {
          obj: {
            deep: true, // 深度监视
            immediate: true, // 立刻执行，一进入页面handler就立刻执行一次
            handler (newValue) {
              clearTimeout(this.timer)
              this.timer = setTimeout(async () => {
                const res = await axios({
                  url: 'https://applet-base-api-t.itheima.net/api/translate',
                  params: newValue
                })
                this.result = res.data.data
                console.log(res.data.data)
              }, 300)
            }
          }


          // 'obj.words' (newValue) {
          //   clearTimeout(this.timer)
          //   this.timer = setTimeout(async () => {
          //     const res = await axios({
          //       url: 'https://applet-base-api-t.itheima.net/api/translate',
          //       params: {
          //         words: newValue
          //       }
          //     })
          //     this.result = res.data.data
          //     console.log(res.data.data)
          //   }, 300)
          // }
        }
      })
    </script>
  </body>
</html>

11.项目实战

方法集锦：

this.fruitList.every(item=>item.isChecked)
//every方法：检查fruitList数组中每个元素是否都有isChecked为true,只有全部满足则返回false
//返回 true/false

this.fruitList.array.forEach(item=>item.isChecked=value)
//将item.isChecked设置为你想设置的值 value是外部传入的参数
//返回true/false;

this.fruitList.reduce((sum,item)=>{
                        if(item.isChecked){
                            return sum+item.num*item.price;{
                                return sum;
                            }
                        }
/*
reduce是JavaScript提供的高阶函数,对数组中的每一个元素,执行一个提供的回调函数
通常用于数组累加+汇总+转换

reduce函数有两个parameters 回调函数+初始值（初始值是放在外面的,并且是累加器）
回调函数有四个参数: 累加器(sum),当前元素(item),当前索引,原数组
返回值
*/
    
const fruit = this.fruitList.find(item=>item.id===id)
//find是返回一个值

监视器实现本地储存

watch:{
                fruitlist:{
                    deep:true,
                    handler(newValue){
                        localStorage.setItem('list',JSON.stringify(newValue))
                    }
                }
            }

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link rel="stylesheet" href="./css/inputnumber.css" />
    <link rel="stylesheet" href="./css/index.css" />
    <title>购物车</title>
  </head>
  <body>
    <div class="app-container" id="app">
      <!-- 顶部banner -->
      <div class="banner-box"><img src="D:/desklop/湖科大计算机科学与技术系/Vue/Vue2+3入门到实战-配套资料/01-随堂代码&素材/day02/day02/code/15-综合案例-购物车/img/fruit.jpg" alt="" /></div>
      <!-- 面包屑 -->
      <div class="breadcrumb">
        <span>🏠</span>
        /
        <span>购物车</span>
      </div>
      <!-- 购物车主体 -->
      <div class="main" v-if="fruitList.length > 0">
        <div class="table">
          <!-- 头部 -->
          <div class="thead">
            <div class="tr">
              <div class="th">选中</div>
              <div class="th th-pic">图片</div>
              <div class="th">单价</div>
              <div class="th num-th">个数</div>
              <div class="th">小计</div>
              <div class="th">操作</div>
            </div>
          </div>
          <!-- 身体 -->
          <div class="tbody">
            <div v-for="(item, index) in fruitList" :key="item.id" class="tr" :class="{ active: item.isChecked }">
              <div class="td"><input type="checkbox" v-model="item.isChecked" /></div>
              <div class="td"><img :src="item.icon" alt="" /></div>
              <div class="td">{{ item.price }}</div>
              <div class="td">
                <div class="my-input-number">
                  <button :disabled="item.num <= 1" class="decrease" @click="sub(item.id)"> - </button>
                  <span class="my-input__inner">{{ item.num }}</span>
                  <button class="increase" @click="add(item.id)"> + </button>
                </div>
              </div>
              <div class="td">{{ item.num * item.price }}</div>
              <div class="td"><button @click="del(item.id)">删除</button></div>
            </div>
          </div>
        </div>
        <!-- 底部 -->
        <div class="bottom">
          <!-- 全选 -->
          <label class="check-all">
            <input type="checkbox" v-model="isAll"/>
            全选
          </label>
          <div class="right-box">
            <!-- 所有商品总价 -->
            <span class="price-box">总价&nbsp;&nbsp;:&nbsp;&nbsp;¥&nbsp;<span class="price">{{ totalPrice }}</span></span>
            <!-- 结算按钮 -->
            <button class="pay">结算( {{ totalCount }} )</button>
          </div>
        </div>
      </div>
      <!-- 空车 -->
      <div class="empty" v-else>🛒空空如也</div>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
    <script>
      const defaultArr = [
            {
              id: 1,
              icon: 'D:/desklop/湖科大计算机科学与技术系/Vue/Vue2+3入门到实战-配套资料/01-随堂代码&素材/day02/day02/code/15-综合案例-购物车/img/火龙果.png',
              isChecked: true,
              num: 2,
              price: 6,
            },
            {
              id: 2,
              icon: 'D:/desklop/湖科大计算机科学与技术系/Vue/Vue2+3入门到实战-配套资料/01-随堂代码&素材/day02/day02/code/15-综合案例-购物车/img/荔枝.png',
              isChecked: false,
              num: 7,
              price: 20,
            },
            {
              id: 3,
              icon: 'D:/desklop/湖科大计算机科学与技术系/Vue/Vue2+3入门到实战-配套资料/01-随堂代码&素材/day02/day02/code/15-综合案例-购物车/img/榴莲.png',
              isChecked: false,
              num: 3,
              price: 40,
            },
            {
              id: 4,
              icon: 'D:/desklop/湖科大计算机科学与技术系/Vue/Vue2+3入门到实战-配套资料/01-随堂代码&素材/day02/day02/code/15-综合案例-购物车/img/鸭梨.png',
              isChecked: true,
              num: 10,
              price: 3,
            },
            {
              id: 5,
              icon: 'D:/desklop/湖科大计算机科学与技术系/Vue/Vue2+3入门到实战-配套资料/01-随堂代码&素材/day02/day02/code/15-综合案例-购物车/img/樱桃.png',
              isChecked: false,
              num: 20,
              price: 34,
            },
          ]
      const app = new Vue({
        el: '#app',
        data: {
          // 水果列表
          fruitList: JSON.parse(localStorage.getItem('list')) || defaultArr,
        },
        computed: {
          // 默认计算属性：只能获取不能设置，要设置需要写完整写法
          // isAll () {
          //   // 必须所有的小选框都选中，全选按钮才选中 → every
          //   return this.fruitList.every(item => item.isChecked)
          // }
          
          // 完整写法 = get + set
          isAll: {
            get () {
              return this.fruitList.every(item => item.isChecked)
            },
            set (value) {
              // 基于拿到的布尔值，要让所有的小选框 同步状态
              this.fruitList.forEach(item => item.isChecked = value)
            }
          },
          // 统计选中的总数 reduce
          totalCount () {
            return this.fruitList.reduce((sum, item) => {
              if (item.isChecked) {
                // 选中 → 需要累加
                return sum + item.num
              } else {
                // 没选中 → 不需要累加
                return sum
              }
            }, 0)
          },
          // 总计选中的总价 num * price
          totalPrice () {
            return this.fruitList.reduce((sum, item) => {
              if (item.isChecked) {
                return sum + item.num * item.price
              } else {
                return sum
              }
            }, 0)
          }
        },
        methods: {
          del (id) {
            this.fruitList = this.fruitList.filter(item => item.id !== id)
          },
          add (id) {
            // 1. 根据 id 找到数组中的对应项 → find
            const fruit = this.fruitList.find(item => item.id === id)
            // 2. 操作 num 数量
            fruit.num++
          },
          sub (id) {
            // 1. 根据 id 找到数组中的对应项 → find
            const fruit = this.fruitList.find(item => item.id === id)
            // 2. 操作 num 数量
            fruit.num--
          }
        },
        watch: {
          fruitList: {
            deep: true,
            handler (newValue) {
              // 需要将变化后的 newValue 存入本地 （转JSON）
              localStorage.setItem('list', JSON.stringify(newValue))
            }
          }
        }
      })
    </script>
  </body>
</html>

五:生命周期/综合案例/工程化开发入门/工程化案例

1.生命周期&生命周期四个阶段

思考：什么时候可以发送初始化渲染请求（越早越好）什么时候可以开始操作dom(至少dom得渲染出来)

Vue生命周期：一个Vue实例从创建到销毁的整个过程

四个阶段：

创建阶段（new Vue()）

data:{
    title:;计数器,
    count:100
}//响应式数据
//发送初始化渲染请求

挂载阶段

<div id="#app">
    <h3>
        {{title}}
    </h3>
    <div>
        <button>-</button>
        <span>{{count}}</span>
        <button>+</button>
    </div>
</div>
<!--渲染模板同时操作Dom-->

更新阶段
- 点击网页的加减号，修改数据的同时就会更新视图
销毁阶段
- 销毁实例

2.生命周期钩子

定义：Vue生命周期过程中，会自动运行一些函数，被称为生命周期钩子->开发者在特定阶段运行自己的代码

地位：在Vue实例内部是最高的一批，和el与data是平级的

1.创建阶段：
beforeCreate
created//主要作用
2.挂载阶段（渲染模板）
beforeMount
mounted//主要作用
3.更新阶段:修改数据，更新视图
beforeUpdate
updated//主要作用
4.销毁阶段:销毁实例:释放Vue外的资源，清除定时器，延时器
beforeDestory
destoryed//主要作用

具体的函数例子：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
</head>
<body>
    <div id="app">
        <h3>{{title}}</h3>
        <div>
            <button @click="count--">-</button>
            <span>{{count}}</span>
            <button @click="count++">+</button>
        </div>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
    <script>
        const app=new Vue({
            el:'#app',
            data:{
                count:100,
                title:'计数器'
            },
            beforeCreate(){
                console.log("beforeCreate响应式数据准备好以前",this.count)
            },
            created(){
                console.log("created响应式数据准备好之后",this.count)

            },
            beforeMount(){
                console.log("beforeMount模板渲染之前",document.querySelectorAll('h3').innerHTML)

            },
            mounted(){
                console.log("mounted模板渲染之后")
            },
            beforeUpdate(){
                console.log("beforeUpdate")
            },
            updated(){
                console.log("updated")
            },
            beforeDestory(){
                console.log('beforeDestory定时器')
            },
            destoryed(){
                console.log('destoryed')
            }
        })
    </script>
</body>

3.生命周期案例

A.created新闻案例

created()->获取data
本案例的data是额外储存的，因此需要通过created获取，然后将data储存到本地vue的data属性中

async created () {
        // 1. 发送请求获取数据
        const res = await axios.get('http://hmajax.itheima.net/api/news')
        // 2. 更新到 list 中，用于页面渲染 v-for
        this.list = res.data.data
      }
    })

async标识意味着created是一个异步方法
使用了axios库来获取网址中的data包
并且通过.data方法进行解包,下面为网址中的包

{
    "message": "获取新闻列表成功",
    "data": [
        {
            "id": 1,
            "title": "5G渗透率持续提升，创新业务快速成长",
            "source": "新京报经济新闻",
            "cmtcount": 58,
            "img": "http://ajax-api.itheima.net/images/0.webp",
            "time": "2222-10-28 11:50:28"
        },
        {
            "id": 5,
            "title": "为什么说中美阶段性协议再近一步，读懂周末的这些关键信息",
            "source": "澎湃新闻",
            "cmtcount": 131,
            "img": "http://ajax-api.itheima.net/images/4.webp",
            "time": "2222-10-24 09:08:34"
        },
        {
            "id": 6,
            "title": "阿根廷大选结果揭晓：反对派费尔南德斯有话要说",
            "source": "海外网",
            "cmtcount": 99,
            "img": "http://ajax-api.itheima.net/images/5.webp",
            "time": "2222-10-23 17:41:15"
        },
        {
            "id": 8,
            "title": "LV母公司当年史上最大并购：报价145亿美元购Tiffany",
            "source": "澎湃新闻",
            "cmtcount": 119,
            "img": "http://ajax-api.itheima.net/images/7.webp",
            "time": "2222-10-22 03:59:44"
        },
        {
            "id": 9,
            "title": "黄峥当年1350亿蝉联80后白手起家首富：1年中财富每天涨1个亿",
            "source": "胡润百富",
            "cmtcount": 676,
            "img": "http://ajax-api.itheima.net/images/8.webp",
            "time": "2222-10-21 06:19:37"
        }
    ]
}

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
  <style>
    * {
      margin: 0;
      padding: 0;
      list-style: none;
    }
    .news {
      display: flex;
      height: 120px;
      width: 600px;
      margin: 0 auto;
      padding: 20px 0;
      cursor: pointer;
    }
    .news .left {
      flex: 1;
      display: flex;
      flex-direction: column;
      justify-content: space-between;
      padding-right: 10px;
    }
    .news .left .title {
      font-size: 20px;
    }
    .news .left .info {
      color: #999999;
    }
    .news .left .info span {
      margin-right: 20px;
    }
    .news .right {
      width: 160px;
      height: 120px;
    }
    .news .right img {
      width: 100%;
      height: 100%;
      object-fit: cover;
    }
  </style>
</head>
<body>

  <div id="app">
    <ul>
      <li v-for="(item, index) in list" :key="item.id" class="news">
        <div class="left">
          <div class="title">{{ item.title }}</div>
          <div class="info">
            <span>{{ item.source }}</span>
            <span>{{ item.time }}</span>
          </div>
        </div>
        <div class="right">
          <img :src="item.img" alt="">
        </div>
      </li>
    </ul>
  </div>
  <script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
  <script>
    // 接口地址：http://hmajax.itheima.net/api/news
    // 请求方式：get
    const app = new Vue({
      el: '#app',
      data: {
        list: []
      },
      async created () {
        // 1. 发送请求获取数据
        const res = await axios.get('http://hmajax.itheima.net/api/news')
        // 2. 更新到 list 中，用于页面渲染 v-for
        this.list = res.data.data
      }
    })
  </script>
</body>
</html>

B.焦点的获取

焦点获取，是对标签的操作，因此是渲染过程，因此通过mounted进行

    // 核心思路：
    // 1. 等input框渲染出来 mounted 钩子
    // 2. 让input框获取焦点 inp.focus()
    mounted () {
      document.querySelector('#inp').focus()
    }

<!DOCTYPE html>
<html lang="zh-CN">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>示例-获取焦点</title>
  <!-- 初始化样式 -->
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/reset.css@2.0.2/reset.min.css">
  <!-- 核心样式 -->
  <style>
    html,
    body {
      height: 100%;
    }
    .search-container {
      position: absolute;
      top: 30%;
      left: 50%;
      transform: translate(-50%, -50%);
      text-align: center;
    }
    .search-container .search-box {
      display: flex;
    }
    .search-container img {
      margin-bottom: 30px;
    }
    .search-container .search-box input {
      width: 512px;
      height: 16px;
      padding: 12px 16px;
      font-size: 16px;
      margin: 0;
      vertical-align: top;
      outline: 0;
      box-shadow: none;
      border-radius: 10px 0 0 10px;
      border: 2px solid #c4c7ce;
      background: #fff;
      color: #222;
      overflow: hidden;
      box-sizing: content-box;
      -webkit-tap-highlight-color: transparent;
    }
    .search-container .search-box button {
      cursor: pointer;
      width: 112px;
      height: 44px;
      line-height: 41px;
      line-height: 42px;
      background-color: #ad2a27;
      border-radius: 0 10px 10px 0;
      font-size: 17px;
      box-shadow: none;
      font-weight: 400;
      border: 0;
      outline: 0;
      letter-spacing: normal;
      color: white;
    }
    body {
      background: no-repeat center /cover;
      background-color: #edf0f5;
    }
  </style>
</head>

<body>
<div class="container" id="app">
  <div class="search-container">
    <img src="https://www.itheima.com/images/logo.png" alt="">
    <div class="search-box">
      <input type="text" v-model="words" id="inp">
      <button>搜索一下</button>
    </div>
  </div>
</div>

<script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
<script>
  const app = new Vue({
    el: '#app',
    data: {
      words: ''
    },
    // 核心思路：
    // 1. 等input框渲染出来 mounted 钩子
    // 2. 让input框获取焦点 inp.focus()
    mounted () {
      document.querySelector('#inp').focus()
    }
  })
</script>

</body>

</html>

4.综合案例：记账本

A.列表渲染：

** (1) 立刻发送请求获取数据 created*

** (2) 拿到数据，存到data的响应式数据中*

** (3) 结合数据，进行渲染 v-for*

** (4) 消费统计 => 计算属性*

toFixed() 是 JavaScript 中用于将数字转换为指定小数位数的字符串的方法。

具体来说，toFixed(2) 方法会将数字四舍五入到指定的小数位数，并返回一个字符串表示结果。

         computed:{
            totalPrice(){
                return this.list.reduce((sum,item)=>sum+item.price,0)
            },
mounted(){

B.添加

** (1) 收集表单数据 v-model*

** (2) 给添加按钮注册点击事件，发送添加请求*

** (3) 需要重新渲染*

 async add () {
            if (!this.name) {
              alert('请输入消费名称')
              return
            }
            if (typeof this.price !== 'number') {
              alert('请输入正确的消费价格')
              return
            }

            // 发送添加请求
            const res = await axios.post('https://applet-base-api-t.itheima.net/bill', {
              creator: '小黑',
              name: this.name,
              price: this.price
            })
            // 重新渲染一次
            this.getList()

            this.name = ''
            this.price = ''
          },

C.删除

** (1) 注册点击事件，传参传 id*

** (2) 根据 id 发送删除请求*

** (3) 需要重新渲染*

async del (id) {
            // 根据 id 发送删除请求
            const res = await axios.delete(`https://applet-base-api-t.itheima.net/bill/${id}`)
            // 重新渲染
            this.getList()
          }

D.饼图渲染

** (1) 初始化一个饼图 echarts.init(dom) mounted钩子实现*

** (2) 根据数据实时更新饼图 echarts.setOption({ … })*

  this.myChart = echarts.init(document.querySelector('#main'))
          this.myChart.setOption({
            // 大标题
            title: {
              text: '消费账单列表',
              left: 'center'
            },
            // 提示框
            tooltip: {
              trigger: 'item'
            },
            // 图例
            legend: {
              orient: 'vertical',
              left: 'left'
            },
            // 数据项
            series: [
              {
                name: '消费账单',
                type: 'pie',
                radius: '50%', // 半径
                data: [
                  // { value: 1048, name: '球鞋' },
                  // { value: 735, name: '防晒霜' }
                ],
                emphasis: {
                  itemStyle: {
                    shadowBlur: 10,
                    shadowOffsetX: 0,
                    shadowColor: 'rgba(0, 0, 0, 0.5)'
                  }
                }
              }
            ]
          })
      },

E.整体工程

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
    <!-- CSS only -->
    <link
      rel="stylesheet"
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
    />
    <style>
      .red {
        color: red!important;
      }
      .search {
        width: 300px;
        margin: 20px 0;
      }
      .my-form {
        display: flex;
        margin: 20px 0;
      }
      .my-form input {
        flex: 1;
        margin-right: 20px;
      }
      .table > :not(:first-child) {
        border-top: none;
      }
      .contain {
        display: flex;
        padding: 10px;
      }
      .list-box {
        flex: 1;
        padding: 0 30px;
      }
      .list-box  a {
        text-decoration: none;
      }
      .echarts-box {
        width: 600px;
        height: 400px;
        padding: 30px;
        margin: 0 auto;
        border: 1px solid #ccc;
      }
      tfoot {
        font-weight: bold;
      }
      @media screen and (max-width: 1000px) {
        .contain {
          flex-wrap: wrap;
        }
        .list-box {
          width: 100%;
        }
        .echarts-box {
          margin-top: 30px;
        }
      }
    </style>
  </head>
  <body>
    <div id="app">
      <div class="contain">
        <!-- 左侧列表 -->
        <div class="list-box">

          <!-- 添加资产 -->
          <form class="my-form">
            <input v-model.trim="name" type="text" class="form-control" placeholder="消费名称" />
            <input v-model.number="price" type="text" class="form-control" placeholder="消费价格" />
            <button @click="add" type="button" class="btn btn-primary">添加账单</button>
          </form>

          <table class="table table-hover">
            <thead>
              <tr>
                <th>编号</th>
                <th>消费名称</th>
                <th>消费价格</th>
                <th>操作</th>
              </tr>
            </thead>
            <tbody>
              <tr v-for="(item, index) in list" :key="item.id">
                <td>{{ index + 1 }}</td>
                <td>{{ item.name }}</td>
                <td :class="{ red: item.price > 500 }">{{ item.price.toFixed(2) }}</td>
                <td><a @click="del(item.id)" href="javascript:;">删除</a></td>
              </tr>
            </tbody>
            <tfoot>
              <tr>
                <td colspan="4">消费总计： {{ totalPrice.toFixed(2) }}</td>
              </tr>
            </tfoot>
          </table>
        </div>
        
        <!-- 右侧图表 -->
        <div class="echarts-box" id="main"></div>
      </div>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/echarts@5.4.0/dist/echarts.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
    <script>
      /**
       * 接口文档地址：
       * https://www.apifox.cn/apidoc/shared-24459455-ebb1-4fdc-8df8-0aff8dc317a8/api-53371058
       * 
       * 功能需求：
       * 1. 基本渲染
       *    (1) 立刻发送请求获取数据 created
       *    (2) 拿到数据，存到data的响应式数据中
       *    (3) 结合数据，进行渲染 v-for
       *    (4) 消费统计 => 计算属性
       * 2. 添加功能
       *    (1) 收集表单数据 v-model
       *    (2) 给添加按钮注册点击事件，发送添加请求
       *    (3) 需要重新渲染
       * 3. 删除功能
       *    (1) 注册点击事件，传参传 id
       *    (2) 根据 id 发送删除请求
       *    (3) 需要重新渲染
       * 4. 饼图渲染
       *    (1) 初始化一个饼图 echarts.init(dom)  mounted钩子实现
       *    (2) 根据数据实时更新饼图 echarts.setOption({ ... })
       */
      const app = new Vue({
        el: '#app',
        data: {
          list: [],
          name: '',
          price: ''
        },
        computed: {
          totalPrice () {
            return this.list.reduce((sum, item) => sum + item.price, 0)
          }
        },
        created () {
          // const res = await axios.get('https://applet-base-api-t.itheima.net/bill', {
          //   params: {
          //     creator: '小黑'
          //   }
          // })
          // this.list = res.data.data

          this.getList()
        },
        mounted () {
          this.myChart = echarts.init(document.querySelector('#main'))
          this.myChart.setOption({
            // 大标题
            title: {
              text: '消费账单列表',
              left: 'center'
            },
            // 提示框
            tooltip: {
              trigger: 'item'
            },
            // 图例
            legend: {
              orient: 'vertical',
              left: 'left'
            },
            // 数据项
            series: [
              {
                name: '消费账单',
                type: 'pie',
                radius: '50%', // 半径
                data: [
                  // { value: 1048, name: '球鞋' },
                  // { value: 735, name: '防晒霜' }
                ],
                emphasis: {
                  itemStyle: {
                    shadowBlur: 10,
                    shadowOffsetX: 0,
                    shadowColor: 'rgba(0, 0, 0, 0.5)'
                  }
                }
              }
            ]
          })
        },

        methods: {
          async getList () {
            const res = await axios.get('https://applet-base-api-t.itheima.net/bill', {
              params: {
                creator: '小黑'
              }
            })
            this.list = res.data.data

            // 更新图表
            this.myChart.setOption({
              // 数据项
              series: [
                {
                  // data: [
                  //   { value: 1048, name: '球鞋' },
                  //   { value: 735, name: '防晒霜' }
                  // ]
                  data: this.list.map(item => ({ value: item.price, name: item.name}))
                }
              ]
            })
          },
          async add () {
            if (!this.name) {
              alert('请输入消费名称')
              return
            }
            if (typeof this.price !== 'number') {
              alert('请输入正确的消费价格')
              return
            }

            // 发送添加请求
            const res = await axios.post('https://applet-base-api-t.itheima.net/bill', {
              creator: '小黑',
              name: this.name,
              price: this.price
            })
            // 重新渲染一次
            this.getList()

            this.name = ''
            this.price = ''
          },
          async del (id) {
            // 根据 id 发送删除请求
            const res = await axios.delete(`https://applet-base-api-t.itheima.net/bill/${id}`)
            // 重新渲染
            this.getList()
          }
        }
      })
    </script>
  </body>
</html>

5.工程化开发入门

A.工程化开发和脚手架

1.核心包传统开发模式:基于html/css/js文件，直接引入核心包，开发Vue

2.工程化开发模式：基于构建工具(webpack)的环境中开发Vue

es6语法/typescript/less/sass ->(webpack自动化编译压缩组合) js(es3/es5) css

问题：

webpack配置复杂
雷同的基础配置
缺乏统一标准

我们需要工具，生成标准化的配置

基本介绍：

Vue CLI是Vue官方提供的命令行工具，可以帮助我们快速创建一个开发Vue项目的标准化基础架子

好处：

开箱即用
内置babel等工具
标准化

使用步骤：

全局安装：yarn global add @vue/cli 或者 npm @vue/cli -g
查看vue版本： vue --version
创建项目架子： vue create project-name(项目名不能用中文)
启动项目：yarn serve 或者npm run serve (找package.json)

B.目录介绍与项目运行流程

Vue-demo
|-node_modules 第三方包文件夹
|-public 放html的地方
| |-favicon.ico 网站图标
| |-index.html index.html模板文件
|-src 源代码目录->以后写代码的文件夹
| |-assets:静态资源目录-存放图片与字体等
| |-components 组件目录->存放通用组件
| |-App.vue App根组件->项目运行看到的内容就在这里编写
| |-main.js 入口文件->打包或者运行第一个执行的文件
|-.gitignore git忽视文件
|-babel.config.js babel配置文件
|-package.json 项目配置文件->项目名，版本号，script,依赖包
|-README.md 项目说明文档
|-vue.config.js vue-cli配置文件
|-yarn.lock yarn锁文件，由yarn自动生成的，用来锁定安装版本

//Babel是JavaScript编译器，作用是ECMAScript2015+(ES6+)转化为向后版本的JavaScript版本，方便在旧版本的浏览器或者环境执行
//yarn.lock是yarn包管理器自动生成的锁定文件，用于确保项目的依赖项在不同环境中有一致的版本。

项目运行过程：

yarn serve->main.js(App.vue注入到main.js 过程如下)->index.html

import Vue from 'vue'
import App from './App.vue'
new Vue({
    render:h=>h(App)
}).$mount('#app')
//描述的是App注入到main.js的过程
/*
new Vue({}): 这部分是创建一个新的 Vue 实例。Vue 实例是 Vue.js 应用程序的核心。通过 new Vue({})，我们实例化了一个 Vue 对象，用于管理应用的数据、状态和行为。

render: h => h(App): 这里是 Vue 实例的配置选项之一，它定义了 Vue 实例如何渲染内容。在这个例子中，render 函数接受一个参数 h，它是一个用来创建虚拟 DOM 元素的函数。h(App) 表示使用 h 函数创建一个 App 组件的虚拟 DOM 元素。

.$mount('#app'): 这是将 Vue 实例挂载到 HTML 页面上的一种方式。$mount 方法用于手动挂载 Vue 实例到一个特定的 DOM 元素上。'#app' 是一个 CSS 选择器，它指定了要挂载到的 HTML 元素的 id，这里表示挂载到 id 为 app 的元素上。

*/

C.组件化

1.组件化：一个页面可以拆分成若干组件，每个组件都有独立的结构，样式，行为

好处：便于维护，利于复用，提升开发效率
组件分类：普通组件、根组件

**2.根组件：**整个应用最上层的组件，包裹所有普通小组件

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

App.vue文件（单文本组件）的三个组成成分：

template:结构（有且只有一个根元素：所有的html元素包含在一个元素内部）
script:js逻辑
style：样式（可支持less，需要装包）

让组件支持Less:

style标签，lang="less"开启less功能
装包:yarn add less less-loader

less代是一种css预处理器，扩展了css语言，我们给出一个例子。

Less 是一种功能强大的 CSS 预处理器，它提供了许多有用的功能来简化和优化 CSS 的编写。以下是一些 Less 中常用的代码示例：

变量（Variables）：使用变量来存储颜色、尺寸、字体等重复使用的值，以便统一管理和调整。

lessCopy Code@primary-color: #3498db;
@font-stack: Arial, sans-serif;
@base-padding: 10px;

嵌套规则（Nested Rules）：可以在选择器内部嵌套其他选择器，提高样式的可读性和维护性。

lessCopy Code.nav {
  ul {
    list-style: none;
  }
  li {
    display: inline-block;
    margin-right: 10px;
    a {
      text-decoration: none;
    }
  }
}

混合器（Mixins）：类似于函数，可以将一组 CSS 属性集合定义为一个混合器，然后在需要的地方调用。

lessCopy Code.rounded-corners(@radius: 5px) {
  border-radius: @radius;
}

运算（Operations）：可以在 Less 中执行数学运算，如加法、减法、乘法和除法。

lessCopy Code@base-padding: 10px;
@extra-padding: 5px;
.padding {
  padding: @base-padding + @extra-padding;
}

导入其他 Less 文件（Import）：可以将一个 Less 文件导入到另一个 Less 文件中，以便将样式模块化管理。

lessCopy Code@import "variables.less";
@import "mixins.less";

条件语句（Conditionals）：可以使用条件语句根据条件设置样式。

lessCopy Code@background-color: #fff;
body {
  background-color: @background-color;
  @media screen and (max-width: 600px) {
    background-color: #f5f5f5;
  }
}

循环（Loops）：可以使用循环生成重复的样式，减少重复代码。

lessCopy Code.columns(@n) when (@n > 0) {
  .column-@{n} {
    width: 100% / @n;
  }
  .columns(@n - 1);
}
.columns(12);

这些是 Less 中一些常用的代码示例，它们使得样式表更加灵活、易维护，并提高了开发效率。

D.组件注册

A.分类

1.局部注册

创建.vue文件（三个组成部分）
在使用的组件内导入并且注册

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

<template>
  <div class="hm-footer">
    我是hm-footer
  </div>
</template>

<script>
export default {

}
</script>

<style>
.hm-footer {
  height: 100px;
  line-height: 100px;
  text-align: center;
  font-size: 30px;
  background-color: #4f81bd;
  color: white;
}
</style>

<template>
  <div class="hm-header">
    我是hm-header
  </div>
</template>

<script>
export default {

}
</script>

<style>
.hm-header {
  height: 100px;
  line-height: 100px;
  text-align: center;
  font-size: 30px;
  background-color: #8064a2;
  color: white;
}
</style>

<template>
  <div class="hm-main">
    我是hm-main
  </div>
</template>

<script>
export default {

}
</script>

<style>
.hm-main {
  height: 400px;
  line-height: 400px;
  text-align: center;
  font-size: 30px;
  background-color: #f79646;
  color: white;
  margin: 20px 0;
}
</style>

<template>
  <div class="App">
    <!-- 头部组件 -->
    <HmHeader></HmHeader>
    <!-- 主体组件 -->
    <HmMain></HmMain>
    <!-- 底部组件 -->
    <HmFooter></HmFooter>

    <!-- 如果 HmFooter + tab 出不来 → 需要配置 vscode
         设置中搜索 trigger on tab → 勾上
    -->
  </div>
</template>

<script>
import HmHeader from './components/HmHeader.vue'
import HmMain from './components/HmMain.vue'
import HmFooter from './components/HmFooter.vue'
export default {
  components: {
    // '组件名': 组件对象
    HmHeader: HmHeader,
    HmMain,
    HmFooter
  }
}
</script>

<style>
.App {
  width: 600px;
  height: 700px;
  background-color: #87ceeb;
  margin: 0 auto;
  padding: 20px;
}
</style>

// 文件核心作用：导入App.vue，基于App.vue创建结构渲染index.html
// 1. 导入 Vue 核心包
import Vue from 'vue'

// 2. 导入 App.vue 根组件
import App from './App.vue'

// 提示：当前处于什么环境 (生产环境 / 开发环境)
Vue.config.productionTip = false

// 3. Vue实例化，提供render方法 → 基于App.vue创建结构渲染index.html
new Vue({
  // el: '#app', 作用：和$mount('选择器')作用一致，用于指定Vue所管理容器
  // render: h => h(App),
  render: (createElement) => {
    // 基于App创建元素结构
    return createElement(App)
  }
}).$mount('#app')

当三个Vue组件都定义好了，接下来要到App.vue中进行注册：注意：Components和标签都要注册

我们注意三个点即可：以HmHeader为例子

import HmHeader from ‘./components/HmHeader.vue’
components:{
HmHeader:HmHeader,

}

<template>
<div class="App">
    <HmHeader></HmHeader>
    <HmMain></HmMain>
    <HmFooter></HmFooter>
    </div>
</template>
<script>
import HmHeader from './components/HmHeader.vue'
import HmMain from './components/HmMain.vue'
import HmFooter from './components/HmFooter.vue'
export default{
    components:{
        HmHeader:HmHeader,
        HmMain,
        HmFooter
    }
}
</script>
<style>
.App {
  width: 600px;
  height: 700px;
  background-color: #87ceeb;
  margin: 0 auto;
  padding: 20px;
}
</style>

2.全局注册：所有组件内都能使用

B.使用：

当成html标签使用<组件名></组件名>
大驼峰命名法

现在于局部注册基础上添加一个按钮HmFooter.vue，对于它我们采取全局注册的方式

<template>
  <button class="hm-button">通用按钮</button>
</template>

<script>
export default {

}
</script>

<style>
.hm-button {
  height: 50px;
  line-height: 50px;
  padding: 0 20px;
  background-color: #3bae56;
  border-radius: 5px;
  color: white;
  border: none;
  vertical-align: middle;
  cursor: pointer;
}
</style>

这一次我们不考虑App.vue，而是把目光投向main.js

// 文件核心作用：导入App.vue，基于App.vue创建结构渲染index.html
import Vue from 'vue'
import App from './App.vue'
// 编写导入的代码，往代码的顶部编写(规范)
import HmButton from './components/HmButton'
Vue.config.productionTip = false

// 进行全局注册 → 在所有的组件范围内都能直接使用
// Vue.component(组件名，组件对象)
Vue.component('HmButton', HmButton)


// Vue实例化，提供render方法 → 基于App.vue创建结构渲染index.html
new Vue({
  // render: h => h(App),
  render: (createElement) => {
    // 基于App创建元素结构
    return createElement(App)
  }
}).$mount('#app')

六：组件三大组成部分（结构/样式/逻辑）/组件通信/综合案例分析/进阶语法

1.组件三大组成部分（结构/样式/逻辑）

只能有一个根元素：也就是所有的标签都必须包含在一个

中

A.组件的样式冲突Scoped

此处展示一种项目开发的问题：

//一定要确定你是Vue2还是Vue3，其中的main.js的导入方式不一样
//下面以Vue3举例
import{createApp} from 'vue'
import App from './App.vue'
const app = createApp(App);
app.mount('#app')

默认情况：写在组件中的样式会全局生效 ->因此多个子组件之间样式容易冲突

1.全局样式：默认组件中的样式会作用到全局

2.局部样式：可以给组件加上scoped属性,可以让样式只作用于当前组件例如

<script>
export default {

}
</script>

<template>
<div class="base-one">
  <span>BaseOne</span>
</div>
</template>

<style scoped>
div{
  border:3px solid blue;
  margin:30px
}
</style>

<script>
export default{

}
</script>

<template>
  <div class="base-one">
    BaseTwo
  </div>
</template>

<style scoped>
div{
  border: 3px solid red;
  margin:30px;
}
</style>

scoped原理：

1.当前组件内标签都被添加data-v-hash值的属性

2.css选择器都被添加data-v-hash值的属性选择器

<template>
 <div data-v-che7c9bc>
     <p data-v-che7c9bc>
         我是hm-header

     </p>
 </div>
</template>
<style>
 div[data-v-che7c9bc]{
     border:1px solid #000,
     margin:10px,0;
 }
</style>
<script>
 export default{
     data(){
         return{
             msg:'1111';
         }
     }
 }
</script>

一个组件的data选项为什么必须是一个函数？

答：保证每个组件实例，维护独立的一份数据对象

每次创建新的属性实例，都会重新执行一次data函数，得到一个新对象
data(){
 return {
     count: 100
}

2.组件通信

A.什么是组件通信

组件通信，就是指组件与组件之间的数据传递
组件的数据是独立的，无法直接访问其他组件的数据
想用其他组件的数据->组件通信

B.不同的组件关系和组件通信方案分类

父子关系
非父子关系

解决方案：

父子关系：props和$emit
非父子关系用provide&inject&eventbus
通用解决方案：Vuex(适合复杂业务场景)

B.1父子通信流程

父组件通过props将数据传递给子组件
子组件通过**$emit**通知父组件修改更新

B.2父子通信方案的核心流程

2.1：父传子props

父中给子添加属性传值
子props接收
子组件使用

<script>
import Son from "@/components/Son.vue";
export default {
  name:'App',
  data(){
    return{
      myTitle:'测试title',
      gg:'公告'
    }
  },
  components:{
    Son,
  }
}
</script>

<template>
<div class="app" style="border: 3px solid #000;margin: 10px">
  我是App组件
  <Son v-bind:title="myTitle" v-bind:gg="gg"></Son>

</div>
</template>

<style>

</style>

<script>
export default{
  name:'Son-Child',//组件的名称
  props:['title','gg']
}
</script>

<template>
<div class="son">
  我是son组件 {{title}}
  公告：{{gg}}
</div>
</template>

<style scoped>

</style>

2.2子传父$emit:

子$emit发送信息
父中给子添加消息监听
父中实现处理函数

<script>
export default{
  name:'Son-child',
  props:['title'],
  methods:{
    changeFn(){
      this.$emit('changeTitle','修改后的title')
    }
  }
}
</script>

<template>
<div class="son">
  我是son组件 {{title}}
  <button @click="changeFn">修改title</button>
</div>
</template>

<style scoped>

</style>

<script>
import Son from "@/components/Son.vue";
export default {
  name:'App',
  data(){
    return{
      myTitle:'测试title',
      gg:'公告'
    }
  },
  components:{
    Son,
  },
  methods:{
    handleChange(newTitle){
      this.myTitle=newTitle;
    }
  }
}
</script>

<template>
<div class="app" style="border: 3px solid #000;margin: 10px">
  我是App组件
  <Son v-bind:title="myTitle" @changeTitle="handleChange"></Son>

</div>
</template>

<style>

</style>

C.什么是prop

定义： 组件上注册的一些自定义属性

**作用：**向子组件传递数据

特点：

可以传递任意数量的prop
可以传递任意类型的prop

props:{
    xxx:boolean
}//xxx是名称 boolean是类型 xxx在父组件中template调用子组件时在属性里v-bind:xxx="xxxa"

export default{
	data(){
	return{
	xxx:000
}
}
}

<script>
export default {
  props:['username','age','isSingle','car','hobby']
}
</script>

<template>
<div class="userInfo">
  <h3>我是个人信息组件</h3>
  <div>姓名:{{username}}</div>
  <div>年龄：{{age}}</div>
  <div>是否单身:{{isSingle}}</div>
  <div>座驾:{{car.brand}}</div>
  <div>兴趣爱好：{{hobby}}</div>
</div>
</template>

<style>
.userInfo{
  width: 300px;
  border: 3px solid #000;
  padding: 20px;
}
.userInfo > div{
  margin: 20px 10px;
}
</style>

<script>
import UserInfo from "@/components/UserInfo.vue";
export default{
  data(){
    return{
      username:'小帅',
      age:28,
      isSingle:true,
      car:{
        brand:'小米',
      },
      hobby:'唱，跳，rap,篮球'
    }
  },
  components:{
    UserInfo
  }
}
</script>

<template>
<div class="app">
  <UserInfo
  :username="username"
  :age="age"
  :is-single="isSingle"
  :car="car"
  :hobby="hobby"
  ></UserInfo>
</div>
</template>

<style>

</style>

D.prop校验

**思考：**组件的prop可以乱传么

**作用：**为组件的prop指定验证要求，不符合要求，控制台就会有错误提示->类似于Java中的自定义异常，帮助开发者快速找到问题

语法：

类型校验
非空校验
默认值
自定义校验

<script>
import UserInfo from "@/components/UserInfo.vue";
export default {
  data(){
    return{
      width:10,
    }
  },
  components:{
    UserInfo,
  }
}
</script>

<template>
  <div class="app">
    <UserInfo :w="width"></UserInfo>
  </div>
</template>

<style>

</style>

<template>
  <div class="base-progress">
    <div class="inner" :style="{ width: w + '%' }">
      <span>{{ w }}%</span>
    </div>
  </div>
</template>

<script>
export default {
  // 1.基础写法（类型校验）
  // props: {
  //   w: Number,
  // },

  // 2.完整写法（类型、默认值、非空、自定义校验）
  props: {
    w: {
      type: Number,
      required: true,
      default: 0,
      validator(val) {
        // console.log(val)
        if (val >= 100 || val <= 0) {
          console.error('传入的范围必须是0-100之间')
          return false
        } else {
          return true
        }
      },
    },
  },
}
</script>

<style scoped>
.base-progress {
  height: 26px;
  width: 400px;
  border-radius: 15px;
  background-color: #272425;
  border: 3px solid #272425;
  box-sizing: border-box;
  margin-bottom: 30px;
}
.inner {
  position: relative;
  background: #379bff;
  border-radius: 15px;
  height: 25px;
  box-sizing: border-box;
  left: -3px;
  top: -2px;
}
.inner span {
  position: absolute;
  right: 0;
  top: 26px;
}
</style>

E.prop&data、单向数据流

**共性：**都可以给组件提供数据

区别：

data的数据是自己的->随便改
prop的数据是外部的->不能直接改，要遵循单向数据流

单向数据流是什么：

父级prop的数据更新，会向下流动，影响子组件，这个数据流动是单向的。

<template>
  <div class="base-count">
    <button @click="handleSub">-</button>
    <span>{{ count }}</span>
    <button @click="handleAdd">+</button>
  </div>
</template>

<script>
export default {
  // 1.自己的数据随便修改  （谁的数据 谁负责）
  // data () {
  //   return {
  //     count: 100,
  //   }
  // },
  // 2.外部传过来的数据 不能随便修改
  props: {
    count: {
      type: Number,
    },
  },
  methods: {
    handleSub() {
      this.$emit('changeCount', this.count - 1)
    },
    handleAdd() {
      this.$emit('changeCount', this.count + 1)
    },
  },
}
</script>

<style>
.base-count {
  margin: 20px;
}
</style>

<template>
  <div class="app">
    <BaseCount :count="count" @changeCount="handleChange"></BaseCount>
  </div>
</template>

<script>
import BaseCount from './components/BaseCount.vue'
export default {
  components:{
    BaseCount
  },
  data(){
    return {
      count:100
    }
  },
  methods: {
    handleChange(newVal) {
      // console.log(newVal);
      this.count = newVal
    }
  }
}
</script>

<style>

</style>

F.非父子通信- event bus事件总线

<template>
  <div class="base-a">
    我是A组件（接受方）
    <p>{{msg}}</p>  
  </div>
</template>

<script>
import Bus from '../utils/EventBus'
export default {
  data() {
    return {
      msg: '',
    }
  },
  created() {
    Bus.$on('sendMsg', (msg) => {
      // console.log(msg)
      this.msg = msg
    })
  },
}
</script>

<style scoped>
.base-a {
  width: 200px;
  height: 200px;
  border: 3px solid #000;
  border-radius: 3px;
  margin: 10px;
}
</style>

<template>
  <div class="base-b">
    <div>我是B组件（发布方）</div>
    <button @click="sendMsgFn">发送消息</button>
  </div>
</template>

<script>
import Bus from '../utils/EventBus'
export default {
  methods: {
    sendMsgFn() {
      Bus.$emit('sendMsg', '今天天气不错，适合旅游')
    },
  },
}
</script>

<style scoped>
.base-b {
  width: 200px;
  height: 200px;
  border: 3px solid #000;
  border-radius: 3px;
  margin: 10px;
}
</style>

<template>
  <div class="base-c">
    我是C组件（接受方）
    <p>{{msg}}</p>  
  </div>
</template>

<script>
import Bus from '../utils/EventBus'
export default {
  data() {
    return {
      msg: '',
    }
  },
  created() {
    Bus.$on('sendMsg', (msg) => {
      // console.log(msg)
      this.msg = msg
    })
  },
}
</script>

<style scoped>
.base-c {
  width: 200px;
  height: 200px;
  border: 3px solid #000;
  border-radius: 3px;
  margin: 10px;
}
</style>

import Vue from 'vue'

const Bus  =  new Vue()

export default Bus

G.provide&inject作用：跨层级共享数据

1.父组件：provide提供数据

<template>
  <div class="app">
    我是APP组件
    <button @click="change">修改数据</button>
    <SonA></SonA>
    <SonB></SonB>
  </div>
</template>

<script>
import SonA from './components/SonA.vue'
import SonB from './components/SonB.vue'
export default {
  provide() {
    return {
      // 简单类型 是非响应式的
      color: this.color,
      // 复杂类型 是响应式的
      userInfo: this.userInfo,
    }
  },
  data() {
    return {
      color: 'pink',
      userInfo: {
        name: 'zs',
        age: 18,
      },
    }
  },
  methods: {
    change() {
      this.color = 'red'
      this.userInfo.name = 'ls'
    },
  },
  components: {
    SonA,
    SonB,
  },
}
</script>

<style>
.app {
  border: 3px solid #000;
  border-radius: 6px;
  margin: 10px;
}
</style>

2.子孙类型取用

<template>
  <div class="SonA">我是SonA组件
    <GrandSon></GrandSon>
  </div>
</template>

<script>
import GrandSon from '../components/GrandSon.vue'
export default {
  components:{
    GrandSon
  }
}
</script>

<style>
.SonA {
  border: 3px solid #000;
  border-radius: 6px;
  margin: 10px;
  height: 200px;
}
</style>

<template>
  <div class="SonB">
    我是SonB组件
  </div>
</template>

<script>
export default {

}
</script>

<style>
.SonB {
  border: 3px solid #000;
  border-radius: 6px;
  margin: 10px;
  height: 200px;
}
</style>

<template>
  <div class="grandSon">
    我是GrandSon
    {{ color }} -{{ userInfo.name }} -{{ userInfo.age }}
  </div>
</template>

<script>
export default {
  inject: ['color', 'userInfo'],
}
</script>

<style>
.grandSon {
  border: 3px solid #000;
  border-radius: 6px;
  margin: 10px;
  height: 100px;
}
</style>

3.综合案例分析

4.进阶语法

A.v-model原理

原理：v-model本质是一个语法糖。例如应用在输入框上，就是value属性和input属性的合写

**作用：**提供数据的双向绑定

数据变，视图跟着变 v-bind:value
视图变，数据跟着变：v-on:input
注意：$event用于在模板中，获取事件的形参

换句话说。你在子组件的方法里面this.$emit(‘input’,e.target.value)

这里的input就必须要在父组件中的template里面引用子组件时候用v-on绑定上

比如：v-on:input=“selectId=$event” 然后v-bind一个value值为"selected"

但是这样写太麻烦了我们简化上述的v-on和v-bind以及value与input为v-model="selectID"属性

<template>
<div id="app">
    <input v-model=“msg" type=text><
    <input v-bind:value="msg" @input="msg = $event.target.value" type="text">
    </div>
</template>

B.表单类组件封装&v-model简化代码

1.表单类组件封装->实现子组件和父组件数据的 双向绑定

父传子数据从父组件通过props传递过来拆解v-model绑定数据
子传父监听输入，子组件传值给父组件修改

<template>
  <div>
    <select :value="value" @change="selectCity">
      <option value="101">北京</option>
      <option value="102">上海</option>
      <option value="103">武汉</option>
      <option value="104">广州</option>
      <option value="105">深圳</option>
    </select>
  </div>
</template>

<script>
export default {
  props: {
    value: String,
  },
  methods: {
    selectCity(e) {
      this.$emit('input', e.target.value)
    },
  },
}
</script>

<style>
</style>

<template>
  <div class="app">
    <BaseSelect
      v-model="selectId"
    ></BaseSelect>
  </div>
</template>

<script>
import BaseSelect from './components/BaseSelect.vue'
export default {
  data() {
    return {
      selectId: '102',
    }
  },
  components: {
    BaseSelect,
  },
}
</script>

<style>
</style>

C.sync修饰符

**作用：**可以实现子组件与父组件数据的双向绑定，简化代码

**特点：**prop属性名，可以自定义，非固定为 value

场景： 封装弹框类的基础组件， visible属性 true显示 false隐藏

**本质：**就是 :属性名和 @update:属性名合写

**痛点:**我们之前提到了 v-bind:value v-on:input这种例子。但是有时候我们希望v-bind的元素不被限定为value，比如我做一个弹窗，我希望可读性高一点。于是我希望用visible来替代value这个传值，对弹窗类进行封装

<BaseDialog:visible.sync="isShow"/>
    //等价于
<BaseDialog :visible="isShow"
@update:visible="isShow=$event"/>

那如何接受呢？

props:{
    visible:Boolean
},
this.$emit('update:visible',false);

<template>
  <div class="base-dialog-wrap" v-show="isShow">
    <div class="base-dialog">
      <div class="title">
        <h3>温馨提示：</h3>
        <button class="close" @click="closeDialog">x</button>
      </div>
      <div class="content">
        <p>你确认要退出本系统么？</p>
      </div>
      <div class="footer">
        <button>确认</button>
        <button>取消</button>
      </div>
    </div>
  </div>
</template>

<script>
export default {
  props: {
    isShow: Boolean,
  },
  methods:{
    closeDialog(){
      this.$emit('update:isShow',false)
    }
  }
}
</script>

<style scoped>
.base-dialog-wrap {
  width: 300px;
  height: 200px;
  box-shadow: 2px 2px 2px 2px #ccc;
  position: fixed;
  left: 50%;
  top: 50%;
  transform: translate(-50%, -50%);
  padding: 0 10px;
}
.base-dialog .title {
  display: flex;
  justify-content: space-between;
  align-items: center;
  border-bottom: 2px solid #000;
}
.base-dialog .content {
  margin-top: 38px;
}
.base-dialog .title .close {
  width: 20px;
  height: 20px;
  cursor: pointer;
  line-height: 10px;
}
.footer {
  display: flex;
  justify-content: flex-end;
  margin-top: 26px;
}
.footer button {
  width: 80px;
  height: 40px;
}
.footer button:nth-child(1) {
  margin-right: 10px;
  cursor: pointer;
}
</style>

<template>
  <div class="app">
    <button @click="openDialog">退出按钮</button>
    <!-- isShow.sync  => :isShow="isShow" @update:isShow="isShow=$event" -->
    <BaseDialog :isShow.sync="isShow"></BaseDialog>
  </div>
</template>

<script>
import BaseDialog from './components/BaseDialog.vue'
export default {
  data() {
    return {
      isShow: false,
    }
  },
  methods: {
    openDialog() {
      this.isShow = true
      // console.log(document.querySelectorAll('.box')); 
    },
  },
  components: {
    BaseDialog,
  },
}
</script>

<style>
</style>

D.ref和$refs

作用：利用ref和$refs可以用于获取dom元素或者组件实例

原本echarts中获取图表，容易误取同名表

const myChart = echarts.init(document.querySelector(.box))
//现在进行了优化
var myChart = echarts.init(this.$refs.baseChartBox)

现在我们简化流程+减少错误

1.获取Dom:找到目标标签-添加ref属性

<div ref="chartRef">我是渲染图表的容器</div>

2.恰当时机，通过this.$refs.xxx获取目标标签

mounted(){
 console.log(this.$refs.chartRef)
}

<template>
  <div class="base-chart-box" ref="baseChartBox">子组件</div>
</template>

<script>
import * as echarts from 'echarts'

export default {
  mounted() {
    // 基于准备好的dom，初始化echarts实例
    // document.querySelector 会查找项目中所有的元素
    // $refs只会在当前组件查找盒子
    // var myChart = echarts.init(document.querySelector('.base-chart-box'))
    var myChart = echarts.init(this.$refs.baseChartBox)
    // 绘制图表
    myChart.setOption({
      title: {
        text: 'ECharts 入门示例',
      },
      tooltip: {},
      xAxis: {
        data: ['衬衫', '羊毛衫', '雪纺衫', '裤子', '高跟鞋', '袜子'],
      },
      yAxis: {},
      series: [
        {
          name: '销量',
          type: 'bar',
          data: [5, 20, 36, 10, 10, 20],
        },
      ],
    })
  },
}
</script>

<style scoped>
.base-chart-box {
  width: 400px;
  height: 300px;
  border: 3px solid #000;
  border-radius: 6px;
}
</style>

<template>
  <div class="app">
    <div class="base-chart-box">
      这是一个捣乱的盒子
    </div>
    <BaseChart></BaseChart>
  </div>
</template>

<script>
import BaseChart from './components/BaseChart.vue'
export default {
  components:{
    BaseChart
  }
}
</script>

<style>
.base-chart-box {
  width: 300px;
  height: 200px;
}
</style>

E.Vue异步更新、$nextTick

在Vue.js开发过程中，我们经常需要关注数据的变化，以便进行相应的视图更新。然而，JavaScript的执行是单线程的，如果在数据更新时直接操作DOM，会导致页面渲染不及时，出现闪烁等问题。为了解决这个问题，Vue.js提供了一个名为nextTick的机制，它能够确保在下一个“tick”中执行延迟回调，从而实现异步更新DOM。

nextTick是Vue.js中的一个内部方法，用于在下一个“tick”执行延迟回调。在Vue.js中，一个“tick”指的是JavaScript事件循环的一个完整周期。当调用nextTick时，Vue.js会将回调函数添加到队列中，等到当前操作完成（包括DOM更新）后，再执行回调函数。

为什么要有nexttick

举个例子

{{num}}
for(let i=0; i<100000; i++){
    num = i
}

如果没有 nextTick 更新机制，那么 num 每次更新值都会触发视图更新(上面这段代码也就是会更新10万次视图)，有了nextTick机制，只需要更新一次，所以nextTick本质是一种优化策略

需求：编辑标题：编辑框自动聚焦

希望Dom在更新完成后做某事，可以用$nextTick

new Vue({
    el:'#app',
    data:{
        message:'HelloWorld'
    },
    methods:{
        updateMessage(){
            this.message="HelloWorld";
            this.$nextTick(function(){
                console.log('Dom updated')
            })
        }
    }
})