Home > Article > Web Front-end > vuejs method of calling components
vuejs method of calling components
- 藏色散人Original
- 2021-11-01 11:16:583426browse
Vuejs method of calling components: 1. Explicitly control the display and hiding of components through v-model or .sync; 2. Call through js code; 3. Call through Vue instructions.
The operating environment of this article: windows7 system, vue2.9.6 version, DELL G3 computer.
Three calling methods of Vue components
I encountered some problems recently when writing fj-service-system. That is, for some of my components, such as Dialog and Message, should I introduce third-party component libraries, such as element-ui, or should I implement one myself? Although they have the function of introducing on demand, the overall style does not match my overall system. So you can consider implementing these simple components manually yourself.
Usually when we read some articles about Vue, what we can see usually talks about Vue single-file component development pages. There are relatively few articles on single component development. When I was working on the fj-service-system project, I found that single component development is also very interesting. You can write it down and record it. Because what I wrote is not a UI framework, it is just a record. There is no github repository, so let’s take a look at the code.
- v-model or .sync explicitly controls the display and hiding of components
- Call through js code
- Call through Vue instructions
When writing components, many writing methods and inspirations come from element-ui, thank you.
Dialog
I am used to calling this thing a dialog box. In fact, it is also called a modal (pop-up window) component. In fact, a small window pops up on the page, and the content in this small window can be customized. It can usually be used as a dialog box for login functions.
This kind of component is very suitable for explicitly controlling the appearance and disappearance through v-model or .sync. It can be written directly on the page and then controlled through data - this is also the component that best conforms to Vue's design ideas.
For this we can write a component called Dialog.vue
<template>
<div class="dialog">
<div class="dialog__wrapper" v-if="visble" @clcik="closeModal">
<div class="dialog">
<div class="dialog__header">
<div class="dialog__title">{{ title }}</div>
</div>
<div class="dialog__body">
<slot></slot>
</div>
<div class="dialog__footer">
<slot name="footer"></slot>
</div>
</div>
</div>
<div class="modal" v-show="visible"></div>
</div></template><script>
export default { name: 'dialog', props: { title: String, visible: { type: Boolean, default: false
}
}, methods: { close() { this.$emit('update:visible', false) // 传递关闭事件
}, closeModal(e) { if (this.visible) { document.querySelector('.dialog').contains(e.target) ? '' : this.close(); // 判断点击的落点在不在dialog对话框内，如果在对话框外就调用this.close()方法关闭对话框
}
}
}
}</script>We won’t write CSS or anything else, it has little to do with the component itself. However, it is worth noting that the above dialog__wrapper class is also full-screen and transparent. It is mainly used to obtain click events and lock the click position. It uses the Node.contains() method of the DOM to determine whether the click position is the dialog itself. If If you click outside the dialog, such as a translucent modal layer, a close event will be dispatched to close the dialog.
When we want to call it externally, we can call it as follows:
<template>
<div class="xxx">
<dialog :visible.sync="visible"></dialog>
<button @click="openDialog"></button>
</div></template><script>
import Dialog from 'Dialog'
export default { components: {
Dialog
}, data() { return { visible: false
}
}, methods: { openDialog() { this.visible = true // 通过data显式控制dialog
}
}
}</script>To make the Dialog open and close more attractive, you can try adding 300ff3b250bc578ac201dd5fb34a00046087faffb1c3f26530d25a6b190c2f81 When components are combined with transition effects, a simple transition effect will also look great.
Notice
This component is similar to element-ui's message (message prompt). What attracts me the most is that it is not called by explicitly writing the HTML structure of the component in the page through v-model, but by using methods such as this.$message() in js. called. Although this method goes against Vue's data-driven thinking. But I have to say that it is really convenient in some situations.
For components like Notice, you only need to prompt a few words at a time to give users a simple message. The information prompted may be varied, and there may even be superimposed prompts. If you call it through the first method, you have to write the html structure in advance. This is undoubtedly a troublesome approach, and it is impossible to predict how many message boxes there will be. If you call it through js method, you only need to consider the text and type called in different situations.
The previous approach was to write a Vue file, then introduce the page through the components attribute, and explicitly write the tag call. So how to call the component through js method?
The key here is Vue’s extend method.
The document does not give details about how extend can be used in this way. It is just explained as a Vue component constructor that needs to be manually mounted.
By viewing the source code of element-ui, we can understand how to implement the above functions.
First of all, create a Notice.vue file
<template>
<div class="notice">
<div class="content">
{{ content }} </div>
</div></template><script>
export default { name: 'notice',
data () { return { visible: false, content: '', duration: 3000
}
}, methods: { setTimer() { setTimeout(() => { this.close() // 3000ms之后调用关闭方法
}, this.duration)
}, close() { this.visible = false
setTimeout(() => { this.$destroy(true) this.$el.parentNode.removeChild(this.$el) // 从DOM里将这个组件移除
}, 500)
}
}, mounted() { this.setTimer() // 挂载的时候就开始计时，3000ms后消失
}
}</script>What is written above is not much different from an ordinary single-file Vue component. But the difference is that there are no props, so how to control the visibility of this component externally?
So a js file is needed to take over this component and call the extend method. You can create an index.js file in the same directory.
import Vue from 'vue'const NoticeConstructor = Vue.extend(require('./Notice.vue')) // 直接将Vue组件作为Vue.extend的参数let nId = 1const Notice = (content) => { let id = 'notice-' + nId++ const NoticeInstance = new NoticeConstructor({ data: { content: content
}
}) // 实例化一个带有content内容的Notice
NoticeInstance.id = id
NoticeInstance.vm = NoticeInstance.$mount() // 挂载但是并未插入dom，是一个完整的Vue实例
NoticeInstance.vm.visible = true
NoticeInstance.dom = NoticeInstance.vm.$el document.body.appendChild(NoticeInstance.dom) // 将dom插入body
NoticeInstance.dom.style.zIndex = nId + 1001 // 后插入的Notice组件z-index加一，保证能盖在之前的上面
return NoticeInstance.vm
}export default { install: Vue => {
Vue.prototype.$notice = Notice // 将Notice组件暴露出去，并挂载在Vue的prototype上
}
}In this file we can see that through NoticeConstructor we can control various properties of a component through js. Finally, we register it into the Vue prototype, so that we can use the this.$notice() method inside the page, and we can easily call this component to write simple notification effects.
Of course don’t forget that this is equivalent to a Vue plug-in, so you need to call the Vue.use() method in the main js:
// main.js // ... import Notice from 'notice/index.js' Vue.use(Notice) // ...
Loading
在看element-ui的时候，我也发现了一个很有意思的组件，是Loading，用于给一些需要加载数据等待的组件套上一层加载中的样式的。这个loading的调用方式，最方便的就是通过v-loading这个指令，通过赋值的true/false来控制Loading层的显隐。这样的调用方法当然也是很方便的。而且可以选择整个页面Loading或者某个组件Loading。这样的开发体验自然是很好的。
其实跟Notice的思路差不多，不过因为涉及到directive，所以在逻辑上会相对复杂一点。
平时如果不涉及Vue的directive的开发，可能是不会接触到modifiers、binding等概念。参考文档
简单说下，形如:v-loading.fullscreen="true"这句话，v-loading就是directive，fullscreen就是它的modifier，true就是binding的value值。所以，就是通过这样简单的一句话实现全屏的loading效果，并且当没有fullscreen修饰符的时候就是对拥有该指令的元素进行loading效果。组件通过binding的value值来控制loading的开启和关闭。（类似于v-model的效果）
其实loading也是一个实际的DOM节点，只不过要把它做成一个方便的指令还不是特别容易。
首先我们需要写一下loading的Vue组件。新建一个Loading.vue文件
<template>
<transition
name="loading"
@after-leave="handleAfterLeave">
<div
v-show="visible"
class="loading-mask"
:class={'fullscreen': fullscreen}>
<div class="loading">
... </div>
<div class="loading-text" v-if="text">
{{ text }} </div>
</div>
</transition></template><script>export default { name: 'loading',
data () { return { visible: true, fullscreen: true, text: null
}
}, methods: { handleAfterLeave() { this.$emit('after-leave');
}
}
}</script><style>.loading-mask{
position: absolute; // 非全屏模式下，position是absolute
z-index: 10000;
background-color: rgba(255,235,215, .8);
margin: 0;
top: 0;
right: 0;
bottom: 0;
left: 0;
transition: opacity .3s;
}
.loading-mask.fullscreen{
position: fixed; // 全屏模式下，position是fixed
}
// ...</style>Loading关键是实现两个效果：
1.全屏loading，此时可以通过插入body下，然后将Loading的position改为fixed，插入body实现。
2.对所在的元素进行loading，此时需要对当前这个元素的的position修改：如果不是absolute的话，就将其修改为relatvie，并插入当前元素下。此时Loading的position就会相对于当前元素进行绝对定位了。
所以在当前目录下创建一个index.js的文件，用来声明我们的directive的逻辑。
import Vue from 'vue'const LoadingConstructor = Vue.extend(require('./Loading.vue'))export default { install: Vue => {
Vue.directive('loading', { // 指令的关键
bind: (el, binding) => { const loading = new LoadingConstructor({ // 实例化一个loading
el: document.createElement('div'), data: { text: el.getAttribute('loading-text'), // 通过loading-text属性获取loading的文字
fullscreen: !!binding.modifiers.fullscreen
}
})
el.instance = loading; // el.instance是个Vue实例
el.loading = loading.$el; // el.loading的DOM元素是loading.$el
el.loadingStyle = {};
toggleLoading(el, binding);
}, update: (el, binding) => {
el.instance.setText(el.getAttribute('loading-text')) if(binding.oldValue !== binding.value) {
toggleLoading(el, binding)
}
}, unbind: (el, binding) => { // 解绑
if(el.domInserted) { if(binding.modifiers.fullscreen) { document.body.removeChild(el.loading);
}else {
el.loading &&
el.loading.parentNode &&
el.loading.parentNode.removeChild(el.loading);
}
}
}
}) const toggleLoading = (el, binding) => { // 用于控制Loading的出现与消失
if(binding.value) {
Vue.nextTick(() => { if (binding.modifiers.fullscreen) { // 如果是全屏
el.originalPosition = document.body.style.position;
el.originalOverflow = document.body.style.overflow;
insertDom(document.body, el, binding); // 插入dom
} else {
el.originalPosition = el.style.position;
insertDom(el, el, binding); // 如果非全屏，插入元素自身
}
})
} else { if (el.domVisible) {
el.instance.$on('after-leave', () => {
el.domVisible = false; if (binding.modifiers.fullscreen && el.originalOverflow !== 'hidden') { document.body.style.overflow = el.originalOverflow;
} if (binding.modifiers.fullscreen) { document.body.style.position = el.originalPosition;
} else {
el.style.position = el.originalPosition;
}
});
el.instance.visible = false;
}
}
} const insertDom = (parent, el, binding) => { // 插入dom的逻辑
if(!el.domVisible) { Object.keys(el.loadingStyle).forEach(property => {
el.loading.style[property] = el.loadingStyle[property];
}); if(el.originalPosition !== 'absolute') {
parent.style.position = 'relative'
} if (binding.modifiers.fullscreen) {
parent.style.overflow = 'hidden'
}
el.domVisible = true;
parent.appendChild(el.loading) // 插入的是el.loading而不是el本身
Vue.nextTick(() => {
el.instance.visible = true;
});
el.domInserted = true;
}
}
}
}同样，写完整个逻辑，我们需要将其注册到项目里的Vue下：
// main.js // ... import Loading from 'loading/index.js' Vue.use(Loading) // ...
至此我们已经可以使用形如
adb2c97e42ba7ef7e89c2223cc327580
这样的方式来实现调用一个loading组件了。
总结
在用Vue写我们的项目的时候，不管是写页面还是写形如这样的功能型组件，其实都是一件很有意思的事情。本文介绍的三种调用组件的方式，也是根据实际情况出发而实际操作、实现的。不同的组件通过不同的方式去调用，方便了开发人员，也能更好地对代码进行维护。当然也许还有其他的方式，我并没有了解，也欢迎大家在评论里指出！
最后再次感谢element-ui的源码给予的极大启发。
推荐：《最新的5个vue.js视频教程精选》
The above is the detailed content of vuejs method of calling components. For more information, please follow other related articles on the PHP Chinese website!