Home > Article > Web Front-end > Detailed explanation of Vue page skeleton screen injection steps

Detailed explanation of Vue page skeleton screen injection steps

php中世界最好的语言Original: 2018-05-21 15:28:273052browse

This time I will bring you a detailed explanation of the Vue page skeleton screen injection steps. What are the precautions for Vue page skeleton screen injection? The following is a practical case, let's take a look.

As a front-end developer who has the closest contact with users, user experience is the most noteworthy issue. Regarding the display of page loading status, there are two main mainstream methods: loading graph and progress bar. In addition, more and more apps use the "skeleton screen" method to display unloaded content, giving users a brand new experience. As SPA becomes increasingly popular in the front-end world, the problem of first-screen loading is also plaguing developers. So is there a way to use skeleton screens in SPA? This is what this article will explore.

The relevant code of the article has been synchronized to Github, welcome to check~

1. What is a skeleton screen

In simple terms , the skeleton screen uses some graphics as placeholders when the page content is not loaded, and then replaces it after the content is loaded.

This technology is widely used in some content-based APPs and web pages. Next, we will take a simple Vue project as an example to explore how to use Vue-based Implement skeleton screen in SPA project.

2. Analyze the content loading process of the Vue page

For the sake of simplicity, we use vue-cli with the webpack-simple template to create a new Project:

vue init webpack-simple vue-skeleton

At this time we got a most basic Vue project:

├── package.json
├── src
│ ├── App.vue
│ ├── assets
│ └── main.js
├── index.html
└── webpack.conf.js

Installation completed After relying on it, you can run the project through

npm run dev . However, before running the project, let's first take a look at what is written in the entry html file.

<!DOCTYPE html>
<html lang="en">
 <head>
 <meta charset="utf-8">
 <title>vue-skeleton</title>
 </head>
 <body>
 <p id="app"></p>
 <script src="/dist/build.js"></script>
 </body>
</html>

As you can see, there is only one p#app in

in the DOM. When js is executed, this p#app will be completely replaced. Therefore, we can Let’s do an experiment and add some content to this p:

<p id="app">
 <p>Hello skeleton</p>
 <p>Hello skeleton</p>
 <p>Hello skeleton</p>
</p>

Open chrome’s developer tools, find the throttle function in Network, adjust the network speed to “Slow 3G”, refresh the page, and you will see The page first displays three sentences of "Hello skeleton", which will be replaced with the original content after the js is loaded.

Now, we have a very clear idea on how to implement the skeleton screen on the Vue page - just insert the skeleton screen related content directly into p#app .

3. Easy-to-maintain solution

Obviously, it is unscientific to manually write the skeleton screen content in p#app. We need A highly scalable, automated and easy-to-maintain solution. Since it is in a Vue project, we certainly hope that the so-called skeleton screen is also a .vue file, which can be automatically injected into p#app by the tool during construction.

First, we create a new Skeleton.vue file in the /src directory, with the following content:

<template>
 <p class="skeleton page">
 <p class="skeleton-nav"></p>
 <p class="skeleton-swiper"></p>
 <ul class="skeleton-tabs">
 <li v-for="i in 8" class="skeleton-tabs-item"><span></span></li>
 </ul>
 <p class="skeleton-banner"></p>
 <p v-for="i in 6" class="skeleton-productions"></p>
 </p>
</template>
<style>
.skeleton {
 position: relative;
 height: 100%;
 overflow: hidden;
 padding: 15px;
 box-sizing: border-box;
 background: #fff;
}
.skeleton-nav {
 height: 45px;
 background: #eee;
 margin-bottom: 15px;
}
.skeleton-swiper {
 height: 160px;
 background: #eee;
 margin-bottom: 15px;
}
.skeleton-tabs {
 list-style: none;
 padding: 0;
 margin: 0 -15px;
 display: flex;
 flex-wrap: wrap;
}
.skeleton-tabs-item {
 width: 25%;
 height: 55px;
 box-sizing: border-box;
 text-align: center;
 margin-bottom: 15px;
}
.skeleton-tabs-item span {
 display: inline-block;
 width: 55px;
 height: 55px;
 border-radius: 55px;
 background: #eee;
}
.skeleton-banner {
 height: 60px;
 background: #eee;
 margin-bottom: 15px;
}
.skeleton-productions {
 height: 20px;
 margin-bottom: 15px;
 background: #eee;
}
</style>

Next, create a new skeleton.entry.js

Entry file：

import Vue from 'vue'
import Skeleton from './Skeleton.vue'
export default new Vue({
 components: {
 Skeleton
 },
 template: '<skeleton />'
})

After completing the preparation of the skeleton screen, it is the turn of a key plug-in vue-server-renderer. This plug-in is originally used for server-side rendering, but in this example, we mainly use its function to process .vue

files into HTML and CSS strings to complete the injection of the skeleton screen. The process is as follows:

##4. Solution implementation

According to the flow chart, we also need to create a new webpack in the root directory .skeleton.conf.js file is specially used to build skeleton screens.

const path = require('path')
const webpack = require('webpack')
const nodeExternals = require('webpack-node-externals')
const VueSSRServerPlugin = require('vue-server-renderer/server-plugin')
module.exports = {
 target: 'node',
 entry: {
 skeleton: './src/skeleton.js'
 },
 output: {
 path: path.resolve(dirname, './dist'),
 publicPath: '/dist/',
 filename: '[name].js',
 libraryTarget: 'commonjs2'
 },
 module: {
 rules: [
 {
 test: /\.css$/,
 use: [
 'vue-style-loader',
 'css-loader'
 ]
 },
 {
 test: /\.vue$/,
 loader: 'vue-loader'
 }
 ]
 },
 externals: nodeExternals({
 whitelist: /\.css$/
 }),
 resolve: {
 alias: {
 'vue$': 'vue/dist/vue.esm.js'
 },
 extensions: ['*', '.js', '.vue', '.json']
 },
 plugins: [
 new VueSSRServerPlugin({
 filename: 'skeleton.json'
 })
 ]
}

可以看到，该配置文件和普通的配置文件基本完全一致，主要的区别在于其 target: 'node' ，配置了 externals ，以及在 plugins 里面加入了 VueSSRServerPlugin 。在 VueSSRServerPlugin 中，指定了其输出的json文件名。我们可以通过运行下列指令，在 /dist 目录下生成一个 skeleton.json 文件：

webpack --config ./webpack.skeleton.conf.js

这个文件在记载了骨架屏的内容和样式，会提供给 vue-server-renderer 使用。

接下来，在根目录下新建一个 skeleton.js ，该文件即将被用于往 index.html 内插入骨架屏。

const fs = require('fs')
const { resolve } = require('path')
const createBundleRenderer = require('vue-server-renderer').createBundleRenderer
// 读取`skeleton.json`，以`index.html`为模板写入内容
const renderer = createBundleRenderer(resolve(dirname, './dist/skeleton.json'), {
 template: fs.readFileSync(resolve(dirname, './index.html'), 'utf-8')
})
// 把上一步模板完成的内容写入（替换）`index.html`
renderer.renderToString({}, (err, html) => {
 fs.writeFileSync('index.html', html, 'utf-8')
})

注意，作为模板的 html 文件，需要在被写入内容的位置添加占位符，本例子在 p#app 里写入：

<p id="app">
 <!--vue-ssr-outlet-->
</p>

接下来，只要运行 node skeleton.js ，就可以完成骨架屏的注入了。运行效果如下：

<html lang="en">
 <head>
 <meta charset="utf-8">
 <title>vue-skeleton</title>
 <style data-vue-ssr-id="742d88be:0">
.skeleton {
 position: relative;
 height: 100%;
 overflow: hidden;
 padding: 15px;
 box-sizing: border-box;
 background: #fff;
}
.skeleton-nav {
 height: 45px;
 background: #eee;
 margin-bottom: 15px;
}
.skeleton-swiper {
 height: 160px;
 background: #eee;
 margin-bottom: 15px;
}
.skeleton-tabs {
 list-style: none;
 padding: 0;
 margin: 0 -15px;
 display: flex;
 flex-wrap: wrap;
}
.skeleton-tabs-item {
 width: 25%;
 height: 55px;
 box-sizing: border-box;
 text-align: center;
 margin-bottom: 15px;
}
.skeleton-tabs-item span {
 display: inline-block;
 width: 55px;
 height: 55px;
 border-radius: 55px;
 background: #eee;
}
.skeleton-banner {
 height: 60px;
 background: #eee;
 margin-bottom: 15px;
}
.skeleton-productions {
 height: 20px;
 margin-bottom: 15px;
 background: #eee;
}
</style></head>
 <body>
 <p id="app">
 <p data-server-rendered="true" class="skeleton page"><p class="skeleton-nav"></p> <p class="skeleton-swiper"></p> <ul class="skeleton-tabs"><li class="skeleton-tabs-item"><span></span></li><li class="skeleton-tabs-item"><span></span></li><li class="skeleton-tabs-item"><span></span></li><li class="skeleton-tabs-item"><span></span></li><li class="skeleton-tabs-item"><span></span></li><li class="skeleton-tabs-item"><span></span></li><li class="skeleton-tabs-item"><span></span></li><li class="skeleton-tabs-item"><span></span></li></ul> <p class="skeleton-banner"></p> <p class="skeleton-productions"></p><p class="skeleton-productions"></p><p class="skeleton-productions"></p><p class="skeleton-productions"></p><p class="skeleton-productions"></p><p class="skeleton-productions"></p></p>
 </p>
 <script src="/dist/build.js"></script>
 </body>
</html>

可以看到，骨架屏的样式通过标签直接被插入，而骨架屏的内容也被放置在 p#app 之间。当然，我们还可以进一步处理，把这些内容都压缩一下。改写 skeleton.js ，在里面添加 html-minifier ：
...

+ const htmlMinifier = require('html-minifier')
...
renderer.renderToString({}, (err, html) => {
+ html = htmlMinifier.minify(html, {
+ collapseWhitespace: true,
+ minifyCSS: true
+ })
 fs.writeFileSync('index.html', html, 'utf-8')
})

来看看效果：

效果非常不错！至此，Vue页面接入骨架屏已经完全实现了。

如果还有任何更好的实现思路，也欢迎和我探讨，有机会我也会总结基于 React 的骨架屏注入实践，敬请期待！

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

Detailed explanation of Vue page skeleton screen injection steps

Related articles