Vue中组件通信方式有很多，其中Vue2和Vue3实现起来也会有很多差异；本文将通过选项式API 组合式API以及setup三种不同实现方式全面介绍Vue2和Vue3的组件通信方式。其中将要实现的通信方式如下表所示

方式 Vue2 Vue3
父传子 props props
子传父 $emit emits
父传子 $attrs attrs
子传父 $listeners 无(合并到 attrs方式)
父传子 provide provide
子传父 inject inject
子组件访问父组件 $parent 无
父组件访问子组件 $children 无
父组件访问子组件 $ref expose&ref
兄弟传值 EventBus mitt

props

props是组件通信中最常用的通信方式之一。父组件通过v-bind传入，子组件通过props接收，下面是它的三种实现方式

  • 选项式API
  1. //父组件
  3. <template>
  4.   <div>
  5.     <Child :msg="parentMsg" />
  6.   </div>
  7. </template>
  8. <script>
  9. import Child from './Child'
  10. export default {
  11.   components:{
  12.     Child
  13.   },
  14.   data() {
  15.     return {
  16.       parentMsg: '父组件信息'
  17.     }
  18.   }
  19. }
  20. </script>
  22. //子组件
  24. <template>
  25.   <div>
  26.     {{msg}}
  27.   </div>
  28. </template>
  29. <script>
  30. export default {
  31.   props:['msg']
  32. }
  33. </script>
  • 组合式Api
  1. //父组件
  3. <template>
  4.   <div>
  5.     <Child :msg="parentMsg" />
  6.   </div>
  7. </template>
  8. <script>
  9. import { ref,defineComponent } from 'vue'
  10. import Child from './Child.vue'
  11. export default defineComponent({
  12.   components:{
  13.     Child
  14.   },
  15.   setup() {
  16.     const parentMsg = ref('父组件信息')
  17.     return {
  18.       parentMsg
  19.     };
  20.   },
  21. });
  22. </script>
  24. //子组件
  26. <template>
  27.     <div>
  28.         {{ parentMsg }}
  29.     </div>
  30. </template>
  31. <script>
  32. import { defineComponent,toRef } from "vue";
  33. export default defineComponent({
  34.     props: ["msg"],// 如果这行不写，下面就接收不到
  35.     setup(props) {
  36.         console.log(props.msg) //父组件信息
  37.         let parentMsg = toRef(props, 'msg')
  38.         return {
  39.             parentMsg
  40.         };
  41.     },
  42. });
  43. </script>
  • setup语法糖

  2. //父组件
  4. <template>
  5.   <div>
  6.     <Child :msg="parentMsg" />
  7.   </div>
  8. </template>
  9. <script setup>
  10. import { ref } from 'vue'
  11. import Child from './Child.vue'
  12. const parentMsg = ref('父组件信息')
  13. </script>
  15. //子组件
  17. <template>
  18.     <div>
  19.         {{ parentMsg }}
  20.     </div>
  21. </template>
  22. <script setup>
  23. import { toRef, defineProps } from "vue";
  24. const props = defineProps(["msg"]);
  25. console.log(props.msg) //父组件信息
  26. let parentMsg = toRef(props, 'msg')
  27. </script>

注意

props中数据流是单项的，即子组件不可改变父组件传来的值

在组合式API中，如果想在子组件中用其它变量接收props的值时需要使用toRef将props中的属性转为响应式。

emit

子组件可以通过emit发布一个事件并传递一些参数，父组件通过v-on进行这个事件的监听

  • 选项式API

  2. //父组件
  4. <template>
  5.   <div>
  6.     <Child @sendMsg="getFromChild" />
  7.   </div>
  8. </template>
  9. <script>
  10. import Child from './Child'
  11. export default {
  12.   components:{
  13.     Child
  14.   },
  15.   methods: {
  16.     getFromChild(val) {
  17.       console.log(val) //我是子组件数据
  18.     }
  19.   }
  20. }
  21. </script>
  23. // 子组件
  25. <template>
  26.   <div>
  27.     <button @click="sendFun">send</button>
  28.   </div>
  29. </template>
  30. <script>
  31. export default {
  32.   methods:{
  33.     sendFun(){
  34.       this.$emit('sendMsg','我是子组件数据')
  35.     }
  36.   }
  37. }
  38. </script>
  • 组合式Api

  2. //父组件
  4. <template>
  5.   <div>
  6.     <Child @sendMsg="getFromChild" />
  7.   </div>
  8. </template>
  9. <script>
  10. import Child from './Child'
  11. import { defineComponent } from "vue";
  12. export default defineComponent({
  13.   components: {
  14.     Child
  15.   },
  16.   setup() {
  17.     const getFromChild = (val) => {
  18.       console.log(val) //我是子组件数据
  19.     }
  20.     return {
  21.       getFromChild
  22.     };
  23.   },
  24. });
  25. </script>
  27. //子组件
  29. <template>
  30.     <div>
  31.         <button @click="sendFun">send</button>
  32.     </div>
  33. </template>
  35. <script>
  36. import { defineComponent } from "vue";
  37. export default defineComponent({
  38.     emits: ['sendMsg'],
  39.     setup(props, ctx) {
  40.         const sendFun = () => {
  41.             ctx.emit('sendMsg', '我是子组件数据')
  42.         }
  43.         return {
  44.             sendFun
  45.         };
  46.     },
  47. });
  48. </script>
  • setup语法糖

  2. //父组件
  4. <template>
  5.   <div>
  6.     <Child @sendMsg="getFromChild" />
  7.   </div>
  8. </template>
  9. <script setup>
  10. import Child from './Child'
  11. const getFromChild = (val) => {
  12.       console.log(val) //我是子组件数据
  13.     }
  14. </script>
  16. //子组件
  18. <template>
  19.     <div>
  20.         <button @click="sendFun">send</button>
  21.     </div>
  22. </template>
  23. <script setup>
  24. import { defineEmits } from "vue";
  25. const emits = defineEmits(['sendMsg'])
  26. const sendFun = () => {
  27.     emits('sendMsg', '我是子组件数据')
  28. }
  29. </script>

attrs和listeners

子组件使用$attrs可以获得父组件除了props传递的属性和特性绑定属性 (class和 style)之外的所有属性。

子组件使用$listeners可以获得父组件(不含.native修饰器的)所有v-on事件监听器，在Vue3中已经不再使用；但是Vue3中的attrs不仅可以获得父组件传来的属性也可以获得父组件v-on事件监听器

  • 选项式API

  2. //父组件
  4. <template>
  5.   <div>
  6.     <Child @parentFun="parentFun" :msg1="msg1" :msg2="msg2"  />
  7.   </div>
  8. </template>
  9. <script>
  10. import Child from './Child'
  11. export default {
  12.   components:{
  13.     Child
  14.   },
  15.   data(){
  16.     return {
  17.       msg1:'子组件msg1',
  18.       msg2:'子组件msg2'
  19.     }
  20.   },
  21.   methods: {
  22.     parentFun(val) {
  23.       console.log(`父组件方法被调用,获得子组件传值：${val}`)
  24.     }
  25.   }
  26. }
  27. </script>
  29. //子组件
  31. <template>
  32.   <div>
  33.     <button @click="getParentFun">调用父组件方法</button>
  34.   </div>
  35. </template>
  36. <script>
  37. export default {
  38.   methods:{
  39.     getParentFun(){
  40.       this.$listeners.parentFun('我是子组件数据')
  41.     }
  42.   },
  43.   created(){
  44.     //获取父组件中所有绑定属性
  45.     console.log(this.$attrs)  //{"msg1": "子组件msg1","msg2": "子组件msg2"}
  46.     //获取父组件中所有绑定方法
  47.     console.log(this.$listeners) //{parentFun:f}
  48.   }
  49. }
  50. </script>
  • 组合式API

  2. //父组件
  4. <template>
  5.   <div>
  6.     <Child @parentFun="parentFun" :msg1="msg1" :msg2="msg2" />
  7.   </div>
  8. </template>
  9. <script>
  10. import Child from './Child'
  11. import { defineComponent,ref } from "vue";
  12. export default defineComponent({
  13.   components: {
  14.     Child
  15.   },
  16.   setup() {
  17.     const msg1 = ref('子组件msg1')
  18.     const msg2 = ref('子组件msg2')
  19.     const parentFun = (val) => {
  20.       console.log(`父组件方法被调用,获得子组件传值：${val}`)
  21.     }
  22.     return {
  23.       parentFun,
  24.       msg1,
  25.       msg2
  26.     };
  27.   },
  28. });
  29. </script>
  31. //子组件
  33. <template>
  34.     <div>
  35.         <button @click="getParentFun">调用父组件方法</button>
  36.     </div>
  37. </template>
  38. <script>
  39. import { defineComponent } from "vue";
  40. export default defineComponent({
  41.     emits: ['sendMsg'],
  42.     setup(props, ctx) {
  43.         //获取父组件方法和事件
  44.         console.log(ctx.attrs) //Proxy {"msg1": "子组件msg1","msg2": "子组件msg2"}
  45.         const getParentFun = () => {
  46.             //调用父组件方法
  47.             ctx.attrs.onParentFun('我是子组件数据')
  48.         }
  49.         return {
  50.             getParentFun
  51.         };
  52.     },
  53. });
  54. </script>
  • setup语法糖

  2. //父组件
  4. <template>
  5.   <div>
  6.     <Child @parentFun="parentFun" :msg1="msg1" :msg2="msg2" />
  7.   </div>
  8. </template>
  9. <script setup>
  10. import Child from './Child'
  11. import { ref } from "vue";
  12. const msg1 = ref('子组件msg1')
  13. const msg2 = ref('子组件msg2')
  14. const parentFun = (val) => {
  15.   console.log(`父组件方法被调用,获得子组件传值：${val}`)
  16. }
  17. </script>
  19. //子组件
  21. <template>
  22.     <div>
  23.         <button @click="getParentFun">调用父组件方法</button>
  24.     </div>
  25. </template>
  26. <script setup>
  27. import { useAttrs } from "vue";
  29. const attrs = useAttrs()
  30. //获取父组件方法和事件
  31. console.log(attrs) //Proxy {"msg1": "子组件msg1","msg2": "子组件msg2"}
  32. const getParentFun = () => {
  33.     //调用父组件方法
  34.     attrs.onParentFun('我是子组件数据')
  35. }
  36. </script>

注意

Vue3中使用attrs调用父组件方法时，方法前需要加上on；如parentFun->onParentFun

provide/inject

provide：是一个对象，或者是一个返回对象的函数。里面包含要给子孙后代属性

inject：一个字符串数组，或者是一个对象。获取父组件或更高层次的组件provide的值，既在任何后代组件都可以通过inject获得

  • 选项式API

  2. //父组件
  3. <script>
  4. import Child from './Child'
  5. export default {
  6.   components: {
  7.     Child
  8.   },
  9.   data() {
  10.     return {
  11.       msg1: '子组件msg1',
  12.       msg2: '子组件msg2'
  13.     }
  14.   },
  15.   provide() {
  16.     return {
  17.       msg1: this.msg1,
  18.       msg2: this.msg2
  19.     }
  20.   }
  21. }
  22. </script>
  24. //子组件
  26. <script>
  27. export default {
  28.   inject:['msg1','msg2'],
  29.   created(){
  30.     //获取高层级提供的属性
  31.     console.log(this.msg1) //子组件msg1
  32.     console.log(this.msg2) //子组件msg2
  33.   }
  34. }
  35. </script>
  • 组合式API

  2. //父组件
  4. <script>
  5. import Child from './Child'
  6. import { ref, defineComponent,provide } from "vue";
  7. export default defineComponent({
  8.   components:{
  9.     Child
  10.   },
  11.   setup() {
  12.     const msg1 = ref('子组件msg1')
  13.     const msg2 = ref('子组件msg2')
  14.     provide("msg1", msg1)
  15.     provide("msg2", msg2)
  16.     return {
  18.     }
  19.   },
  20. });
  21. </script>
  23. //子组件
  25. <template>
  26.     <div>
  27.         <button @click="getParentFun">调用父组件方法</button>
  28.     </div>
  29. </template>
  30. <script>
  31. import { inject, defineComponent } from "vue";
  32. export default defineComponent({
  33.     setup() {
  34.         console.log(inject('msg1').value) //子组件msg1
  35.         console.log(inject('msg2').value) //子组件msg2
  36.     },
  37. });
  38. </script>
  • setup语法糖

  2. //父组件
  3. <script setup>
  4. import Child from './Child'
  5. import { ref,provide } from "vue";
  6. const msg1 = ref('子组件msg1')
  7. const msg2 = ref('子组件msg2')
  8. provide("msg1",msg1)
  9. provide("msg2",msg2)
  10. </script>
  12. //子组件
  14. <script setup>
  15. import { inject } from "vue";
  16. console.log(inject('msg1').value) //子组件msg1
  17. console.log(inject('msg2').value) //子组件msg2
  18. </script>

说明

provide/inject一般在深层组件嵌套中使用合适。一般在组件开发中用的居多。

parent/children

$parent: 子组件获取父组件Vue实例，可以获取父组件的属性方法等

$children: 父组件获取子组件Vue实例，是一个数组，是直接儿子的集合，但并不保证子组件的顺序

  • Vue2
  1. import Child from './Child'
  2. export default {
  3.   components: {
  4.     Child
  5.   },
  6.   created(){
  7.     console.log(this.$children) //[Child实例]
  8.     console.log(this.$parent)//父组件实例
  9.   }
  10. }

注意

父组件获取到的$children并不是响应式的

expose&ref

$refs可以直接获取元素属性，同时也可以直接获取子组件实例

  • 选项式API

  2. //父组件
  4. <template>
  5.   <div>
  6.     <Child ref="child" />
  7.   </div>
  8. </template>
  9. <script>
  10. import Child from './Child'
  11. export default {
  12.   components: {
  13.     Child
  14.   },
  15.   mounted(){
  16.     //获取子组件属性
  17.     console.log(this.$refs.child.msg) //子组件元素
  19.     //调用子组件方法
  20.     this.$refs.child.childFun('父组件信息')
  21.   }
  22. }
  23. </script>
  25. //子组件 
  27. <template>
  28.   <div>
  29.     <div></div>
  30.   </div>
  31. </template>
  32. <script>
  33. export default {
  34.   data(){
  35.     return {
  36.       msg:'子组件元素'
  37.     }
  38.   },
  39.   methods:{
  40.     childFun(val){
  41.       console.log(`子组件方法被调用,值${val}`)
  42.     }
  43.   }
  44. }
  45. </script>
  • 组合式API

  2. //父组件
  4. <template>
  5.   <div>
  6.     <Child ref="child" />
  7.   </div>
  8. </template>
  9. <script>
  10. import Child from './Child'
  11. import { ref, defineComponent, onMounted } from "vue";
  12. export default defineComponent({
  13.   components: {
  14.     Child
  15.   },
  17.   setup() {
  18.     const child = ref() //注意命名需要和template中ref对应
  19.     onMounted(() => {
  20.       //获取子组件属性
  21.       console.log(child.value.msg) //子组件元素
  23.       //调用子组件方法
  24.       child.value.childFun('父组件信息')
  25.     })
  26.     return {
  27.       child //必须return出去 否则获取不到实例
  28.     }
  29.   },
  30. });
  31. </script>
  33. //子组件
  35. <template>
  36.     <div>
  37.     </div>
  38. </template>
  39. <script>
  40. import { defineComponent, ref } from "vue";
  41. export default defineComponent({
  42.     setup() {
  43.         const msg = ref('子组件元素')
  44.         const childFun = (val) => {
  45.             console.log(`子组件方法被调用,值${val}`)
  46.         }
  47.         return {
  48.             msg,
  49.             childFun
  50.         }
  51.     },
  52. });
  53. </script>
  • setup语法糖

  2. //父组件
  4. <template>
  5.   <div>
  6.     <Child ref="child" />
  7.   </div>
  8. </template>
  9. <script setup>
  10. import Child from './Child'
  11. import { ref, onMounted } from "vue";
  12. const child = ref() //注意命名需要和template中ref对应
  13. onMounted(() => {
  14.   //获取子组件属性
  15.   console.log(child.value.msg) //子组件元素
  17.   //调用子组件方法
  18.   child.value.childFun('父组件信息')
  19. })
  20. </script>
  22. //子组件
  24. <template>
  25.     <div>
  26.     </div>
  27. </template>
  28. <script setup>
  29. import { ref,defineExpose } from "vue";
  30. const msg = ref('子组件元素')
  31. const childFun = (val) => {
  32.     console.log(`子组件方法被调用,值${val}`)
  33. }
  34. //必须暴露出去父组件才会获取到
  35. defineExpose({
  36.     childFun,
  37.     msg
  38. })
  39. </script>

注意

通过ref获取子组件实例必须在页面挂载完成后才能获取。

在使用setup语法糖时候，子组件必须元素或方法暴露出去父组件才能获取到

EventBus/mitt

兄弟组件通信可以通过一个事件中心EventBus实现，既新建一个Vue实例来进行事件的监听，触发和销毁。

在Vue3中没有了EventBus兄弟组件通信，但是现在有了一个替代的方案mitt.js，原理还是 EventBus

  • 选项式API
  1. //组件1
  2. <template>
  3.   <div>
  4.     <button @click="sendMsg">传值</button>
  5.   </div>
  6. </template>
  7. <script>
  8. import Bus from './bus.js'
  9. export default {
  10.   data(){
  11.     return {
  12.       msg:'子组件元素'
  13.     }
  14.   },
  15.   methods:{
  16.     sendMsg(){
  17.       Bus.$emit('sendMsg','兄弟的值')
  18.     }
  19.   }
  20. }
  21. </script>
  23. //组件2
  25. <template>
  26.   <div>
  27.     组件2
  28.   </div>
  29. </template>
  30. <script>
  31. import Bus from './bus.js'
  32. export default {
  33.   created(){
  34.    Bus.$on('sendMsg',(val)=>{
  35.     console.log(val);//兄弟的值
  36.    })
  37.   }
  38. }
  39. </script>
  41. //bus.js
  43. import Vue from "vue"
  44. export default new Vue()
  • 组合式API

首先安装mitt

  1. npm i mitt -S

然后像Vue2中bus.js一样新建mitt.js文件

mitt.js

  1. import mitt from 'mitt'
  2. const Mitt = mitt()
  3. export default Mitt
  1. //组件1
  2. <template>
  3.      <button @click="sendMsg">传值</button>
  4. </template>
  5. <script>
  6. import { defineComponent } from "vue";
  7. import Mitt from './mitt.js'
  8. export default defineComponent({
  9.     setup() {
  10.         const sendMsg = () => {
  11.             Mitt.emit('sendMsg','兄弟的值')
  12.         }
  13.         return {
  14.            sendMsg
  15.         }
  16.     },
  17. });
  18. </script>
  20. //组件2
  21. <template>
  22.   <div>
  23.     组件2
  24.   </div>
  25. </template>
  26. <script>
  27. import { defineComponent, onUnmounted } from "vue";
  28. import Mitt from './mitt.js'
  29. export default defineComponent({
  30.   setup() {
  31.     const getMsg = (val) => {
  32.       console.log(val);//兄弟的值
  33.     }
  34.     Mitt.on('sendMsg', getMsg)
  35.     onUnmounted(() => {
  36.       //组件销毁 移除监听
  37.       Mitt.off('sendMsg', getMsg)
  38.     })
  40.   },
  41. });
  42. </script>
  • setup语法糖

  2. //组件1
  4. <template>
  5.     <button @click="sendMsg">传值</button>
  6. </template>
  7. <script setup>
  8. import Mitt from './mitt.js'
  9. const sendMsg = () => {
  10.     Mitt.emit('sendMsg', '兄弟的值')
  11. }
  12. </script>
  14. //组件2
  16. <template>
  17.   <div>
  18.     组件2
  19.   </div>
  20. </template>
  21. <script setup>
  22. import { onUnmounted } from "vue";
  23. import Mitt from './mitt.js'
  24. const getMsg = (val) => {
  25.   console.log(val);//兄弟的值
  26. }
  27. Mitt.on('sendMsg', getMsg)
  28. onUnmounted(() => {
  29.   //组件销毁 移除监听
  30.   Mitt.off('sendMsg', getMsg)
  31. })
  32. </script>

盘点Vue2和Vue3的10种组件通信方式(值得收藏)的更多相关文章

  1. vue中8种组件通信方式, 值得收藏!

    vue是数据驱动视图更新的框架, 所以对于vue来说组件间的数据通信非常重要,那么组件之间如何进行数据通信的呢? 首先我们需要知道在vue中组件之间存在什么样的关系, 才更容易理解他们的通信方式, 就 ...

  2. Vue中的8种组件通信方式

    Vue是数据驱动视图更新的框架,所以对于vue来说组件间的数据通信非常重要. 常见使用场景可以分为三类: 父子组件通信: props / $emit $parent / $children provi ...

  3. Vue中组件通信的几种方法（Vue3的7种和Vue2的12种组件通信）

    Vue3组件通信方式: props $emit expose / ref $attrs v-model provide / inject Vuex 使用方法: props 用 props 传数据给子组 ...

  4. vue2升级vue3：Vue Demij打通vue2与vue3壁垒，构建通用组件

    如果你的vue2代码之前是使用vue-class-component 类组件模式写的.选择可以使用 https://github.com/facing-dev/vue-facing-decorator ...

  5. Vue2和Vue3技术整理1 - 入门篇 - 更新完毕

    Vue2 0.前言 首先说明:要直接上手简单得很,看官网熟悉大概有哪些东西.怎么用的,然后简单练一下就可以做出程序来了,最多两天,无论Vue2还是Vue3,就都完全可以了,Vue3就是比Vue2多了一 ...

  6. Vue2和Vue3技术整理3 - 高级篇

    3.高级篇 前言 基础篇链接:https://www.cnblogs.com/xiegongzi/p/15782921.html 组件化开发篇链接:https://www.cnblogs.com/xi ...

  7. vue2升级vue3：vue2 vue-i18n 升级到vue3搭配VueI18n v9

    项目从vue2 升级vue3,VueI18n需要做适当的调整.主要是Vue I18n v8.x 到Vue I18n v9 or later 的变化,其中初始化: 具体可以参看:https://vue- ...

  8. vue2升级vue3指南（二）—— 语法warning&error篇

    本文总结了vue2升级vue3可能会遇到的语法警告和错误,如果想知道怎样升级,可以查看我的上一篇文章:vue2升级vue3指南(一)-- 环境准备和构建篇 Warning 1.deep /deep/和 ...

  9. 使用Enterprise Architecture绘制10种UML画画

    UML绘制10种课程要求UML画画,选Enterprise Architecture作为一个绘图工具,每一个草图必须是网上找教程,我觉得很麻烦,还有一些数字并没有找到详细的教程.在我自己找一个绘图方法 ...

随机推荐

  1. Java概论——JavaSE基础

    Java概论 Java特性和优势 简单性 面向对象 可移植性 高性能:即时编译 分布式:可处理TCP/IP协议的一些东西 动态性:通过反射机制使其具有动态性 多线程:良好的交互性和实时性 安全性:防病 ...

  2. c++ 快速乘

    First 在一些数学题中,两个数相乘运算很多,同时又很容易溢出,如两个 long long 相乘 今天本蒟蒻来总结一下快速乘的两种方法 1:二进制 和快速幂的原理一样,优化一个一个加的算法,复杂度\ ...

  3. NB-IoT无线通信模块与Lora无线通信协议技术分析与前景展望

    物联网的快速发展对无线通信技术提出了更高的要求,专为低带宽.低功耗.远距离.大量连接的物联网应用而设计的LPWAN(low-power Wide-Area Network,低功耗广域网)也快速兴起.物 ...

  4. 打字练习-编程语言关键字系列-java

    小编整理的java关键字,内容如下:abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, ...

  5. 物联网？快来看 Arduino 上云啦

    作者:HelloGitHub-Anthony 这里是 HelloGitHub 推出的讲解开源硬件开发平台 Arduino 的系列教程. 第一篇:Arduino 介绍和开发环境搭建 第二篇:制作温湿度显 ...

  6. CentOS中实现基于Docker部署BI数据分析

    作为一个专业小白,咱啥都不懂. linux不懂,docker不懂. 但是我还想要完成领导下达的任务:在linux中安装docker后部署数据可视化工具.作为一名敬业 的打工人摆烂不可以,躺平不可以,弱 ...

  7. sap 获取设置的打印机参数

    *&---------------------------------------------------------------------* *& Form FRM_SET_PRI ...

  8. 深入理解 happens-before 原则

    在前面的文章中,我们深入了解了 Java 内存模型,知道了 Java 内存模型诞生的意义,以及其要解决的问题.最终我们知道:Java 内存模型就是定义了 8 个基本操作以及 8 个规则,只要遵守这些规 ...

  9. SQL Server数据库 备份A库，然后删除A库，再还原A库，此时数据库一直显示“正在还原”的解决方法

    SQL Server数据库 备份A库,然后删除A库,再还原A库,此时数据库一直显示"正在还原"的解决方法: A库一直显示"正在还原". 在这种状态下,由于未提交 ...

  10. NC14661 简单的数据结构

    NC14661 简单的数据结构 题目 题目描述 栗酱有一天在网上冲浪的时候发现了一道很有意思的数据结构题. 该数据结构形如长条形. 一开始该容器为空,有以下七种操作. 1 a从前面插入元素a 2 从前 ...