又到了毕业季，不知不觉毕业已经三年了 🤔

在这三年期间对生活有了很多感悟，俗话说“字节一年，人间三年”，感觉自己又读了两个大学 hh

对这三年做个总结吧，同时也分享下自己在杭州、在大厂的所见所得所感，也希望对你有所帮助~

一、关于我

第一次以这种形式与大家见面，还是自我介绍下吧

希望尽量用简短的文字让你了解我，同时磨平一些行文的信息差

那我们从一个小游戏开始吧

1.1 “生命年轮”游戏

• 以七年为一个节点，写下七年中，每年对自己最重要的事情


• 并分享给朋友，谈谈对这些事件的看法和对自己的影响，从而让彼此更加亲近

1.2 年轮线

成都人，95后，从 2015 年大一到 2022 毕业三年的 7 年

1.3 核心事件

• 2016 年：坚持计算机行业。“软件工程”作为高考最后一个志愿，大一结束时本想转专业，但最后还是坚持下来


• 2017 年：担任街舞协会 会长，举办《HipHop 之夜》晚会，邀请了各大高校协会参与


• 2018 年：大三确认技术方向，开始发力，自学前端


• 2019 年：大四实习，应届去了杭州字节跳动


• 2020 年：重新定义了学习，面向方法论成长


• 2021 年：遵从内心，学会勇敢，想清楚自己真正喜欢和擅长什么


• 2022 年：再见杭州，你好魔都。去上海寻找无限可能

1.4 个人感受

性格成就现在的我

我是那种“玩和学”能够分开的人，学的时候认真学，玩的时候也会认真玩。所以大一、大二严格来说是“玩”过去的，我过的很开心。大三决定不考研后，开始自学专业课，应届能进大厂

方法论很重要

不得不说公司 2 年多的成长能够抵过大学 4 年的学习（没说不重要）。身边结识了一群优秀的人，才慢慢明白，自己学生生涯的思维是不全面的，学习方式是不高效的，由此才开始慢慢调整

选择大于努力

人生面临各种选择，无论是学生时代还是涉足社会。如果大方向是错的，再怎么努力也不会看到好结果

二、城里、城外

那么开始我的分享

苏小姐道：“法国也有这么一句话。不过，不说是鸟笼，说是被围困的城堡，城外的人想冲进去，城里的人想逃出来。鸿渐，是不是？”——《围城》

2.1 小故事

应届拿到几个大厂 offer，拥有不错的年薪，这也确实是我大学时代的梦，骄傲地跟父母报完喜讯后，马上订了台心仪已久的 Mac Pro。来到杭州报道，同事、环境等都让我格外欣喜和满足。我终于 进入 了字节

工作一年多，萌生了 出 国留学的想法，想再深造深造。同事D 再三劝阻我重视“沉默成本”，同时目前也是快升职之际，这种时间节点不常，有应该把握，另外出国的话以后稳定了随时都可以出去。句句在理，我被说服了，还是选择 留 下来搏一搏

想着暂时不出去的话，那就先 去 外企吧。随后去报了雅思课程，无论是之后留学还是外企，总归没有坏处。却因为疫情原因，兜兜转转花了半年终于考过了雅思。有了英语能力加成，加上本身技术底子不错，准备了一阵，拿到了苏州微软的 offer，最后却因为各种原因 拒绝 了

一个饭后，阳光明媚，约着同事C 和同事D 下去逛逛，吐槽 了下当下种种。C 告知了他准备 离开 的想法，我感到稍许失落，但也表示理解。很快，我们就相聚在散伙饭桌上了

2.2 感悟

关于“城里城外”故事还有很多，相信在你的生活中也萦绕着它们

站在城里：理性看待 对当下的不满

不满足于当下，本身是中性的，它既能变成追求美好生活的 动力，也可能成为负能量的源泉，让我们迷失在报怨中。应该要正确看待欲望

• 看清改变的迫切性和必要性


• 树立清晰的目标，制定计划


• 按照计划推进、根据状况调整

不盲目憧憬城外：按照自己的节奏走

城外风光似乎无限美好，为什么他一年就能考上研、升职加薪、出国留学……，总是被别人牵着走，和别人比较，自己永远都不会快乐

想起一个故事，高中时听班主任讲他带过的一个学姐，她想去国外读本科，所以高中就自学雅思，2013年左右，国内考点很少，无奈只能抢国外的场次，于是她一个人在新加坡考完了雅思。而我完成雅思，是在工作 2 年之后，与高中生涯相隔近 10 年，但这是属于我的 人生节奏

朋友，认真规划未来，按照自己的轨迹前行，想去的地方总会到达的。同时也能够真心为好友们的成功而祝福

跨越城墙：构筑自己的“储蓄池”

天地悠悠，过客匆匆，潮起又潮落。人生总会面临改变，无论是主动还是被动的。要学会构建自己的认知“储蓄池”

站在《系统论》角度，系统的发展，伴随着正要素和负要素的推动，此消彼长，对应着人生的起伏。我们靠什么去扛过一次次重大改变，仅靠遇事时候的打鸡血、调整心态 是远远不够的，靠的是我们在精神和认知上的 未雨绸缪。即

有计划的提升自我，建立具有缓冲能力的储蓄池，以从容应对每次的变更

三、幸存者偏差是把双刃剑

幸存者偏差效应：指只能看到经过某种筛选而产生的结果，而没有意识到筛选的过程，因此忽略了筛选掉的关键信息

3.1 小故事

毕业三年，现在年薪也来到了 n十万，但细想身边同事好友 谁又不是呢，自己是个正常水平吧，没有什么优越；学历呢，字节背靠杭州，面向浙大招聘，同事学历也基本至一本起步，自己也没有什么异常。同事W 说如果你学历本科，月入过万，有车有房，帅气阳光，你就已经是百里挑一了。我陷入了沉思

前同事P 来到杭州阿里，相约一起喝酒。我吐槽说其实大厂也就那样，面试造火箭，进去拧螺丝，业务需求 没啥难度，写写界面，封封组件……他说：“你也不能这样说，还是有很多人想进都进不了大厂的，我觉得进大厂可以证明自己”。“证明自己”，我一惊，忽然想起这个被抛在“大明湖畔”的词。回想快毕业时，当时天天想着要进大厂。但身处大厂久了，反而被“幸存者偏差”折磨的不成样

3.2 感悟

不可否认，幸存者偏差是刻在潜意识深处的东西

身处幸存者偏差，让我们与环境拉齐

身处大厂，周围同事都很优秀，我在有意识地吸收他们的工作经验和学习方法。同时也看到自己能力上的不足，并积极改进，慢慢总结出自己的一套方法论 无论什么环境，潜意识本能会 向均线拉齐，即所谓耳濡目染：大学寝室中 5 个室友都在打游戏，你会本能想加入，想着大家不都这样；同样身处于优秀的人之间，你会本能向他们靠齐，努力克服惰性

跳出舒适圈

幸存者偏差的缺点就是长此以往，自己会对当下变得麻木，失去对整体局势变化趋势的感知力 没有什么“大家都这样，那我也就这样了”的借口，当直觉层面感到不对时，要 引起重视。及时跳出舒适圈，去感受更多的可能性，慢慢从这些可能性中筛选出适宜变化的、高效的、自己够得着的生活方式

四、所谓理想

兄弟B 在英国留学，兄弟L 在云南做生意，我在杭州当码农，我们都有光明的前途。——《新华字典》（玩个梗 hh）

4.1 三十而立

90 后是“悲催”的一代

• 1982 年，计划生育政策正式写入宪法，90后一代基本都是独生子女


• 2000 年，互联网起步，70后、80后陆续下海创业，垄断资源


• 2010 年前后，通货膨胀，物价飞涨


• 2014 年，房价大涨，高处不胜寒，90后初入社会


• 2015 年，二胎政策全面开放，90后成为生育主力军，承受高额房贷


• 2020 年，互联网增量饱和，整个行业开始内卷


• 2030 年，中国逐步进入老龄化社会，90后延迟退休

以上列举的时间线肯定不全或说准确，但我想说的是 90后，同 80后、70后一样，也是背负沉重压力的一代，每个代有着自己的低谷和红利。90后在享受着“第三次工业革命”——互联网时代 的便利的同时，也在 承担 着意想不到的压力，很多 90后开始学会摆烂，佛系的生活渐渐流行开来，不婚、晚婚、晚育是常态

2021 年我国结婚登记数据为 763.6 万对，当我妈催我谈恋爱结婚时，我却只能说：“你看，90后 不都这样？”

在奔三途中的 90后们，我认为首先要“立”的还是“立己”。一次聚餐时，询问老会长Z，我是考研还是工作好，他脱口而出，“去考研吧，提升自己是最没有风险的投资”，这句话我会记一辈子

人们普遍惰于思考，在俗成的时间点随大流，没错，你大概率不会输的很惨。平安喜乐，踞一方天地，亦岂不快哉？所以，更多的是你与自己的博弈

4.2 精神上的富裕是最难满足的

古有“饱暖思淫欲”，当代有《马斯洛需求层次理论》金字塔。人有基本的生理、安全和归属需求，能生存下去后，开始思考价值认可和 理想抱负。感谢祖国的强大让我们处于和平的年代，能有机会去追求形而上的东西

每次层需求的满足都是奔赴下一境界的激励源，相对的，需求层次越高，也 更难得到满足，取决于个人的潜力点和你的预期高度。还有一点就是，人的欲望是无穷无尽的，每个阶段有每个阶段的执念，是安于现状还是继续奋勇前行，也是你说的算。但我认为，对于精神层面的追求，你至少应该有那么一次是为自己而活的

4.3 理想的样子

“理想”本来就是一个很虚的概念，它可以杂糅进很多虚幻的东西，但“目标”不是，想清楚自己到底想要什么，勇敢地朝着这个它前进，慢慢部署自己的硬实力和软实力，直到逐渐达到那个高度

对于我来说，为未来 奋斗 过程中的自己，本就是我 理想 中的样子！

五、回归生活

在祖国广袤的土地上，在鳞次栉比的大厦里，我用一把键盘 养活 了自己

如果你问我理想的生活是什么，我会告诉你，我拼尽全力，只是为了能够 平凡 地度过这一生。正如万青唱的那样：傍晚6点下班……

感谢你的阅读

By Liam

2022.05.19 于杭州

对于深拷贝这个概念在面试中时常被提起，面试官可能让你实现深拷贝需要考虑那些因素，或者直接让你手写封装一个深拷贝，那么今天就和大家探讨一下一个让面试官感到牛逼的深拷贝，

1.思考

众所周知普通的数据类型是值存储，而复杂类型是通过开辟内存空间来存储数据的，我们通过内存地址从而查找数据，为了可以完全得到一个与原对象一模一样但又没有内存地址关联的深拷贝，我们需要考虑的因素其实有很多，
1.Object.create()创造的对象 ， Object.create()详细介绍

  let obj = Object.create(null)

            obj.name = '张三'

            obj.age = 22

这个对象是一个没有原型的对象，大部分对象都有自己的原型，可以使用公共的方法，但这个却不行，我们是不是应该把它考虑进去？

2.symbol作为属性名的情况 Symbol详细介绍 以及
for in 详细介绍

let obj = {

            name: 'aa',

            age: 22,

            [Symbol('a')]: '独一无二的'

            }

对于带有symbol的属性，在 for in 的迭代中是不可枚举的，我们是不是需要考虑如何解决？

3.对于修改对象的属性描述 Object.defineProperty()

let obj = { name: 'ayu', age: 22, sex: '男' }

Object.defineProperty(obj, 'age', {

    enumerable: true,

    configurable: true,

    value: 22,

    writable: false

})

这里我们改写了原对象的属性描述，age变得无法枚举，for in 也失去效果，并且很多默认的属性描述信息，我们是不是在拷贝后也应该和原对象保持一致？

4.对象的循环引用

let obj = { name: 'ayu', age: 22, sex: '男' }

obj.e = e

obj对象中有个e的属性指向obj，造成相互引用，当我们在封装深拷贝时，主要是通过递归来逐层查找属性值的情况，然后对其进行操作，如果出现这个情况，就会死循环递归造成栈内存溢出，这种情况难道也不值得考虑嘛？

5.一些特殊的对象
都说万物皆对象，对象其实有很多类型，正则，日期(Date)，等都需要特殊处理
而函数和数组就比较简单

6.深拷贝的多数要点
也就是当一个对象里面嵌套了多层对象，这个大家应该都知道，我们通常一般使用递归去处理，再结合上面分析的因素就可以封装函数了

const isComplexDataType = (obj) => (typeof obj === 'object' || typeof obj === 'function') && obj !== null

const deepClone = function (obj, hash = new WeakMap()) {

    if (obj.constructor === Date) return new Date(obj) // 日期对象直接返回一个新的日期对象

    if (obj.constructor === RegExp) return new RegExp(obj) //正则对象直接返回一个新的正则对象

    //如果循环引用了就用 weakMap 来解决

    if (hash.has(obj)) return hash.get(obj)

    let allDesc = Object.getOwnPropertyDescriptors(obj)

    //遍历传入参数所有键的特性

    let cloneObj = Object.create(Object.getPrototypeOf(obj), allDesc)

    //继承原型链

    hash.set(obj, cloneObj)

    for (let key of Reflect.ownKeys(obj)) {

        cloneObj[key] =

            isComplexDataType(obj[key]) && typeof obj[key] !== 'function' ? deepClone(obj[key], hash) : obj[key]

    }

    return cloneObj

}

思路
从deepclone这个函数开始说起

1. 1.如果对象的构造器是Date构造器，则我们使用Dte构造器再构造一个Date


2. 如果对象的构造器是正则构造器再构造一个正则


3. WeakMap我们先不提，allDesc是拿到原对象所有的属性（可枚举以及不可枚举）以及对应的属性描述信息


4. cloneObj是我们根据第三步拷贝的一个新的对象的信息，不过是一个浅拷贝，而且我们考虑了原型不存在的情况 Object.assin与Object.create的区别


5. 通过for of 循环 Reflect.ownKeys(obj) Reflect.ownKeys()用法 （Reflect.ownKeys()可以遍历对象自身所有的属性（symbol，不可枚举都可以），然后重新将obj的key以及对应的值赋值给cloneObj，并且对obj[key]的值做了讨论，当它是对象并且不是函数时，我们递归处理，否则里面为普通值，直接赋给ObjClone

对于deepClone的第二个参数WeakMap来讲， 请大家想想最开始我们提到的一个问题，我们有一个对象，然后我们填了了一个属性，属性为这个对象，这是在相互引用，如果我们处理这样的对象，也使用递归处理，那么就是死循环，因此我们需要一个数据结构来解决，每次我们递归处理的时候，都把obj，以及赋值的cloneobj对应存储，当遇到死循环的时候直接return这个对象即可
WeakMap详细介绍·

(本文用到大量ES5以后的API，推荐阅读阮一峰老师的ES6，这样才能理解的透彻)

前言

在学习vue的时候vue2只有在组件中严格要求data必须是一个函数，而在普通vue实例中，data可以是一个对象，但是在vue3出现后data必须一个函数，当时看着官方文档说的是好像是对象的引用问题，但是内部原理却不是很了解，今天通过一个简单的例子来说明为啥data必须是一个函数

参考 (vue2data描述)

参考: (vue3data描述)

1.Vue3中的data

const { createApp } = Vue

const app = {

    data: {

        a: 1

    },

    template: `

    
{{a}}


    `

}

createApp(app).mount('#app')

可以看到上来vue就给了警告说明data必须是一个函数 下面直接抛错

2.vue中的data

var app = new Vue({

    el: '#app',

    data: { a: 'hello world' }

})

这种写法是可以的，前面提过普通实例data可以是对象，但是在组件中必须是函数，
那么在vue2中难道普通实例就没有缺陷嘛？

答案：是有缺陷的，
比如这样

<div id="app1">{{ message }}div>

<div id="app2">{{ message }}div> 

const data = { message: 'hello world' }

const vue1 = new Vue({

    el: '#app1',

    data

})



const vue2 = new Vue({

    el: '#app2',

    data

})

       

这样在页面中会显示2个内容为hello world的div标签
那么当我们通过实例去改变messag呢？

 vue1.message = 'hello Vue'

奇怪的事情发生了，我知识改变了vue1的实例中的数据，但是其他实例的数据也发生了改变，相信很简单就能看出来这应该是共用同一个对象的引用而导致的，这在开放中是非常不友好的，开发者很容易就产生连串的错误，vue2也知道这种缺陷只是没有在普通实例中去体现而已，只在组件中实现了对于data的约束

为了让大家更好的立即为啥data必须是一个函数，黑猫在此简单实现一个vue的实例然后来证明为啥data是一个函数，以及如果data不是一个函数，我们应该如何处理

3.证明data是函数以及原理实现

在实现简单原理之前，我们需要搞清楚Vue在创建实例之前，对于data到底做了什么事情简单来说就是:

vue 在创建实例的过程中调用data函数返回实例对象通过响应式包装后存储在实例的$data上并且实例可以直接越过$data访问属性

1.通过这句描述可以知道Vue是一个构造函数，并且传入的参数中有一个data的属性，我们可以$data去访问，也可以直接访问这个属性，并且我们需要对这个data做代理

那么简单实现如下

function Vue(options) {

    this.$data = proxy(options.data())

}

function proxy(options) {

    return new Proxy(options, {

        get(target, key, value, receiver) {

            return Reflect.get(target, key, value, receiver)

        },

        set(target, key, newValue, receiver) {

            Reflect.set(target, key, newValue, receiver)

        }

    })

}

const data = function () {

    return {

        a: 'hello world'

    }

}

const vue1 = new Vue({

    data

})

const vue2 = new Vue({

    data

})

vue1.$data.a = 'hello Vue'

console.log(vue1.$data.a) // hello Vue

console.log(vue2.$data.a) // hello world

通过简单实现可与看出来，当我们的data是一个函数的时候，在Vue的构造函数中，只有有实例创建就有执行data函数，然后返回一个特别的对象，所以当我们修改其中一个实例的时候并不会对其他实例的数据产生变化

那么当data不是一个函数呢 ，我们简单改下代码，代码如下

function Vue(options) {

    this.$data = proxy(options.data)

}

function proxy(options) {

    return new Proxy(options, {

        get(target, key, value, receiver) {

            return Reflect.get(target, key, value, receiver)

        },

        set(target, key, newValue, receiver) {

            Reflect.set(target, key, newValue, receiver)

        }

    })

}

const data = {

    a: 'hello world'

}

const vue1 = new Vue({

    data

})

const vue2 = new Vue({

    data

})

vue1.$data.a = 'hello Vue'

console.log(vue1.$data.a) // hello Vue

console.log(vue2.$data.a) // hello Vue

可以看出，由于共用一个对象，当代理的时候也是对同一个对象进行代理，那么当我们通过一个实例去改变数据的时候，就会影响其他实例的状态

4.如果data必须是一个对象呢？

假如有人提出如果data是一个对象，那么我们应该如何处理呢，其实也非常简单，在代理的时候我们可以将传入的data对象通过深拷贝即可，这样我们就不会使用相同引用的对象啦。

[深拷贝牛逼封装参考我以前的文章](不一样的深拷贝)

之前分页都是使用框架给出的分页类来实现分页，当然，体验可能不是那么好。

这次在写YII2.0框架的后台管理系统的小例子的时候，我这也尝试了一下前后分离，用ajax来实现分页跳转。

那么前端的页码绘制及跳页等其他的样式，都是由JavaScript根据后台返回的数据拼接而成。我的分页效果如下图所示：

大概就是上面的样子。

Html代码如下：对照第一张图片

<ul> 

    <li><span>1<span data-id="1"></span></span></li>

    <li><a data-id="2">2</a></li>

    <li><a data-id="3">3</a></li>

    <li><a data-id="4">4</a></li>

    <li><a data-id="5">5</a></li>

    <li><a data-id="6">6</a></li>

    <li><a data-id="7">7</a></li>

    <li><a data-id="8">8</a></li>

    <li><a data-id="false"> ... </a></li>

    <li><a data-id="11"> 11 </a></li>

    <li><a data-id="next"> &gt;&gt; </a></li>

</ul>

JavaScript代码如下：

我这里使用的是纯JavaScript代码，没有使用jquery，这个是考虑到兼容性的问题。

/**

 * @name 绘制分页

 * @author camellia

 * @date 20200703

 * @param pageOptions 这是一个json对象

 * @param pageTotal 总页数

 * @param curPage 当前页数

 * @param paginationId  显示分页代码的上层DOM的id

 */

 function dynamicPagingFunc(pageOptions)

 {

    // 总页数

    var pageTotal = pageOptions.pageTotal || 1;

    // 当前页

    var curPage = pageOptions.curPage || 1;

    // 获取页面DOM对象

    var paginationId = document.getElementById(''+pageOptions.paginationId+'') || document.getElementById('pagination');

    // 如果当前页 大于总页数  当前页为1

    if(curPage>pageTotal)

    {

       curPage =1;

    }

    var html = "<ul>  ";

    /*总页数小于5，全部显示*/

    if(pageTotal<=5)

    {

       html = appendItem(pageTotal,curPage,html);

       paginationId.innerHTML = html;

    }

    /*总页数大于5时，要分析当前页*/

    if(pageTotal>5)

    {

       if(curPage<=4)

       {

          html = appendItem(pageTotal,curPage,html);

          paginationId.innerHTML = html;

       }

       else if(curPage>4)

       {

          html = appendItem(pageTotal,curPage,html);

          paginationId.innerHTML = html;

       }

    }

    // 显示到页面上的html字符串

    // var html = "<ul>  ";

    // html = appendItem(pageTotal,curPage,html);

    html += "</ul>";

    // 显示至页面中

    paginationId.innerHTML = html;

 }

 

 /**

  * @name 绘制分页内部调用方法，根据不同页码来分析显示样式

  * @author camellia

  * @date 20200703

  * @param pageTotal 总页数

  * @param curPage 当前页

  * @param html 显示在页面上的html字符串

  */

 function appendItem(pageTotal,curPage,html)

 {

    // 显示页

    var showPage = 8;

    // 总页数大于XX页的时候，中间默认...

    var maxPage = 9;

    // 开始页

    var starPage = 0;

    // 结束页

    var endPage = 0;

    // 首先当前页不为1的时候显示上一页

    if(curPage != 1)

    {

       html += "<li><a data-id = 'prev' > << </a></li> ";

    }

    // 当总页数小于或等于最大显示页数时，首页是1，结束页是最大显示页

    if(pageTotal <= maxPage)

    {

       starPage = 1;

       endPage = pageTotal;

    }

    else if(pageTotal>maxPage && curPage<= showPage)

    {

       starPage = 1;

       endPage = showPage;

       if(curPage == showPage)

       {

          endPage = maxPage;

       }

    }

    else

    {

       if(pageTotal == curPage)

       {

          starPage = curPage - 3;

          endPage = curPage;

       }

       else

       {

          starPage = curPage - 2;

          endPage = Number(curPage) + 1;

       }

 

       html += "<li><a data-id = '1'> 1 </a></li> ";

       html += "<li><a data-id='false'> ... </a></li> ";

    }

    var i = 1;

    for(let i = starPage;i <= endPage;i++)

    {

       if(i==curPage)

       {

          html += "<li ><span>"+ i +"<span data-id="+i+"></span></span></li>";

       }

       else

       {

          html += "<li ><a data-id = "+ i +">"+i+"</a></li>";

       }

    }

 

 

    if(pageTotal<=maxPage)

    {

       if(pageTotal != curPage)

       {

          html += "<li><a data-id='next' > >> </a></li> ";

       }

    }

    else

    {

       if(curPage < pageTotal-2)

       {

          html += "<li><a data-id='false'> ... </a></li> ";

       }

       if(curPage <= pageTotal-2)

       {

          html += "<li><a data-id = "+pageTotal+" > "+pageTotal+" </a></li> ";

       }

       if(pageTotal != curPage)

       {

          html += "<li><a data-id = 'next' > >> </a></li> ";

       }

    }

    return html;

 }

 调用上边的分页代码：

// 绘制分页码

 var pageOptions = {'pageTotal':result.pageNumber,'curPage':result.page,paginationId:'pages'};

 dynamicPagingFunc(pageOptions);

我这里把分页的样式是引用的公共css中的文件，这里就不展示了，将你的分页html代码把我的代码替换掉就好。

参数的聚体解释以及函数中用到的参数，备注基本都已给出。

下面这部分是点击各个页码时，请求数据及重回页码的部分

/**

 * @name 分页点击方法，因为页面html是后生成的，所以需要使用ON方法进行绑定

 * @author camellia

 * @date 20200703

 */

 $(document).on('click', '.next', function()

 {

     layer.load(0, {shade: false});

     // 获取当前页码

     var obj = $(this).attr('data-id');

     // 获取前一页的页码，点击上一页以及下一页的时候使用

     var curpages = $("li .sr-only").attr('data-id');

     // 点击下一页的时候

     if(obj == 'next')

     {

         obj = Number(curpages) + 1;

     }

     else if(obj == 'prev')// 点击上一页的时候

     {

         obj = curpages - 1;

     }

     $.ajax({

         //几个参数需要注意一下

         type: "POST",//方法类型

         dataType: "json",//预期服务器返回的数据类型

         url: "?r=xxx/xxx-xxx" ,//url

         data: {'page':obj},

         success: function (result)

         {

             // 将列表部分的html清空

             document.getElementById('tbody').innerHTML = '';

             // 重新绘制数据列表

             drawPage(result.dbbacklist);

             // 绘制分页码

             var pageOptions = {'pageTotal':result.pageNumber,'curPage':result.page,paginationId:'pages'};

             dynamicPagingFunc(pageOptions);

             layer.closeAll();

         },

         error : function() {

             alert("异常！");

         }

     });

 });

有好的建议，请在下方输入你的评论。

欢迎访问个人博客：guanchao.site

欢迎访问我的小程序：打开微信->发现->小程序->搜索“时间里的”

2022年8月8日，linxiang07 同学给我们的 Vue DevUI 提了一个 Issue：
#1199 Button/Search/Input/Select等支持设置size的组件标准不统一，并且认真梳理了现有支持size属性的组件列表和每个组件大中小尺寸的现状，整理了一个表格（可以说是提 Issue 的典范，值得学习）。

不仅如此，linxiang 同学还提供了详细的修改建议：

1. 建议xs、 sm 、md、lg使用标准的尺寸


2. 建议这些将组件的尺寸使用公共的sass变量


3. 建议参考社区主流的尺寸


4. 考虑移除xs这个尺寸、或都都支持xs

作为一名对自己有要求的前端，差两个像素不能忍

如果业务只使用单个组件，可能看不太出问题，比如 Input 组件的尺寸如下：

• sm 24px


• md 26px


• lg 44px

Select 组件的尺寸如下：

• sm 22px


• md 26px


• lg 42px

当 Input 和 Select 组件单独使用时，可能看不出什么问题，但是一旦把他俩放一块儿，问题就出来了。

大家仔细一看，可以看出中间这个下拉框比两边输入框和按钮的高度都要小一点。

别跟我说你没看出来！作为一名资深的前端，像素眼应该早就该练就啦！

作为一名对自己严格要求的前端，必须 100% 还原设计稿，差两个像素怎么能忍！

vaebe: 表单 size 这个 已经很久了 争取不要留到23年

这时我们的 Maintainer 成员 vaebe 主动承担了该问题的修复工作（必须为 vaebe 同学点赞）。

看着只是一个 Issue，但其实这里面涉及的组件很多。

8月12日，vaebe 同学提了第一个修复该问题的 PR：

style(input): input组件的 size 大小

直到12月13日（今天）提交最后一个 PR：

cascader组件 props size 在表单内部时应该跟随表单变化

共持续5个月，累计提交34个PR，不仅完美地修复了这个组件尺寸不统一的问题，还完善了相关组件的单元测试，非常专业，必须再次给 vaebe 同学点赞。

关于 vaebe 同学

vaebe 同学是今年4月刚加入我们的开源社区的，一直有在社区持续作出贡献，修复了大量组件的缺陷，完善了组件文档，补充了单元测试，还为我们新增了 ButtonGroup 组件，是一位非常优秀和专业的开发者。

如果你也对开源感兴趣，欢迎加入我们的开源社区，添加小助手微信：opentiny-official，拉你进我们的技术交流群！

Vue DevUI：github.com/DevCloudFE/…（欢迎点亮 Star 🌟）

--- END ---

我是 Kagol，如果你喜欢我的文章，可以给我点个赞，关注我的掘金账号和公众号 Kagol，一起交流前端技术、一起做开源！

封面图来自B站UP主亿点点不一样的视频：吃毒蘑菇真的能见小人吗？耗时六个月拍下蘑菇的生长和繁殖

前端

Vue是一款非常流行的JavaScript框架，它提供了一套高效、灵活、易于使用的前端开发工具。在实际开发中，我们通常会使用Vue来构建单页面应用（SPA），并将其部署到服务器上以便用户访问。本篇博客将介绍如何进行Vue单页面应用的部署配置。

构建生产版本

首先，我们需要将Vue应用程序构建为生产版本，这可以通过运行以下命令来完成：

npm run build

该命令将生成一个dist目录，其中包含了生产版本的所有必要文件，例如HTML、CSS、JavaScript等。在部署之前，我们需要将这些文件上传到服务器上，并将其存储在合适的位置。

配置Nginx服务器

接下来，我们需要将Vue应用程序与Nginx服务器结合起来，以便处理HTTP请求和响应。下面是一个简单的配置示例：

server {

    listen 80;

    server_name example.com;



    root /var/www/vue-app/dist;

    index index.html;



    location / {

        try_files $uri $uri/ /index.html;

    }

}

在上面的示例中，我们定义了一个名为“example.com”的虚拟主机，并指定了根目录即Vue应用程序所在的dist目录。同时，我们还设置了默认的index.html文件，并通过location指令来处理所有的HTTP请求。

配置HTTPS加密连接

如果需要启用HTTPS加密连接，我们可以通过以下方式来进行配置：

server {

    listen 443 ssl;

    server_name example.com;



    root /var/www/vue-app/dist;

    index index.html;



    ssl_certificate /path/to/cert.pem;

    ssl_certificate_key /path/to/key.pem;



    location / {

        try_files $uri $uri/ /index.html;

    }

}

在上面的示例中，我们使用ssl指令来启用SSL/TLS支持，并设置了证书和私钥文件的路径。同时，我们还将所有HTTP请求重定向到HTTPS连接，以确保数据传输的安全性。

配置缓存和压缩

为了提高Vue应用程序的性能和响应速度，我们可以配置缓存和压缩。下面是一个简单的配置示例：

server {

    listen 80;

    server_name example.com;



    root /var/www/vue-app/dist;

    index index.html;



    location / {

        try_files $uri $uri/ /index.html;



        expires 1d;

        gzip on;

        gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

    }

}

在上面的示例中，我们使用expires指令来定义缓存时间，并使用gzip指令来启用Gzip压缩。同时，我们还设置了需要进行压缩的文件类型，例如文本、CSS、JavaScript等。

总结

以上就是Vue单页面应用的部署配置步骤。首先，我们需要构建生产版本，并将其上传到服务器上。然后，我们需要通过Nginx服务器来处理HTTP请求和响应，以及启用HTTPS加密连接、缓存和压缩等功能。了解这些配置信息，将有助于我们更好地部署和管理

前言

今天分享一个简单的卡片鼠标悬停动画，初始显示一张图片，当鼠标移至卡片上方时，显示文字，先来看看预览效果：

代码实现

页面布局

<div class="view view-first">  

    <img src="./images/1.webp" />  

    <div class="mask">  

    <h2>Title</h2>  

    <p>Your Text</p>  

        <a href="#" class="info">Read More</a>  

    </div>  

</div>  

这段代码了一个用于展示图片的容器 <div> 元素，其中包含了一个图片 <img> 元素和一个用于显示图片标题、文字和链接的 <div> 元素。这个容器使用了类名为 view 和 view-first 的 CSS 类来进行样式控制。

页面样式

.view {

    width: 1080px;

    height: 1430px;

    margin: 10px auto;

    border: 10px solid red;

    overflow: hidden;

    position: relative;

    text-align: center;

    box-shadow: 1px 1px 2px #e6e6e6;

    cursor: pointer;

}

.view .mask, .view .content {

    width: 1080px;

    height: 1430px;

    position: absolute;

    overflow: hidden;

    top: 0;

    left: 0

}

.view h2 {

    text-transform: uppercase;

    color: #fff;

    text-align: center;

    font-size: 180px;

    padding: 10px;

    background: rgba(0, 0, 0, 0.6);

    margin: 220px 0 0 0

}

.view p {

    font-family: Georgia, serif;

    font-style: italic;

    font-size: 120px;

    color: #fff;

    padding: 10px 20px 20px;

    text-align: center

}

.view a.info {

    display: inline-block;

    text-decoration: none;

    padding: 7px 14px;

    font-size: 60px;

    background: #000;

    color: #fff;

    text-transform: uppercase;

    box-shadow: 0 0 1px #000

}

.view a.info:hover {

    box-shadow: 0 0 5px #000

}





.view-first img { 

    transition: all 0.2s linear;

}

.view-first .mask {

    opacity: 0;

    background-color: rgba(219,127,8, 0.7); 

    transition: all 0.4s ease-in-out;

}

.view-first h2 {

    transform: translateY(-100px);

    opacity: 0;

    transition: all 0.2s ease-in-out;

}

.view-first p { 

    transform: translateY(100px);

    opacity: 0;

	transition: all 0.2s linear;

}

.view-first a.info{

    opacity: 0;

	transition: all 0.2s ease-in-out;

}



.view-first:hover img { 

	transform: scale(1.2);

} 

.view-first:hover .mask { 

	opacity: 0.8;

}

.view-first:hover h2,

.view-first:hover p,

.view-first:hover a.info {

    opacity: 1;

    transform: translateY(0px);

}

.view-first:hover p {

    transition-delay: 0.1s;

}

.view-first:hover a.info {

    transition-delay: 0.2s;

}

这段 CSS 代码定义了 .view 和 .view-first 这两个类的样式属性。其中，.view 类定义了容器的基本样式，包括宽度、高度、边距、背景颜色、阴影等。.view-first 类定义了容器在鼠标悬停时的效果，包括图片放大、遮罩层透明度变化、标题、文字和链接的透明度和位置变化等。这段代码通过使用伪类 :hover 来控制在鼠标悬停时的效果。同时，这段 CSS 代码中包含了一些过渡效果（transition），通过设置不同的过渡时间和延迟时间，实现了在鼠标悬停时的平滑动画效果。同时，通过使用透明度（opacity）、位移（transform: translateY()）和缩放（transform: scale()）等属性，实现了图片和文字的渐现和渐变效果。接下来对各个样式进行详细解释：

.view {

    width: 1080px;

    height: 1430px;

    margin: 10px auto;

    border: 10px solid red;

    overflow: hidden;

    position: relative;

    text-align: center;

    box-shadow: 1px 1px 2px #e6e6e6;

    cursor: pointer;

}

设置容器元素的宽度和高度，margin: 10px auto;设置容器元素的外边距，使其在水平方向上居中，上下边距为 10 像素，text-align: center;文本的水平对齐方式为居中，box-shadow: 1px 1px 2px #e6e6e6;设置容器元素的阴影效果，水平和垂直偏移都为 1 像素，模糊半径为 2 像素，阴影颜色为 #e6e6e6。cursor: pointer;设置鼠标悬停在容器元素上时的光标样式为手型。

.view .mask, .view .content {

    width: 1080px;

    height: 1430px;

    position: absolute;

    overflow: hidden;

    top: 0;

    left: 0

}

选中类名为 "mask" 和 "content" 的元素，采用绝对定位，设置top和left偏移量为0。

.view h2 {

    text-transform: uppercase;

    color: #fff;

    text-align: center;

    font-size: 180px;

    padding: 10px;

    background: rgba(0, 0, 0, 0.6);

    margin: 220px 0 0 0

}

对字体颜色和大小进行设置，文字水平居中，设置背景色等，text-transform: uppercase;设置标题文本转换为大写。

.view p {

    font-family: Georgia, serif;

    font-style: italic;

    font-size: 120px;

    color: #fff;

    padding: 10px 20px 20px;

    text-align: center

}

.view a.info {

    display: inline-block;

    text-decoration: none;

    padding: 7px 14px;

    font-size: 60px;

    background: #000;

    color: #fff;

    text-transform: uppercase;

    box-shadow: 0 0 1px #000

}

.view a.info:hover {

    box-shadow: 0 0 5px #000

}

对子元素p标签和指定a标签进行字体样式进行设置，text-decoration: none;去除下划线，a元素在鼠标悬停状态下的添加阴影。

.view-first img { 

    transition: all 0.2s linear;

}

.view-first .mask {

    opacity: 0;

    background-color: rgba(219,127,8, 0.7); 

    transition: all 0.4s ease-in-out;

}

.view-first h2 {

    transform: translateY(-100px);

    opacity: 0;

    transition: all 0.2s ease-in-out;

}

.view-first p { 

    transform: translateY(100px);

    opacity: 0;

	transition: all 0.2s linear;

}

.view-first a.info{

    opacity: 0;

	transition: all 0.2s ease-in-out;

}



.view-first:hover img { 

	transform: scale(1.2);

} 

.view-first:hover .mask { 

	opacity: 0.8;

}

.view-first:hover h2,

.view-first:hover p,

.view-first:hover a.info {

    opacity: 1;

    transform: translateY(0px);

}

.view-first:hover p {

    transition-delay: 0.1s;

}

.view-first:hover a.info {

    transition-delay: 0.2s;

}

对各元素在鼠标悬停状态下的样式进行设置，并添加动画效果，主要动画元素transform: scale(1.2);图片在悬停状态下缩放1.2倍，transform: translateY(0px);在y轴上偏移量，transition-delay: 0.1s;动画延迟时间，ease-in-out缓入缓出。

结语

以上便是全部代码了，总体比较简单，只需要使用一些简单的动画属性即可，喜欢的小伙伴可以拿去看看，根据自己想要的效果进行修改。

作者：李亚飞

Debugging is like trying to find a needle in a haystack, except the needle is also made of hay.

Debug调试就像是在大片的干草堆中找针一样，只不过针也是由干草制成的。

在软件开发的世界里，偶尔会出现一些非常隐蔽的 Bug，这时候工程师们像探险家一样，需要深入代码的丛林，寻找隐藏在其中的“幽灵宝藏”。前段时间，我和我的团队也踏上了这样一段刺激、有趣的探险之旅。

最近繁忙的工作告一段落，我总算轻松下来了，想趁这个机会，跟大家分享我们的这次“旅途”。

01 引子

我是 ShowMeBug 的 CEO 李亚飞，是一个古老的 Ruby 工程师。由于 2019 年招聘工程师的噩梦经历，我立志打造一个真实模拟工作场景的 IDE，用来终结八股文、算法横行的技术招聘时代。

这个云上的 IDE 引擎，我称之为轻协同 IDE 引擎——因为它不是为了繁杂重度的工作场景准备的，而是适应于大部分人的习惯、能快速上手熟悉、加载速度快、能协同（面试用）、低延迟感，让用户感受非常友好 。

多环境启动与切换

为了达成秒级启动环境的性能要求，我们设计了一套精巧的分布式文件系统架构，其核心是一个可以瞬间复制大量小文件的写时复制 (COW) 技术。IO 吞吐能达到几万人同时在线，性能绝对是它的一大优势。

我们对此信心满满，然而没想到，很快就翻车了。

02 探险启程

2023 年 1 月，北方已经白雪皑皑，而深圳却仍难以感受到冬天的寒意。

我和我的团队在几次打开文件树的某个文件时，会显得有点慢——当时没有人在意，按照常规思路，“网速”背了这个锅。事后我们复盘才发现，这个看似微不足道的小问题，其实正是我们开始这次探险之旅的起点。

1 月底，南方的寒意缓缓侵入。这时候我们的轻协同 IDE 引擎已经开始陆续支持了 Vue2、Vue3、React、Django、Rails 等框架环境，一开始表现都很棒，加载和启动速度都很快。但是，跑了一段时间，我们开始察觉，线上环境就出现个别环境（Rails 环境）启动要 20-30s 才能完成。

虽然其他环境仍然保持了极快的加载和启动速度，但敏锐的第六感告诉我，不行，这一定有什么猫腻，如果不立即行动，势必会对用户体验带来很不好的影响。于是，我开始安排团队排查眼前这个不起眼的问题，我们的探险之旅正式开始。

03 初露希望

湿冷的冬季，夜已深，我和我们的团队依旧坐在电脑前苦苦探索，瑟瑟发抖。

探险之旅的第一站，就是老大难的问题：定位Bug。目前只有某一个环境启动很慢，其他的环境都表现不错。大家想了很多办法都没有想明白为什么，甚至怀疑这个环境的模板是不是有问题——但把代码放在本地启动，最多就2秒。

哎，太诡异了。我们在这里卡了至少一周时间，不断追踪代码，分析日志文件，尝试各种方案，都没有弄清楚一个正常的程序启动为什么会慢。我们一度陷入了疲惫和焦虑的情绪中。

Debug 是种信仰，只有坚信自己能找到 Bug，才有可能找到 Bug。

软件开发界一直有一个低级 Bug 定律：所有诡异的问题都来自一个低级原因。在这“山重水复疑无路”之际，我们决定重新审视我们的探险路径：为什么只有 Rails 更慢，其他并不慢？会不会只是一个非常微小的原因而导致？

这时候，恰好有一个架构师朋友来访，向我们建议，可以用 perf 火焰图分析看看 Rails 的启动过程。

perf火焰图实例

当我们用 perf 来分析时，惊讶地发现：原来 Rails 的启动要加载更多的文件！ 紧接着，我们又重新用了一个文件读写监控的工具：fatrace，通过它，我们看到 Rails 每次启动需要读写至少 5000 个文件，但其他框架并不需要。

这才让我们突然意识到，会不会是文件系统读写速度不及预期，导致了启动变慢。

04 Bug现身

为了搞清楚是不是文件系统读写速度的问题，我急需一个测试 IO 抖动的脚本。我们初步估算一下，写好这个脚本需要好几个小时的时间。

夜已深，研发同学都陆续下班了。时间紧迫！我想起了火爆全球的 ChatGPT，心想，不如让它写一个试试。

测试 IO 抖动的脚本

Bingo，如同“幽灵宝藏”一般的分子级 Bug 逐渐显现，问题的根因已经确认：过慢的磁盘 IO 读写引发了一系列操作变慢，进而导致启动时间变得非常慢 。

更庆幸的是，它还让我们发现了偶尔打开文件树变慢的根本原因，这也是整个系统并发能力下降的罪魁祸首 。

05 迷雾追因

看到这里，大家可能会问，这套分布式文件系统莫非一直这么慢，你们为什么在之前没有发现？

非也，早在项目开始的时候，这里的时延是比较良好的，大家没有特别注意这个 IOPS 性能指标，直到我们后面才留意到，系统运行超过一个月时，IO 读写时延很容易就进入到卡顿的状态，表现就是文件系统所在主机 CPU 忽高忽低，重启就会临时恢复。

此时，探险之旅还没结束。毕竟，这个“幽灵宝藏”周围依旧笼罩着一层迷雾。

我们继续用 fatrace（监控谁在读写哪个 IO）监控线上各个候选人答题目录的 IO读写情况，好家伙，我们发现了一个意外的情况：几乎每一秒都有一次全量的文件 stats 操作 (这是一个检测文件是否有属性变化的 IO 操作）！

也就是说，比如有 1000 个候选人正在各自的 IDE 中编码，每个候选人平均有 300 个文件，就会出现每秒 30 万的 IO 操作数！

我们赶紧去查资料，根据研究数据显示，一个普通的 SSD 盘的 IOPS 最高也就到 2-3 万 。于是，我们重新测试了自己分布式文件系统的 IOPS 能力，结果发现也是 2-3 万 。

那这肯定远远达不到我们理想中的能力级别。

这时，问题更加明确：某种未知的原因导致了大量的 IOPS 的需求，引发了 IO 读写时延变长，慢了大约几十倍。

06 接近尾声

我和我的团队继续深究下去，问题已经变得非常明确了：

原来，早在去年 12 月，我们上线一个监听文件增删的变化来通知各端刷新的功能。

最开始我们采用事件监听 (fswatch event)，因为跨了主机，所以存在 1-2s 的延迟。研发同学将其改为轮询实现的方案，进而引发了每秒扫描目录的 stats 行为。

当在百人以下访问时，IOPS 没有破万，还足够应对。但一旦访问量上千，便会引发 IO 变慢，进而导致系统出现各种异常：间歇导致某些关键接口 QPS 变低，进而引发系统抖动。

随着“幽灵宝藏”显露真身，这次分子级 Bug 的探险之旅也已经接近尾声。团队大
呼：这过程实在太酸爽了！

07 技术无止境

每一个程序员在成长路上，都需要与 Bug 作充足的对抗，要么你勇于探索，深入代码的丛林，快速定位，挖到越来越丰富的“宝藏”，然后尽情汲取到顶级的知识，最终成为高手；或者被它打趴下, 花费大量时间都找不到问题的根源，成为芸芸众生中的一人。

当然，程序员的世界中，不单单是 Debug。

当我毕业 5 年之后，开始意识到技术的真正价值是解决真正的社会问题。前文中我提到，由于我发现技术招聘真是一个极其痛苦的事：特别花面试官的时间，却又无法有效分析出候选人的技术能力，所以创立 ShowMeBug 来解决这个问题：用模拟实战的编程环境，解决科学评估人才的难度。

这个轻协同 IDE 技术从零开发，支持协同文件树、完全自定义的文件编辑器、协同的控制台 (Console) 与终端 (Shell)，甚至直接支持 Ctrl+P 的文件树搜索，不仅易于使用，又强大有力。

但是这还不够。要知道，追求技术精进是我们技术人的毕生追求。对于这个轻协同IDE，我们追求三个零：零配置、零启动、零延迟。其中，零启动就是本文所追求的极限：以最快的速度启动环境和切换环境。

因此，探险之旅结束后，我们进一步改进了此文件系统，设定 raid 的多磁盘冗余，采用高性能 SSD，同时重新制定了新磁盘架构参数，优化相关代码，最终大幅提升了分布式文件系统的稳定性与并发能力。

截止本文结尾，我们启动环境的平均速度为 1.3 秒，切换环境速度进入到亚秒级，仅需要 780ms。目前在全球范围的技术能力评估赛道 (TSA) 中，具备 1-2 年的领先性。

08 后记

正当我打算结束本文时，我们内部的产品吐槽群信息闪烁，点开一看：嚯，我们又发现了新 Bug。

立夏已至，我们的探险之旅又即将开始。

在深圳地铁延误、临停n次之后

终于让我不得不又new了一个py文件😭😭

这次主要记录的是一个延误告警的开发过程

一、实现逻辑

使用库：requests，time，zmail，re

实现逻辑：

1、抓取深圳地铁微博的文章

2、判断是否有延误相关的内容

3、判断时间是否是今天

4、通知方式：邮件

5、定时执行任务

二、抓取深圳地铁微博（一中1～3）

def goout_report():

    url ="https://weibo.com/ajax/statuses/mymblog"

    # url ="https://weibo.com/szmcservice/statuses/mymblog"

    data = {"uid":2311331195,"page":1,"feature":0}

    headers={

    "accept":"application/json, text/plain, */*",

    "accept-encoding":"gzip, deflate, br",

    "accept-language":"zh-CN,zh;q=0.9",

    "referer":"https://weibo.com/szmcservice?tabtype=feed",

    "cookie":"SUB=_2AkMV8LtUf8NxqwJRmf8XzmLgaY9wywjEieKjrEqPJRMxHRl-yT92ql0ctRB6PnCVuU8iqV308mSwZuO-G9gDVwYDBUdc; SUBP=0033WrSXqPxfM72-Ws9jqgMF55529P9D9WFpwsXV4nqgkyH.bEVfx-Xw; login_sid_t=c6bbe5dc58bf01c49b0209c29fadc800; cross_origin_proto=SSL; _s_tentry=passport.weibo.com; Apache=4724569630281.133.1655452763512; SINAGLOBAL=4724569630281.133.1655452763512; ULV=1655452763517:1:1:1:4724569630281.133.1655452763512:; wb_view_log=1920*10801; XSRF-TOKEN=1YMvL3PsAm21Y3udZWs5LeX3; WBPSESS=xvhb-0KtQV-0lVspmRtycws5Su8i9HTZ6dAejg6GXKXDqr8m6IkGO6gdtA5nN5IMNb5JZ1up7qJoFXFyoP2RSQSYXHY1uLzykpOFENQ07VthB0G9WHKwRCMWdaof42zB4mOkdTEeX_N9-m1x6Cpm3pmPsC1YhmTwqH8RGwXmYkI=",

    "referer":"https://weibo.com/szmcservice",

    "x-requested-with": "XMLHttpRequest",

    "x-xsrf-token":"1YMvL3PsAm21Y3udZWs5LeX3",

    "sec-ch-ua":'Not A;Brand";v="99", "Chromium";v="102", "Google Chrome";v="102',

    "sec-ch-ua-platform":"Windows",

    "sec-fetch-dest": "empty",

    }

    text = requests.get(url,headers=headers,params=data,verify=False).json()['data']['list']

    today_date = time.ctime()[:10]

    for i in range(1,5):

        time_post = text[i]['created_at'][:10]

        content = str(text[i]).split("'text': '")[1].split(", 'textLength'")[0]

        tp=""

        if '延误' in content and time_post == today_date:

            # mail(content)

            text = re.findall(">(.*?)<|>(.*?)\\",content)

            for i in text:

                for j in i:

                    if j!="":





                       tp=tp+j



           mail(tp)

            break

        else:

            continue

 

三、邮件通知，代码如下

def mail(content):

    mail = {

        'subject': '别墨迹了！地铁又双叒叕延误啦',  #邮件标题

        'content_text': content,  # 邮件内容

    }

    server = zmail.server('自己的邮箱', '密码',smtp_host="smtp.qq.com",

                      smtp_port=465) #此处用的qq邮箱、授权码

    server.send_mail('收件人邮箱', mail)

ps：需去QQ邮箱网页版-设置-账户-开启smtp服务、获取授权码

四、定时执行任务

1、Jenkins比较合适项目的一个定时执行，

可参考如下：

jenkins环境： jenkins环境部署踩坑记

git环境：Mac-git环境搭建

2、windows-计算机管理比较合适脚本的执行，具体步骤如下，

• 
  

  windows键+R输入compmgmt.msc可进入计算机管理界面

  
  

  

  
  


• 
  

  点击上图“创建任务”后如图，

  
  

  “常规”界面上输入任务名称、选项二，

  
  

  这样锁屏也会自动执行脚本

  
  

  

  
  


• 
  

  点击“触发器”-新建进入新建触发器界面

  
  

  这个界面可设置任务执行时间、执行频率、任务重复间隔、延迟时间等等

  
  

  

  
  


• 
  

  点击“操作”-新建跳到如图-新建操作界面

  
  

  这个界面可在“程序或脚本”输入框设置脚本运行程序，比如python.exe

  
  

  在“添加参数”输入框设置需要运行脚本路径（包含脚本名）

  
  

  在“起始于”输入框设置脚本执行路径（一般可为脚本目录）

  
  

  

  
  


• 
  

  其他选项卡也可以看看，

  
  

  全部填写完可以点击“创建任务”界面上的“确定”按钮，

  
  

  然后在列表中找到新建的任务点击可查看，

  
  

  

  
  


• 
  

  实时执行测试的话可以点击上图“运行”按钮

  
  

  或者右击任务-运行即可

  
  

  任务执行结果如下：

  
  

哈哈，如题所说，对于很多人来说写正则就是”兰德里的折磨“吧。如果不是有需求频繁要用，根本就不会想着学它。(?!^)(?=(\\d{3})+ 这种就跟外星文一样。

但你要说是用它，它又真的好用。用来做做校验、做做字符串提取、做做变形啥的，真不错。最好的就是能 CV 过来直接用~

本篇带来 15 个正则使用场景，按需索取，收藏恒等于学会！！

千分位格式化

在项目中经常碰到关于货币金额的页面显示，为了让金额的显示更为人性化与规范化，需要加入货币格式化策略。也就是所谓的数字千分位格式化。

1. 123456789 => 123,456,789


2. 123456789.123 => 123,456,789.123

const formatMoney = (money) => {

  return money.replace(new RegExp(`(?!^)(?=(\\d{3})+${money.includes('.') ? '\\.' : '$'})`, 'g'), ',')  

}



formatMoney('123456789') // '123,456,789'

formatMoney('123456789.123') // '123,456,789.123'

formatMoney('123') // '123'

想想如果不是用正则，还可以用什么更优雅的方法实现它？

解析链接参数

你一定常常遇到这样的需求，要拿到 url 的参数的值，像这样：

// url 



const name = getQueryByName('name') // fatfish

const age = getQueryByName('age') // 100

通过正则，简单就能实现 getQueryByName 函数：

const getQueryByName = (name) => {

  const queryNameRegex = new RegExp(`[?&]${name}=([^&]*)(&|$)`)

  const queryNameMatch = window.location.search.match(queryNameRegex)

  // Generally, it will be decoded by decodeURIComponent

  return queryNameMatch ? decodeURIComponent(queryNameMatch[1]) : ''

}



const name = getQueryByName('name')

const age = getQueryByName('age')



console.log(name, age) // fatfish, 100

驼峰字符串

JS 变量最佳是驼峰风格的写法，怎样将类似以下的其它声明风格写法转化为驼峰写法？

1. foo Bar => fooBar

2. foo-bar---- => fooBar

3. foo_bar__ => fooBar

正则表达式分分钟教做人：

const camelCase = (string) => {

  const camelCaseRegex = /[-_\s]+(.)?/g

  return string.replace(camelCaseRegex, (match, char) => {

    return char ? char.toUpperCase() : ''

  })

}



console.log(camelCase('foo Bar')) // fooBar

console.log(camelCase('foo-bar--')) // fooBar

console.log(camelCase('foo_bar__')) // fooBar

小写转大写

这个需求常见，无需多言，用就完事儿啦：

const capitalize = (string) => {

  const capitalizeRegex = /(?:^|\s+)\w/g

  return string.toLowerCase().replace(capitalizeRegex, (match) => match.toUpperCase())

}



console.log(capitalize('hello world')) // Hello World

console.log(capitalize('hello WORLD')) // Hello World

实现 trim()

trim() 方法用于删除字符串的头尾空白符，用正则可以模拟实现 trim：

const trim1 = (str) => {

  return str.replace(/^\s*|\s*$/g, '') // 或者 str.replace(/^\s*(.*?)\s*$/g, '$1')

}



const string = '   hello medium   '

const noSpaceString = 'hello medium'

const trimString = trim1(string)



console.log(string)

console.log(trimString, trimString === noSpaceString) // hello medium true

console.log(string)

trim() 方法不会改变原始字符串，同样，自定义实现的 trim1 也不会改变原始字符串；

HTML 转义

防止 XSS 攻击的方法之一是进行 HTML 转义，符号对应的转义字符：

正则处理如下：

const escape = (string) => {

  const escapeMaps = {

    '&': 'amp',

    '<': 'lt',

    '>': 'gt',

    '"': 'quot',

    "'": '#39'

  }

  // The effect here is the same as that of /[&<> "']/g

  const escapeRegexp = new RegExp(`[${Object.keys(escapeMaps).join('')}]`, 'g')

  return string.replace(escapeRegexp, (match) => `&${escapeMaps[match]};`)

}



console.log(escape(`

  


    
hello world


  


`))

/*

<div>

  <p>hello world</p>

</div>

*/

HTML 反转义

有了正向的转义，就有反向的逆转义，操作如下：

const unescape = (string) => {

  const unescapeMaps = {

    'amp': '&',

    'lt': '<',

    'gt': '>',

    'quot': '"',

    '#39': "'"

  }

  const unescapeRegexp = /&([^;]+);/g

  return string.replace(unescapeRegexp, (match, unescapeKey) => {

    return unescapeMaps[ unescapeKey ] || match

  })

}



console.log(unescape(`

  <div>

    <p>hello world</p>

  </div>

`))

/*



  
hello world




*/

校验 24 小时制

处理时间，经常要用到正则，比如常见的：校验时间格式是否是合法的 24 小时制：

const check24TimeRegexp = /^(?:(?:0?|1)\d|2[0-3]):(?:0?|[1-5])\d$/

console.log(check24TimeRegexp.test('01:14')) // true

console.log(check24TimeRegexp.test('23:59')) // true

console.log(check24TimeRegexp.test('23:60')) // false

console.log(check24TimeRegexp.test('1:14')) // true

console.log(check24TimeRegexp.test('1:1')) // true

校验日期格式

常见的日期格式有：yyyy-mm-dd, yyyy.mm.dd, yyyy/mm/dd 这 3 种，如果有符号乱用的情况，比如2021.08/22，这样就不是合法的日期格式，我们可以通过正则来校验判断：

const checkDateRegexp = /^\d{4}([-\.\/])(?:0[1-9]|1[0-2])\1(?:0[1-9]|[12]\d|3[01])$/



console.log(checkDateRegexp.test('2021-08-22')) // true

console.log(checkDateRegexp.test('2021/08/22')) // true

console.log(checkDateRegexp.test('2021.08.22')) // true

console.log(checkDateRegexp.test('2021.08/22')) // false

console.log(checkDateRegexp.test('2021/08-22')) // false

匹配颜色值

在字符串内匹配出 16 进制的颜色值：

const matchColorRegex = /#(?:[\da-fA-F]{6}|[\da-fA-F]{3})/g

const colorString = '#12f3a1 #ffBabd #FFF #123 #586'



console.log(colorString.match(matchColorRegex))

// [ '#12f3a1', '#ffBabd', '#FFF', '#123', '#586' ]

判断 HTTPS/HTTP

这个需求也是很常见的，判断请求协议是否是 HTTPS/HTTP

const checkProtocol = /^https?:/



console.log(checkProtocol.test('https://medium.com/')) // true

console.log(checkProtocol.test('http://medium.com/')) // true

console.log(checkProtocol.test('//medium.com/')) // false

校验版本号

版本号必须采用 x.y.z 格式，其中 XYZ 至少为一位，我们可以用正则来校验：

// x.y.z

const versionRegexp = /^(?:\d+\.){2}\d+$/



console.log(versionRegexp.test('1.1.1'))

console.log(versionRegexp.test('1.000.1'))

console.log(versionRegexp.test('1.000.1.1'))

获取网页 img 地址

这个需求可能爬虫用的比较多，用正则获取当前网页所有图片的地址。在控制台打印试试，太好用了~~

const matchImgs = (sHtml) => {

  const imgUrlRegex = /]+src="((?:https?:)?\/\/[^"]+)"[^>]*?>/gi

  let matchImgUrls = []

  

  sHtml.replace(imgUrlRegex, (match, $1) => {

    $1 && matchImgUrls.push($1)

  })

  return matchImgUrls

}



console.log(matchImgs(document.body.innerHTML))

格式化电话号码

这个需求也是常见的一匹，用就完事了：

let mobile = '18379836654' 

let mobileReg = /(?=(\d{4})+$)/g 



console.log(mobile.replace(mobileReg, '-')) // 183-7983-6654

觉得不错的话，给个赞吧，以后继续补充~~

实现效果

实现方式

主要使用了

• radial-gradient


• transform


• perspective


• rotateX


• transform-origin

等属性

思路

• 只需要想清楚如何实现弧形三角即可。这里还是借助了渐变 -- 径向渐变

• 其实他是这样，如下图所示，我们只需要把黑色部分替换为透明即可，使用两个伪元素即可：

• 通过超出隐藏和旋转得到想要的效果

• 综上

在上述 outside-circle 的图形基础上：

1. 设置一个适当的 perspective 值


2. 设置一个恰当的旋转圆心 transform-origin


3. 绕 X 轴进行旋转

• 动图演示

代码

<!DOCTYPE html>

<html lang="en">

<head>

  <meta charset="UTF-8">

  <meta http-equiv="X-UA-Compatible" content="IE=edge">

  <meta name="viewport" content="width=device-width, initial-scale=1.0">

  <title>Document</title>

</head>

<style>

  .g-container {

    position: relative;

    width: 300px;

    height: 100px;

    background: red;

    border: 1px solid #277f9e;

    border-radius: 10px;

    overflow: hidden;

}

.g-inner {

    position: absolute;

    width: 150px;

    height: 50px;

    background: #fee6e0;

    bottom: 0;

    border-radius: 0 20px 0 20px;

    transform: perspective(40px) scaleX(1.4) scaleY(1.5) rotateX(20deg) translate(-10px, 0);

    transform-origin: 50% 100%;

}

.g-inner::before {

    content: "";

    position: absolute;

    right: -10px;

    width: 10px;

    height: 10px;

    top: 40px;

    background: radial-gradient(circle at 100% 0, transparent, transparent 9.5px, #fee6e0 10px, #fee6e0);

}

.g-after {

    position: absolute;

    width: 150px;

    height: 50px;

    background: #6ecb15;

    bottom: 49px;

    right: 0;

    border-radius: 20px 0 20px 0;

    transform: perspective(40px) scaleX(1.4) scaleY(-1.5) rotateX(20deg) translate(14px, 0);

    transform-origin: 53% 100%;

}

.g-after::before {

    content: "";

    position: absolute;

    left: -10px;

    top: 40px;

    width: 10px;

    height: 10px;

    background: radial-gradient(circle at 0 0, transparent, transparent 9.5px, #6ecb15 10px, #6ecb15);

}

.g-inner-text,.g-after-text {

  position: absolute;

  width: 150px;

  height: 50px;

  line-height: 50px;

  text-align: center;

}

.g-inner-text {

  top: 50%;

  left: 0;

}

.g-after-text {

  top: 50%;

  right: 0;

}

</style>

<body>

  <div class="g-container">

    <div class="g-inner"></div>

    <div class="g-after"></div>

    <div class="g-inner-text">选项卡1</div>

    <div class="g-after-text">选项卡2</div>

  </div>

</body>

</html>

参考文章：github.com/chokcoco/iC…

为了让页面保活更加稳定，你们是怎么做的？

我用一行配置实现了

Vue页面保活是指在用户离开当前页面后，可以在返回时恢复上一次浏览页面的状态。这种技术可以让用户享受更加流畅自然的浏览体验，而不会被繁琐的操作打扰。

为什么需要页面保活？

页面保活可以提高用户的体验感。例如，当用户从一个带有分页的表格页面（【页面A】）跳转到数据详情页面（【页面B】），并查看了数据之后，当用户从【页面B】返回【页面A】时，如果没有页面保活，【页面A】会重新加载并跳转到第一页，这会让用户感到非常烦恼，因为他们需要重新选择页面和数据。因此，使用页面保活技术，当用户返回【页面A】时，可以恢复之前选择的页码和数据，让用户的体验更加流畅。

如何实现页面保活？

状态存储

这个方案最为直观，原理就是在离开【页面A】之前手动将需要保活的状态存储起来。可以将状态存储到LocalStore、SessionStore或IndexedDB。在【页面A】组件的onMounted钩子中，检测是否存在此前的状态，如果存在从外部存储中将状态恢复回来。

有什么问题？

• 浪费心智（麻烦/操心）。这个方案存在的问题就是，需要在编写组件的时候就明确的知道跳转到某些页面时进行状态存储。


• 无法解决子组件状态。在页面组件中还可以做到保存页面组件的状态，但是如何保存子组件呢。不可能所有的子组件状态都在页面组件中维护，因为这样的结构并不是合理。

组件缓存

利用Vue的内置组件<KeepAlive/>缓存包裹在其中的动态切换组件（也就是<Component/>组件）。<KeepAlive/>包裹动态组件时，会缓存不活跃的组件，而不是销毁它们。当一个组件在<KeepAlive/>中被切换时，activated和deactivated生命周期钩子会替换mounted和unmounted钩子。最关键的是，<KeepAlive/>不仅适用于被包裹组件的根节点，也适用于其子孙节点。

<KeepAlive/>搭配vue-router即可实现页面的保活，实现代码如下：

<template>

  <RouterView v-slot="{ Component }">

    <KeepAlive>

      <component :is="Component"/>

    </KeepAlive>

  </RouterView>

</template>

有什么问题？

• 页面保活不准确。上面的方式虽然实现了页面保活，但是并不能满足生产要求，例如：【页面A】是应用首页，【页面B】是数据列表页，【页面C】是数据详情页。用户查看数据详情的动线是：【页面A】->【页面B】->【页面C】，在这条动线中【页面B】->【页面C】的时候需要缓存【页面B】，当从【页面C】->【页面B】的时候需要从换从中恢复【页面B】。但是【页面B】->【页面A】的时候又不需要缓存【页面B】，上面的这个方法并不能做到这样的配置。

最佳实践

最理想的保活方式是，不入侵组件代码的情况下，通过简单的配置实现按需的页面保活。

【不入侵组件代码】这条即可排除第一种方式的实现，第二种【组件缓存】的方式只是败在了【按需的页面保活】。那么改造第二种方式，通过在router的路由配置上进行按需保活的配置，再提供一种读取配置结合<KeepAlive/>的include属性即可。

路由配置

src/router/index.ts

import useRoutersStore from '@/store/routers';



const routes: RouteRecordRaw[] = [

  {

    path: '/',

    name: 'index',

    component: () => import('@/layout/index.vue'),

    children: [

      {

        path: '/app',

        name: 'App',

        component: () => import('@/views/app/index.vue'),

      },

      {

        path: '/data-list',

        name: 'DataList',

        component: () => import('@/views/data-list/index.vue'),

        meta: {

          // 离开【/data-list】前往【/data-detail】时缓存【/data-list】

          leaveCaches: ['/data-detail'],

        }

      },

      {

        path: '/data-detail',

        name: 'DataDetail',

        component: () => import('@/views/data-detail/index.vue'),

      }

    ]

  }

];



router.beforeEach((to: RouteLocationNormalized, from: RouteLocationNormalized, next: NavigationGuardNext) => {

  const { cacheRouter } = useRoutersStore();

  cacheRouter(from, to);

  next();

});

保活组件存储

src/stroe/router.ts

import { RouteLocationNormalized } from 'vue-router';



const useRouterStore = defineStore('router', {

  state: () => ({

    cacheComps: new Set<string>(),

  }),

  actions: {

    cacheRouter(from: RouteLocationNormalized, to: RouteLocationNormalized) {

      if(

        Array.isArray(from.meta.leaveCaches) && 

        from.meta.leaveCaches.inclued(to.path) && 

        typeof from.name === 'string'

      ) {

        this.cacheComps.add(form.name);

      }

      if(

        Array.isArray(to.meta.leaveCaches) && 

        !to.meta.leaveCaches.inclued(from.path) && 

        typeof to.name === 'string'

      ) {

        this.cacheComps.delete(to.name);

      }

    },

  },

  getters: {

    keepAliveComps(state: State) {

      return [...state.cacheComps];

    },

  },

});

页面缓存

src/layout/index.vue

<template>

  <RouterView v-slot="{ Component }">

    <KeepAlive :include="keepAliveComps">

      <component :is="Component"/>

    </KeepAlive>

  </RouterView>

</template>



<script lang='ts' setup>

import { storeToRefs } from 'pinia';

import useRouterStore from '@/store/router';



const { keepAliveComps } = storeToRefs(useRouterStore());

</script>

TypeScript提升配置体验

import 'vue-router';



export type LeaveCaches = string[];



declare module 'vue-router' {

  interface RouteMeta {

    leaveCaches?: LeaveCaches;

  }

}

该方案的问题

• 缺少通配符处理/*、/**/index。


• 无法缓存/preview/:address这样的动态路由。


• 组件名和路由名称必须保持一致。

总结

通过<RouterView v-slot="{ Component }">获取到当前路由对应的组件，在将该组件通过<component :is="Component" />渲染，渲染之前利用<KeepAlive :include="keepAliveComps">来过滤当前组件是否需要保活。
基于上述机制，通过简单的路由配置中的meta.leaveCaches = [...]来配置从当前路由出发到哪些路由时，需要缓存当前路由的内容。

如果大家有其他保活方案，欢迎留言交流哦！

开头

这里主要是根据 vue 递归组件 作用域插槽 代码的理解和el-tree是如何写的。

代码

父组件

<template>

  <div>

    <Tree :data="data">

      <template #default="{ title }">

        <div class="prent">

          {{ title + "+自定义" }}

        </div>

      </template>

    </Tree>

  </div>

</template>

<script>

import Tree from "./tree.vue";

export default {

  components: {

    Tree,

  },

  data() {

    return {

      data: [{

        title: "父1",

        children: [{

          title: "子",

          children:[{title:"孙",}]

        }],

      },{

        title: "父2",

        children:[{title:"子"}]

      }]

    };

  }

};

</script>

子组件

<template>

  <div class="tree">

    <div v-for="item of data" :key="item.title">

      <!-- 显示title标题 -->

      <div class="title">

        <!-- 插槽，这里也是把title传出去, A插槽 -->

        <slot :title="item.title">

          <!-- {{ item.title }} -->

        </slot>

      </div>

      <!-- 如果存在子项则调用本身组件 递归 -->

      <Tree v-if="item.children" :data='item.children'>

            <!-- B 插槽 -->

          <slot :title='item.title' />

      </Tree>

    </div>

  </div>

</template>



<script>

export default {

  name: 'Tree',

  props: {

    data: Array,

  },

};

</script>



<style scoped>

.tree {

  padding-left: 10px;

}



ul,

li {

  list-style: none;

  margin: 0;

  padding: 0;

}

</style>

理解步骤,始终知道 -> 递归就是把最里面的放到最外面来，你就当 A插槽最后会被 B 插槽替代。

所以，父组件的 default 插槽用的是 B 插槽，因此 B 插槽就暴露出一个 title 给父组件使用。

删掉 A 的title ：

<template>

  <div class="tree">

    <div v-for="item of data" :key="item.title">

      <!-- 显示title标题 -->

      <div class="title">

        <!-- 插槽，这里也是把title传出去, A插槽 -->

        <slot :title="item.title">

          <!-- {{ item.title }} -->

        </slot>

      </div>

      <!-- 如果存在子项则调用本身组件 递归 -->

      <Tree v-if="item.children" :data='item.children'>

            <!-- B 插槽 -->

          <slot :title='item.title' />

      </Tree>

    </div>

  </div>

</template>



<script>

export default {

  name: 'Tree',

  props: {

    data: Array,

  },

};

</script>



<style scoped>

.tree {

  padding-left: 10px;

}



ul,

li {

  list-style: none;

  margin: 0;

  padding: 0;

}

</style>

结果：

由于可能只有一层，所以走不到 B 插槽，因此 A 插槽也需要暴露一个 title 给外面使用。

el-tree 的原理

父组件

<template>

  <div>

    <Tree :data="data">

        <!-- C -->

      <template #default="{ title }">

        <div class="prent">

          {{ title + "+自定义" }}

        </div>

      </template>

    </Tree>

  </div>

</template>

<script>

import Tree from "./tree.vue";

export default {

  components: {

    Tree,

  },

  data() {

    return {

      data: [{

        title: "父1",

        children: [{

          title: "子",

          children:[{title:"孙",}]

        }],

      },{

        title: "父2",

        children:[{title:"子"}]

      }]

    };

  }

};

</script>

子组件

<template>

  <div class="tree">

    <div v-for="item of data" :key="item.title">

      <!-- 显示title标题 -->

      <div class="title">

        <!-- 插槽，这里也是把title传出去, A -->

        <slot :title="item.title">

          <!-- {{ item.title }} -->

        </slot>

      </div>

      <!-- 如果存在子项则调用本身组件 递归 -->

      <Tree v-if="item.children" :data='item.children'>

        <!-- B -->

        <template #default="{ title }">

          <div class="prent">

            {{ title + "+自定义22" }}

          </div>

        </template>

      </Tree>

    </div>

  </div>

</template>



<script>

import node from './node.js'

export default {

  name: 'Tree',

  components: {

    node,

    

  },

  props: {

    data: Array,

  },

  data() {

    return {

      tree: null,

    }

  },

  created() {

    if(!this.$parent.$scopedSlots.default) {

      this.tree = this

    }else {

      this.tree = this.$parent.tree

    }

  },

};

</script>



<style scoped>

.tree {

  padding-left: 10px;

}



ul,

li {

  list-style: none;

  margin: 0;

  padding: 0;

}

</style>

结果：

这里可以看到，父组件的 C 和 子组件中的 B 都是使用到了 A 这个插槽。

这里我们只要能把 B 替换成父组件的 C 就完成了递归插槽。

子组件的代码转变

<template>

  <div class="tree">

    <div v-for="item of data" :key="item.title">

      <!-- 显示title标题 -->

      <div class="title">

        <!-- 插槽，这里也是把title传出去 -->

        <slot :title="item.title">

          <!-- {{ item.title }} -->

        </slot>

      </div>

      <!-- 如果存在子项则调用本身组件 递归 -->

      <Tree v-if="item.children" :data='item.children'>

        <template #default="{ title }">

          <node :title="title">

          </node>

        </template>

      </Tree>

    </div>

  </div>

</template>



<script>

import node from './node.js'

export default {

  name: 'Tree',

  components: {

    node: {

      props: {

        title: String,

      },

      render(h) {

        const parent = this.$parent;

        const tree = parent.tree

        const title = this.title

        return (tree.$scopedSlots.default({ title }))

      }

    }

  },

  props: {

    data: Array,

  },

  data() {

    return {

      tree: null,

    }

  },

  created() {

    if (!this.$parent.$scopedSlots.default) {

      this.tree = this

    } else {

      this.tree = this.$parent.tree

    }

  },

};

</script>



<style scoped>

.tree {

  padding-left: 10px;

}



ul,

li {

  list-style: none;

  margin: 0;

  padding: 0;

}

</style>

这里搞了一个 node 的函数组件，node 函数组件拿到 子组件的 tree， tree也是一层层的保存着 $scopedSlots.default 其实就是 C 的那些编译节点。 然后把 title 传给了 C。

el-tree 源码贴图

tree

tree-node

总结

写的有点乱啊，这个只是辅助你理解 递归插槽，其实一开始都是懵逼了，多看下代码理解还是能看的懂的。

前端部署需要用户刷新才能继续使用，一直是一个老大难的用户体验问题。本文将围绕这个问题进行讲解，揭晓问题发生的原因及解决思路。

一、背景

网站发版过程中，用户可在浏览web页面时，可能会导致页面无法加载对应的资源，导致出现点击无反应的情况，严重影响用户体验。

二、问题分析

2.1 问题现象

网络控制台显示加载页面的资源显示404。

2.2 满足条件

发生这个现象，需要满足三个条件：

1. 站点是SPA页面，并开启懒加载；


2. 资源地址启用内容hash。（加载更快启用了强缓存，为了应对资源变更能及时更新内容，会对资源地址的文件名加上内容hash）。


3. 覆盖式部署，新版本发布后旧的版本会被删除。

特别在容器部署的情况的SPA页面，很容易满足上诉三个条件。笔者在做公司的内部系统就踩过坑。

2.3 原因分析

浏览器打开页面后，会记录路由和资源路径的映射，服务器发版后，没有及时通知浏览器更新路由映射表。导致用户在发布前端打开的页面，在版本更新后，进入下一个路由加载上一个版本的资源失败，导致需要用户刷新才能正常使用。

三、解决方案

3.1 方案一：失败重试

3.1.1 思路整理：

既然加载失败了，就重试加载发版后的资源版本就行。增加一个manifest.json文件能够获取新版本对应的资源路径。

3.1.2 举例说明

以vue项目进行举例子说明：

第一步: 修改构建工具配置以生成manifest文件

使用vite构建的项目，可以在vite.config.ts增加配置build.manifest为true，用以生成manifest.json文件

export default defineConfig({

  // 更多配置

  build: {

    //开启manifest

    manifest: true,

    cssCodeSplit: false //关闭单独生成css文件，方便demo演示

  }

})

如果使用webpack构建的项目，可以使用webpack-manifest-plugin插件进行配置。

进行项目生产构建，生成manifest.json，内容如下：

 // 简单说明：文件内容是项目原始代码目录结构和构建生成的资源路径一一对应

{

  "index.html": { // 页面入口

    "dynamicImports": ["src/pages/page1.vue", "src/pages/page2.vue"],

    "file": "assets/index-e170761c.js",

    "isEntry": true,

    "src": "index.html"

  },

   // page1对应单文件组件

  "src/pages/page1.vue": {

    "file": "assets/page1-515906ab1.js", // JS文件

    "imports": ["index.html"],

    "isDynamicEntry": true,

    "src": "src/pages/page1.vue"

  },

   // page2对应单文件组件

  "src/pages/page2.vue": {

    "file": "assets/page2-9785c68c.js", // JS文件

    "imports": ["index.html"],

    "isDynamicEntry": true,

    "src": "src/pages/page2.vue"

  },

  "style.css": {

    "file": "assets/style-809e5baa.css",

    "src": "style.css"

  }

}