我的华为荣耀v8手机忘记密码了，怎么解锁呀？

您好，设置图案解锁时，请根据屏幕提示设置备用数字密码。忘记解锁图案时，可以通过备用数字密码解锁屏幕。如果您不记得备用数字密码，或者您之前设置的就是数字密码

使用手机找回

前提条件是，之前已经在手机上登录了华为云服务，而且开启了“手机找回 ”。

具体方法：1、打开“华为云服务 ”;2、登录;3、开启“手机找回 ”。

如果已经开启了，那下面的就简单了。

1、首先，登录华为云服务然后点击“手机找回 ”。

2、网页上会示意出手机现在所在的位置。点击“远程锁定设备 ”。

3、根据屏幕提示，输入新的解锁密码，点击“确定 ”。

4、在手机上输入新的解锁密码，成功解锁。所以，建议实现登录华为云服务，还要开启“手机找回 ”，有备无患。

方法三、强制恢复出厂设置

在不插USB线的情况下，同时长按音量上键和电源键(大约20秒)，直至手机显示华为Logo，并进入操作界面，选择“恢复出厂设置 ”。

事件是发生在1998年三月左右的台中郊区大坑风动石那边。 某日中午左右一个家族好几个成员都到大坑风动石那边玩耍, 就在过程之中有人拿出V8将家中成员一一的拍摄下来, 回来之後也就不甚在意所以没将所拍摄的带子拿出来看。一直到不久之後当天一同去玩的某先生突然过世了, 就在办丧事的时候有人想起在大坑所拍的带子有拍到往生的那位先生,於是就拿出这卷带子看。 一看之下才发现那天到大坑去玩的家族成员之後, 竟然跟著一名脸色铁青,走路轻飘飘的, 穿著红色衣服的小女孩, 而且那小女孩的双眼始终被一片阴影给遮蔽。但是那天一同去玩的人, 没有一个人想起那天曾经看过这样的一个红衣小女孩。更巧的是影片之中那位往生了的先生在笑的时候, 口中竟然出现类似獠牙的东西, 但是整个影片之中让人感觉最不好的还是那名穿著红色衣服的小女孩。但是之後一直有流言说这卷带子是假的,但反驳理由如下: 第一因为说假的人始终拿不出证据都只用听说之类的话带过第二这卷带子牵涉到一位以往生的先生而没有人会拿往生者开玩笑第三影片拍摄者与其家族也曾亲自接受访问证明不虚第四几乎所有接受访问的法师看了之後都说这不是好东西第五你自己看了就知道第六至於有人说那只是住在那边的人, 这可能是有些山魈魍魉之类会借活人的形象来活动。 总括而言当外表看起来和活人一样, 甚至於可能就是你认识的人, 但是红衣小女孩事实上却是另一个空间的灵体, 更很可能就是那边的魍魉之类的借了个小女孩的形在活动而只是脸上的那股妖气跟那诡异的举动是怎麼样也藏不住的。 yeah按: 另一网友PHU kei提供:我讲个更恐怖的 提供红衣小女孩V8的是受难家属而这卷V8也被报导灵异节目所报导之後这灵异节目受一个人所托 说一定要救救他因为 那个人说他曾见过那个红衣小女孩之後事业开始下滑 运气直直落而背到极点甚至还发生好几次意外险些没命 他顿时觉得他快不久於人世了在他求救无助时 刚好看到这个节目有提到他所看到的女孩 於是他决定提起勇气向这灵异节目求救 而灵异节目的主持人也热心的帮忙他 并且询问他是如何遇到那个小女孩 也放了这卷V8做进一步的确定没想到在开始正要放的同时 那个人说他再也不想看到小女孩的脸 因为他说他看了之後整个人非常难受而主持人也不再强迫他 因此主持人请了当地附近的居民看看这卷V8的小女孩 是否曾有人见过动用了学校以及警察局的关系 已经确定没有V8中的这位小女孩 也就是这位小女孩根本就是一个幽灵在经过重重的考证之下 这位小女孩的确是不乾净的东西 恐怖的是凡看过这卷V8的人没有一个人会觉得心情舒服甚至起鸡皮疙瘩(你看久了就会知道) 身材虽是小孩子但是脸却像个老人精且面无血色 最後主持人请了一个法力十分高强的法师解决这事 但是必须当事人带法师到第一次看到小女孩的现场 当法师到了现场後(场地是一片竹林)奇怪的是来了 原本天气晴朗就在法师刚刚踏入这片竹林时 天气马上转成阴暗正当法师要更进入竹林时 竟然刮起强风而且越刮越强彷佛是红衣小女孩的警告 而法师也不畏威胁地做了一下手势风势竟然停住了 (补充:这位法师是所谓的灵媒藉由神明的附身来办理事务) 之後法师将他收服了并且将它抓了回去到寺庙中 後来将他封到蛋中可是奇怪的是法师竟然说要放了他 而当事人吓的要死说怕那位红一小女孩会再找他索命 但是法师也向他保证说他和那位小女孩也达成协议 (要他不要再害人)何况那位小女孩也被他打伤了 也嚐了些苦头法师似乎有不可告人的秘密 最後以一句不要赶尽杀绝要再给他机会) 之後将蛋壳打开流入河流中 更绝的是蛋黄和蛋白都是黑的很恐怖吧 各位会觉得我为何知道那麼多因为我刚好有看那个灵异节目 而那个灵异节目已全部的时间来拍摄这整个过程 所以我讲的过程都是透过现场的报导所得 最最最後我要说明的是能不看这V8就不要看 如果要看就看一次就好不要常看因为那法师说过 任何灵异的照片或V8都会留有那个不乾净东西的气 对人都是不好的功力更强的鬼魅 可直接透过V8或是照片来直接伤害人 我觉得法师会放了他是因为这个红衣小女孩不是泛泛之辈 算是等级很高修行不差的XX 因此觉得如果这样毁了他实在有点可惜(对红衣小女孩而言) 所以V8能不看最好喽如果他若没有向善的话 搞不好你运气差看了这卷V8他就会找上你喔

1独创的两声道前/后环绕技术，可以用普通立体音箱前后放置形成与51相同的环绕音场，完全达到六音箱相同的效果。

2独特的数码影院音频（SDTS）处理技术，可以把各种非SDTS的音频进行数码处理，从而产生最强大的音频处理输出，支持从2声道到8声道的各种音频输出组合。2声道：①原始立体声②环绕立体声③ProLogic 音箱立体声④前/后环绕声 ⑤环绕耳机。

3独创软件音箱接线技术，只需要一个拖放就可以调整音箱的输出，如把左右进行对换使你用四个音箱时无需受挪动音箱之苦。把鼠标箭头移动到插头的位置上，图标转换成蓝色，就可以通过拖动蓝色插头来移动接线位置达到指定音箱输出的效果了。

4SP/DIF输出技术，支持使用硬件AC-3解码音响系统，令你的家庭影院发挥震撼的效果。

《豪杰超级解霸2001XP》

是在原解霸的功能及技术上有更大提高的更新版本，全面兼容WINDOWS XP，超值赠送《豪杰超级DVD21》。《豪杰超级解霸2001XP》可以完美播放Rm、Mpeg4压缩**，支持Rm、Mpeg4压缩**光盘的自动播放，播放效果更出众；支持奔腾Ⅲ SSE、奔腾4SSE2指令集优化；支持光驱超级变速，保护光驱；更增加数个完美界面，让您的解霸更加个性化。

《豪杰超级DVD21》

又名豪杰超级DVD图像增强版。顾名思义，《豪杰超级DVD21》播放DVD的效果有很大的提高，画面效果更加清晰、平滑。并且全面模拟杜比环绕立体声，影音效果无以伦比；并可以检测计算机的基本信息，影音播放信息一目了然；直接自由编辑DVD字幕的字体、颜色、大小、位置，首家支持鼠标拖放DVD字幕；并可根据能否移动字幕鉴别真假DVD影碟。

《豪杰超级DVD21》

采用豪杰多项独创技术。独创运动图像自动跟踪补偿技术，有效消除运动图像细微抖动；独创影像细节保存技术，避免影像细节损失；独创斜向图像处理技术，有效消除斜向图像锯齿毛刺；独创图像色彩保真技术，防止画面渗色、失真、模糊，影像效果更逼真、清晰。

《豪2001XP》提供多种音视频转换工具

支持AⅥ、MPEG和GIF转换，MPEG文件合并，MPEG4文件制作，；自由截取单幅画面、多幅连续画面或**片段。更可以制作自己的**原声带！具体方法如下：先在播放的视频上截取自己喜欢的片段，保存为MPG文件，再用音频工具中的“MP3格式转换”工具来把这段视频的音乐录制下来，这样就可以制作自己的**原声带了。

打开、安装、选择。

1、将包装盒内附带的两块球面镜以及鼻子护垫安装到包装盒上面；

2、安装好球面镜和鼻子护垫后，掀起包装盒另一侧的盖板，便直接变成了一个VR眼镜。

3、打开荣耀V8的视频APP的VR频道，然后选择想观看的视频，将手机放入眼镜中就可以享受前所未有的观影体验啦！V8盒子app是一款适配极强的游戏辅助虚拟机，多悬浮窗操作，万物悬浮，大小由心，还有自带ROOT、息屏挂机以及自定义屏幕分辨率等等功能。

手机芯片组及(数据线)接口定义大全

MOTO A925尾插通用接口定义：1-地, 6-供电, 4-D+, 5-D－

V3尾插通用机型接口定义：1―地、5-供电、3-D+、4-D－）

V680,V730: TX-3, RX-4, 地-5

V998定义：9-GND, 11-UPLINK, 12-DOWNLINK, 13-DSCEN(5V), 14-EXT B+

MOTO A768: SC29301,320W18,62147CV; 电源5188450 43A56; PXA262B1, HYE25L25616,040KAD1J, MD4832-d512; 功放k407e051b; BLUETOOTH

给你个地址 你自己找吧~~

http://wwwelecfanscom/article/88/196/2009/20091214133746html

这次给大家带来JS数组sort方法如何使用，JS数组sort方法使用的注意事项有哪些，下面就是实战案例，一起来看一下。

算法课上，我们会接触很多种排序算法，什么冒泡排序、选择排序、快速排序、堆排序等等。那么javascript的sort方法采用哪种排序算法呢？要搞清楚这个问题，呃，直接看v8源代码好了。v8中对Arraysort的实现是采用javascript完成的，粗看下来，使用了快速排序算法，但明显比我们熟悉的快速排序要复杂。那么到底复杂在什么地方？为什么要搞这么复杂？这是我们今天要探讨的问题。

快速排序算法

快速排序算法之所以被称为快速排序算法，是因为它能达到最佳和平均时间复杂度均为O(nlogn)，是一种应用非常广泛的排序算法。它的原理并不复杂，先找出一个基准元素（pivot，任意元素均可），然后让所有元素跟基准元素比较，比基准元素小的，放到一个集合中，其他的放到另一个集合中；再对这两个集合执行快速排序，最终得到完全排序好的序列。

所以快速排序的核心是不断把原数组做切割，切割成小数组后再对小数组进行相同的处理，这是一种典型的分治的算法设计思路。实现一个简单的快速排序算法并不困难。我们不妨试一下：

function QuickSort(arr, func) {

if (!arr || !arrlength) return [];

if (arrlength === 1) return arr;

var pivot = arr[0];

var smallSet = [];

var bigSet = [];

for (var i = 1; i < arrlength; i++) {

if (func(arr[i], pivot) < 0) {

smallSetpush(arr[i]);

} else {

bigSetpush(arr[i]);

}

}

return QuickSort(smallSet, func)concat([pivot])concat(QuickSort(bigSet, func));

}这是一个非常基础的实现，选取数组的第一项作为基准元素。

原地（in-place）排序

我们可以注意到，上面的算法中，我们其实是创建了一个新的数组作为计算结果，从空间使用的角度看是不经济的。javascript的快速排序算法中并没有像上面的代码那样创建一个新的数组，而是在原数组的基础上，通过交换元素位置实现排序。所以，类似于push、pop、splice这几个方法，sort方法也是会修改原数组对象的！

我们前面说过，快速排序的核心在于切割数组。那么如果只是在原数组上交换元素，怎么做到切割数组呢？很简单，我们并不需要真的把数组切割出来，只需要记住每个部分起止的索引号。举个例子，假设有一个数组[12, 4, 9, 2, 18, 25]，选取第一项12为基准元素，那么按照原始的快速排序算法，会把这个数组切割成两个小数组：[4, 9, 2], 12, [18, 25]。但是我们同样可以不切割，先通过比较、交换元素，将原数组修改成[4, 9, 2, 12, 18, 25]，再根据基准元素12的位置，认为0~2号元素是一组，4~5号元素是一组，为了表述方便，我这里将比基准元素小的元素组成的分区叫小数分区，另一个分区叫大数分区。这很像电脑硬盘的分区，并不是真的把硬盘分成了C盘、D盘，而是记录下一些起止位置，在逻辑上分成了若干个分区。类似的，在快速排序算法中，我们也把这个过程叫做分区（partition）。所以相应的，我也要修改一下之前的说法了，快速排序算法的核心是分区。

说了这么多，还是实现一个带分区的快速排序吧：

function swap(arr, from, to) {

if (from == to) return;

var temp = arr[from];

arr[from] = arr[to];

arr[to] = temp;

}

function QuickSortWithPartition(arr, func, from, to) {

if (!arr || !arrlength) return [];

if (arrlength === 1) return arr;

from = from || 0;

to = to || arrlength - 1;

var pivot = arr[from];

var smallIndex = from;

var bigIndex = from + 1;

for (; bigIndex <= to; bigIndex++) {

if (func(arr[bigIndex], pivot) < 0) {

smallIndex++;

swap(arr, smallIndex, bigIndex);

}

}

swap(arr, smallIndex, from);

QuickSortWithPartition(arr, func, from, smallIndex - 1);

QuickSortWithPartition(arr, func, smallIndex + 1, to);

return arr;

}看起来代码长了很多，不过并不算复杂。首先由于涉及到数组元素交换，所以先实现一个swap方法来处理元素交换。快速排序算法中，增加了两个参数，from和to，分别表示当前要处理这个数组的哪个部分，from是起始索引，to是终止索引；如果这两个参数缺失，则表示处理整个数组。

同样的，我用最简单的方式选取基准元素，即所要处理分区的第一个元素。然后我定义了smallIndex和bigIndex两个变量，分别表示的是左侧小数分区的终止索引和右侧大数分区的终止索引。什么意思？就是说从第一个元素（基准元素）到第smallIndex个元素间的所有元素都比基准元素小，从第smallIndex + 1到第bigIndex个元素都比基准元素大。一开始没有比较时，很显然这两部分分区都是空的，而比较的过程很简单，直接是bigIndex向右移，一直移到分区尾部。每当bigIndex增加1，我们会进行一次判断，看看这个位置上的元素是不是比基准元素大，如果大的话，不用做处理，它已经处于大数分区了；但如果比基准元素小，就需要进行一次交换。怎么交换呢？首先将smallIndex增加1，意味着小数分区增加了一个元素，但此时smallIndex位置的元素很明显是一个大数（这个说法其实不对，如果之前大数分区里面没有元素，此时smallIndex和bigIndex相等，但对交换没有影响），而在bigIndex位置的元素是一个小数，所以只要把这两个位置的元素交换一下就好了。

最后可别忘了一开始的起始元素，它的位置并不正确，不过只要将它和smallIndex位置的元素交换位置就可以了。同时我们得到了对应的小数分区[fromsmallIndex - 1]和大数分区[smallIndex + 1to]。再对这两个分区递归排序即可。

分区过程的优化

上面的分区过程（仅仅）还是有一定的优化空间的，因为上面的分区过程中，大数分区和小数分区都是从左向右增长，其实我们可以考虑从两侧向中间遍历，这样能有效地减少交换元素的次数。举个例子，例如我们有一个数组[2, 1, 3, 1, 3, 1, 3]，采用上面的分区算法，一共碰到三次比基准元素小的情况，所以会发生三次交换；而如果我们换个思路，把从右往左找到小于基准和元素，和从左往右找到大于基准的元素交换，这个数组只需要交换一次就可以了，即把第一个3和最后一个1交换。

我们也来尝试写一下实现：

function QuickSortWithPartitionOp(arr, func, from, to) {

if (!arr || !arrlength) return [];

from = from || 0;

to = to || arrlength - 1;

if (from >= to - 1) return arr;

var pivot = arr[from];

var smallEnd = from + 1;

var bigBegin = to;

while (smallEnd < bigBegin) {

while (func(arr[bigBegin], pivot) > 0 && smallEnd < bigBegin) {

bigBegin--;

}

while (func(arr[smallEnd], pivot) < 0 && smallEnd < bigBegin) {

smallEnd++;

}

if (smallEnd < bigBegin) {

swap(arr, smallEnd, bigBegin);

}

}

swap(arr, smallEnd, from);

QuickSortWithPartitionOp(arr, func, from, smallEnd - 1);

QuickSortWithPartitionOp(arr, func, smallEnd + 1, to);

return arr;

}分区与性能

前面我们说过，快速排序算法平均时间复杂度是O(nlogn)，但它的最差情况下时间复杂度会衰弱到O(n2)。而性能好坏的关键就在于分区是否合理。如果每次都能平均分成相等的两个分区，那么只需要logn层迭代；而如果每次分区都不合理，总有一个分区是空的，那么需要n层迭代，这是性能最差的场景。

那么性能最差的场景会出现吗？对于一个内容随机的数组而言，不太可能出现最差情况。但我们平时在编程时，处理的数组往往并不是内容随机的，而是很可能预先有一定顺序。设想一下，如果一个数组已经排好序了，由于之前的算法中，我们都是采用第一个元素作为基准元素，那么必然会出现每次分区都会有一个分区为空。这种情况当然需要避免。

一种很容易的解决方法是不要选取固定位置的元素作为基准元素，而是随机从数组里挑出一个元素作为基准元素。这个方法很有效，极大概率地避免了最差情况。这种处理思想很简单，我就不另外写代码了。

然而极大概率地避免最差情况并不等于避免最差情况，特别是对于数组很大的时候，更要求我们在选取基准元素的时候要更谨慎些。

三数取中（median-of-three）

基准元素应当精心挑选，而挑选基准元素的一种方法为三数取中，即挑选基准元素时，先把第一个元素、最后一个元素和中间一个元素挑出来，这三个元素中大小在中间的那个元素就被认为是基准元素。

简单实现一下获取基准元素的方法：

function getPivot(arr, func, from, to) {

var middle = (from + to) >> 1;

var i0 = arr[from];

var i1 = arr[to];

var i2 = arr[middle];

var temp;

if (func(i0, i1) > 0) {

temp = i0;

i0 = i1;

i1 = temp;

}

if (func(i0, i2) > 0) {

arr[middle] = i0;

arr[from] = i2;

arr[to] = i1;

return i0;

} else {

arr[from] = i0;

if (func(i1, i2) > 0) {

arr[middle] = i1;

arr[to] = i2;

return i1;

} else {

arr[middle] = i2;

arr[to] = i1;

return i2;

}

}

}这个例子里我完全没管基准元素的位置，一是降低复杂度，另一个原因是下面讨论重复元素处理时，基准元素的位置没什么意义。不过我把最小的值赋给了第一个元素，最大的值赋给了第二个元素，后面处理重复元素时会有帮助。

当然，仅仅是三数取中获得的基准元素，也不见得是可靠的。于是有一些其他的取中值的方法出现。有几种比较典型的手段，一种是平均间隔取一个元素，多个元素取中位数（即多取几个，增加可靠性）；一种是对三数取中进行递归运算，先把大数组平均分成三块，对每一块进行三数取中，会得到三个中值，再对这三个中值取中位数。

不过查阅v8的源代码，发现v8的基准元素选取更为复杂。如果数组长度不超过1000，则进行基本的三数取中；如果数组长度超过1000，那么v8的处理是除去首尾的元素，对剩下的元素每隔200左右（200~215，并不固定）挑出一个元素。对这些元素排序，找出中间的那个，并用这个元素跟原数组首尾两个元素一起进行三数取中。这段代码我就不写了。

针对重复元素的处理

到目前为止，我们在处理元素比较的时候比较随意，并没有太多地考虑元素相等的问题。但实际上我们做了这么多性能优化，对于重复元素引起的性能问题并没有涉及到。重复元素会带来什么问题呢？设想一下，一个数组里如果所有元素都相等，基准元素不管怎么选都是一样的。那么在分区的时候，必然出现除基准元素外的其他元素都被分到一起去了，进入最差性能的case。

那么对于重复元素应该怎么处理呢？从性能的角度，如果发现一个元素与基准元素相同，那么它应该被记录下来，避免后续再进行不必要的比较。所以还是得改分区的代码。

function QuickSortWithPartitionDump(arr, func, from, to) {

if (!arr || !arrlength) return [];

from = from || 0;

to = to || arrlength - 1;

if (from >= to - 1) return arr;

var pivot = getPivot(arr, func, from, to);

var smallEnd = from;

var bigBegin = to;

for (var i = smallEnd + 1; i < bigBegin; i++) {

var order = func(arr[i], pivot);

if (order < 0) {

smallEnd++;

swap(arr, i, smallEnd);

} else if (order > 0) {

while (bigBegin > i && order > 0) {

bigBegin--;

order = func(arr[bigBegin], pivot);

}

if (bigBegin == i) break;

swap(arr, i, bigBegin);

if (order < 0) {

swap(arr, i, smallEnd);

smallEnd++;

}

}

}

QuickSortWithPartitionDump(arr, func, from, smallEnd);

QuickSortWithPartitionDump(arr, func, bigBegin, to);

return arr;

}简单解释一下这段代码，上文已经说过，在getPivot方法中，我将比基准小的元素放到第一位，把比基准大的元素放到最后一位。定义三个变量smallEnd、bigBegin、i，从from到smallEnd之间的元素都比基准元素小，从smallEnd到i之间的元素都和基准元素一样大，从i到bigBegin之间的元素都是还没有比较的，从bigBegin到to之间的元素都比基准元素大。了解这个关系就好理解这段代码了。遍历从smallEnd + 1到bigBegin之间的元素：

如果这个元素小于基准，那么smallEnd增加1，这时smallEnd位置的元素是等于基准元素的（或者此时smallEnd与i相等），交换smallEnd与i处的元素就可以了。

如果这个元素大于基准，相对比较复杂一点。此时让bigBegin减小1，检查大数分区前面一个元素是不是大于基准，如果大于基准，重复此步骤，不断让bigBegin减小1，直到找到不比基准大的元素（如果这个过程中，发现bigBegin与i相等，则中止遍历，说明分区结束）。找到这个不比基准大小元素时需要区分是不是比基准小。如果比基准小，需要做两步交换，先将i位置的大数和bigBegin位置的小数交换，这时跟第一种case同时，smallEnd增加1，并且将i位置的小数和smallEnd位置的元素交换。如果和基准相等，则只需要将i位置的大数和bigBegin位置的小数交换。

如果这个元素与基准相等，什么也不用做。

小数组优化

对于小数组（小于16项或10项。v8认为10项以下的是小数组。），可能使用快速排序的速度还不如平均复杂度更高的选择排序。所以对于小数组，可以使用选择排序法要提高性能，减少递归深度。

function insertionSort(a, func, from, to) {

for (var i = from + 1; i < to; i++) {

var element = a[i];

for (var j = i - 1; j >= from; j--) {

var tmp = a[j];

if (func(tmp, element) > 0) {

a[j + 1] = tmp;

} else {

break;

}

}

a[j + 1] = element;

}

}v8引擎没有做的优化

由于快速排序的不稳定性（少数情况下性能差，前文已经详细描述过），David Musser于1997设计了内省排序法（Introsort）。这个算法在快速排序的基础上，监控递归的深度。一旦长度为n的数组经过了logn层递归（快速排序算法最佳情况下的递归层数）还没有结束的话，就认为这次快速排序的效率可能不理想，转而将剩余部分换用其他排序算法，通常使用堆排序算法（Heapsort，最差时间复杂度和最优时间复杂度均为nlogn）。

v8引擎额外做的优化

快速排序递归很深，如果递归太深的话，很可以出现“爆栈”，我们应该尽可能避免这种情况。上面提到的对小数组采用选择排序算法，以及采用内省排序算法都可以减少递归深度。不过v8引擎中，做了一些不太常见的优化，每次我们分区后，v8引擎会选择元素少的分区进行递归，而将元素多的分区直接通过循环处理，无疑这样的处理大大减小了递归深度。我大致把v8这种处理的过程写一下：

function quickSort(arr, from, to){

while(true){

// 排序分区过程省略

//

if (to - bigBegin < smallEnd - from) {

quickSort(a, bigBegin, to);

to = smallEnd;

} else {

quickSort(a, from, smallEnd);

from = bigBegin;

}

}

}不得不说是一个很巧妙的实现。

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

推荐阅读：

如何操作Vue去除路径中的＃号

如何使用vue中实现点击空白处隐藏div实现