• vue-生命周期钩子函数-axios-$refs-$nextTick的使用

    文章目录

    一、 Vue生命周期介绍

    组件从 创建 到 销毁 的整个过程就是生命周期

    • 生命周期：组件学习，到了某个时间段，在相应函数内部做某些事情！
    • function created( ) { 做某些事件 }
    • 生命周期：特定函数，会在某个时间点被执行！也叫：钩子函数

    Vue 框架内置函数，随着组件的生命周期阶段，自动执行

    • 作用: 特定的时间点，执行特定的操作；

    • 场景: 组件创建完毕后，可以在created 生命周期函数中发起Ajax 请求，从而初始化 data 数据

    分类:

    4大阶段8个方法

    • 初始化
    • 挂载
    • 更新
    • 销毁
    阶段方法名方法名
    初始化beforeCreatecreated
    挂载beforeMountmounted
    更新beforeUpdateupdated
    销毁beforeDestroydestroyed

    官网文档：https://cn.vuejs.org/guide/essentials/lifecycle.html

    1.初始化阶段

    1. new Vue() – Vue实例化 ( vue文件 就是组件，也是一个小的Vue实例)
    2. Init Events & Lifecycle – 初始化事件和生命周期函数：beforeCreate创建之前 和 created创建完成
    3. beforeCreate – 生命周期钩子函数被执行
    4. Init injections&reactivity – Vue内部添加了data和methods等
    5. created – 生命周期钩子函数被执行, 实例创建
    6. 接下来是编译模板阶段 –开始分析
    7. Has el option? – 是否有el选项 – 检查要挂到哪里
      没有. 调用$mount()方法
      有, 继续检查template选项

    代码:
    在components/Life.vue - 创建一个文件

    
<script>
export default {
    data(){
        return {
            msg: "hello, Vue"
        }
    },
    // 一. 初始化
    // new Vue()以后, vue内部给实例对象添加了一些属性和方法, data和methods初始化"之前"
    beforeCreate(){
        console.log("beforeCreate -- 执行");
        console.log(this.msg); // undefined
    },
    
    // data和methods初始化以后  场景: 网络请求, 注册全局事件
    created(){
        console.log("created -- 执行");
        console.log(this.msg); // hello, Vue

        this.timer = setInterval(() => {
            console.log("哈哈哈");
        }, 1000)
    }
}
script>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    在App.vue - 引入使用

    <template>
  <div>
    <h1>1. 生命周期</h1>
 	<Life></Life>
  </div>
</template>

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    2.挂载阶段

    1. template选项检查
      有 - 编译template返回render渲染函数
      无 – 编译el选项对应标签作为template(要渲染的模板)
    2. 虚拟DOM挂载成真实DOM之前
    3. beforeMount – 生命周期钩子函数被执行
    4. Create … – 把虚拟DOM和渲染的数据一并挂到真实DOM上
    5. 真实DOM挂载完毕
    6. mounted – 生命周期钩子函数被执行

    代码:
    在components/Life.vue - 创建一个文件

    <template>
  <div>
      <p>学习生命周期 - 看控制台打印p>
      <p id="myP">{{ msg }}p>
  div>
template>

<script>
export default {
    // ...省略其他代码
    
    // 二. 挂载
    // 真实DOM挂载之前
    // 场景: 预处理data, 不会触发updated钩子函数
    beforeMount(){
        console.log("beforeMount -- 执行");
        console.log(document.getElementById("myP")); // null

        this.msg = "重新值"
    },
    // 真实DOM挂载以后
    // 场景: 挂载后真实DOM
    mounted(){
        console.log("mounted -- 执行");
        console.log(document.getElementById("myP")); // p
    }
}
script>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    3.更新阶段

    1. 当data里数据改变, 更新DOM之前
    2. beforeUpdate – 生命周期钩子函数被执行
    3. Virtual DOM…… – 虚拟DOM重新渲染, 打补丁到真实DOM
    4. updated – 生命周期钩子函数被执行
    5. 当有data数据改变 – 重复这个循环

    代码:
    components/Life.vue - 创建一个文件

    准备ul+li循环, 按钮添加元素, 触发data改变->导致更新周期开始

    <template>
  <div>
      <p>学习生命周期 - 看控制台打印p>
      <p id="myP">{{ msg }}p>
      <ul id="myUL">
          <li v-for="(val, index) in arr" :key="index">
              {{ val }}
          li>
      ul>
      <button @click="arr.push(1000)">点击末尾加值button>
  div>
template>

<script>
export default {
    data(){
        return {
            msg: "hello, Vue",
            arr: [5, 8, 2, 1]
        }
    },
    // ...省略其他代码

    // 三. 更新
    // 前提: data数据改变才执行
    // 更新之前
    beforeUpdate(){
        console.log("beforeUpdate -- 执行");
        console.log(document.querySelectorAll("#myUL>li")[4]); // undefined
    },
    // 更新之后
    // 场景: 获取更新后的真实DOM
    updated(){
        console.log("updated -- 执行");
        console.log(document.querySelectorAll("#myUL>li")[4]); // li
    }
}
script>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    4.销毁阶段

    1. 当$destroy()被调用 – 比如组件DOM被移除(例v-if)
    2. beforeDestroy – 生命周期钩子函数被执行
    3. 拆卸数据监视器、子组件和事件侦听器
    4. 实例销毁后, 最后触发一个钩子函数
    5. destroyed – 生命周期钩子函数被执行

    代码:
    components/Life.vue - 准备生命周期方法( Life组件即将要被删除 )

    <script>
export default {
    // ...省略其他代码
    
    // 四. 销毁
    // 前提: v-if="false" 销毁Vue实例
    // 场景: 移除全局事件, 移除当前组件, 计时器, 定时器, eventBus移除事件$off方法
    beforeDestroy(){
        // console.log('beforeDestroy -- 执行');
        clearInterval(this.timer)
    },
    destroyed(){
        // console.log("destroyed -- 执行");
    }
}
script>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    主要: App.vue - 点击按钮让Life组件从DOM上移除 -> 导致Life组件进入销毁阶段

    




    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    5.总结

    • 初始化阶段：created 用data内数据发送ajax请求！
    • 挂载阶段：mounted 进行必要webapi DOM操作!（给一个思考多个机会！）
    • 更新阶段：新旧虚拟dom对比后结果，打补丁到真实dom阶段上！（不常用！）
    • 销毁阶段：某些子组件内部，如果开启定时器任务，销毁组件之前，需要清除定时器！

    二、axios

    axios文档：http://www.axios-js.com/

    特点：

    • 支持客户端发送Ajax请求
    • 支持服务端Node.js发送请求
    • 支持Promise相关用法
    • 支持请求和响应的拦截器功能
    • 自动转换JSON数据
    • axios 底层还是原生XHR实现, 内部通过Promise封装的

    1.axios的基本使用

    
// 4. 全局配置
axios.defaults.baseURL = "http://123.57.109.30:3006"


axios({
      method: '请求方式', // get post
      url: '请求地址',
      data: {    // 拼接到请求体的参数,  post请求的参数
        xxx: xxx,
      },
      params: {  // 拼接到请求行的参数, get请求的参数
        xxx: xxx 
      }
    })
    .then(res => {
        console.log(res.data) // 后台返回的结果   回调函数（回：回头）
    })
    .catch(err => {
        console.log(err) // 后台报错返回
    })

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    三、$refs

    1.获取DOM

    利用 ref 和 $refs 可以用于获取 dom 元素
    代码:
    components/More.vue

    <template>
  <div>
      <p>1. 获取原生DOM元素</p>
      <h1 id="h" ref="myH">我是一个孤独可怜又能吃的h1</h1>
  </div>
</template>

<script>
// 目标: 获取组件对象
// 1. 创建组件/引入组件/注册组件/使用组件
// 2. 组件起别名ref
// 3. 恰当时机, 获取组件对象
export default {
    mounted(){
        console.log(document.getElementById("h")); // h1
        console.log(this.$refs.myH); // h1
    }
}
</script>

<style>

</style>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    总结: 通过id / ref, 都可以获取原生DOM标签

    2.获取组件对象

    获取组件对象, 调用组件里方法
    代码:
    components/Child/Demo.vue

    <template>
  <div>
      <p>我是Demo组件</p>
  </div>
</template>

<script>
export default {
    methods: {
        fn(){
            console.log("demo组件内的方法被调用了");
        }
    }
}
</script>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    More.vue - 获取组件对象 - 调用组件方法

    <template>
  <div>
      <p>1. 获取原生DOM元素</p>
      <h1 id="h" ref="myH">我是一个孤独可怜又能吃的h1</h1>
      <p>2. 获取组件对象 - 可调用组件内一切</p>
      <Demo ref="de"></Demo>
  </div>
</template>

<script>
// 目标: 获取组件对象
// 1. 创建组件/引入组件/注册组件/使用组件
// 2. 组件起别名ref
// 3. 恰当时机, 获取组件对象
import Demo from './Child/Demo'
export default {
    mounted(){
        console.log(document.getElementById("h")); // h1
        console.log(this.$refs.myH); // h1

        let demoObj = this.$refs.de;
        demoObj.fn()
    },
    components: {
        Demo
    }
}
</script>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    总结:
    ref定义值, 通过$refs.值 来获取组件对象, 就能继续调用组件内的变量

    • 父级组件对子组件：
      • 传入数据：父---->子；
      • ref随意获取子元素内部：数据和方法。（子组件：设计方法，具有形参！）

    四、$nextTick使用

    1.使用

    点击count++, 马上通过" 原生DOM "拿标签内容, 无法拿到新值

    components/Move.vue - 继续新增第三套代码

    <template>
  <div>
      <p>1. 获取原生DOM元素</p>
      <h1 id="h" ref="myH">我是一个孤独可怜又能吃的h1</h1>
      
      
      <p>2. 获取组件对象 - 可调用组件内一切</p>
      <Demo ref="de"></Demo>
      
      
      <p>3. vue更新DOM是异步的</p>
      <p ref="myP">{{ count }}</p>
      <button @click="btn">点击count+1, 马上提取p标签内容</button>
  </div>
</template>

<script>
// 目标: 获取组件对象
// 1. 创建组件/引入组件/注册组件/使用组件
// 2. 组件起别名ref
// 3. 恰当时机, 获取组件对象
import Demo from './Child/Demo'
export default {
    mounted(){
        console.log(document.getElementById("h")); // h1
        console.log(this.$refs.myH); // h1

        let demoObj = this.$refs.de;
        demoObj.fn()
    },
    components: {
        Demo
    },
    data(){
        return {
            count: 0
        }
    },
    methods: {
        btn(){
            this.count++; // vue监测数据更新, 开启一个DOM更新队列(异步任务)
            console.log(this.$refs.myP.innerHTML); // 0

            // 原因: Vue更新DOM异步
            // 解决: this.$nextTick()
            // 过程: DOM更新完会挨个触发$nextTick里的函数体
            this.$nextTick(() => {
                console.log(this.$refs.myP.innerHTML); // 1
            })
        }
    }
}
</script>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    总结: 因为DOM更新是异步的

    2.使用场景

    点击搜索按钮, 弹出聚焦的输入框, 按钮消失
    components/Tick.vue

    <template>
  <div>
      <input ref="myInp" type="text" placeholder="这是一个输入框" v-if="isShow">
      <button v-else @click="btn">点击我进行搜索</button>
  </div>
</template>

<script>
// 目标: 点按钮(消失) - 输入框出现并聚焦
// 1. 获取到输入框
// 2. 输入框调用事件方法focus()达到聚焦行为
export default {
    data(){
        return {
            isShow: false
        }
    },
    methods: {
        btn(){
            this.isShow = true;
            
            
            this.$refs.myInp.focus(); // 没有效果
            
            // 原因: data变化更新DOM是异步的
            // 输入框还没有挂载到真实DOM上
            // 解决:
            // this.$nextTick(() => {
            //     this.$refs.myInp.focus()
            // })
        }
        //async btn(){  
        //    this.isShow = true;
        //    
        //    // 扩展: await取代回调函数
        //    // $nextTick()原地返回Promise对象
        //    await this.$nextTick()
        //    this.$refs.myInp.focus()
        //}
    }
}
</script>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
  • 相关阅读:
    Postman的高级用法—Runner的使用​
    Python基础|输入、数据类型、变量、格式化输出点
    【微服务】Nacos通知客户端服务变更以及重试机制
    Java设计模式-创建者模式-工厂模式
    Docker Compose安装部署Jenkins
    Linux学习第24天：Linux 阻塞和非阻塞 IO 实验（一）： 挂起
    React Native 创建新项目详细教程
    一文教你快速搭建数据驱动自动化测试框架
    java中的集合框架基础-2
    泛型的使用
  • 原文地址：https://blog.csdn.net/m0_62181310/article/details/126652521