最近，和我打球几个美团的小伙伴，基本都是30岁出头，多数都刚结婚生娃，开始步入中年，面对互联网正在进行的重大变革，有些焦虑，更有些迷茫。

我永远坚信：选择比奋斗更重要，因为奋斗只体现你的勤奋与毅力，而选择则彰显你的智慧与信念。我是18年步入30岁，转眼已经五年，借此回顾一下自己所做的思考和选择，希望能帮助到他人，也能为自己接下来的选择明确方向。

30多岁的人，多数人上有老下有小，既是国家的中坚力量，更是家庭的支柱。我们既要为国家创造财富，更要增加自己小家的收入。

受面向对象编程的启发，我觉得面向提升收入来展开本文，文章的结构和层级会更好，也会更吸引人，而且能够切实帮助到读者。

确保身心健康

身体是革命的本钱，没有良好的身心状态，即使我们赚了很多钱，也得花钱治病。这些年，我头顶的头发稀疏了很多，特别是最近这一两年，因为两个娃比较小，经常需要半夜起床哄娃，经常得不到充分的休息，肠胃也出现了一些问题。

为了解决身体上出现的问题，我主要通过中医、跑长跑和打篮球来调理和强身健体。在中医方面，自学了一些基础理论，比如背下了黄帝内经的上古天真论，避免选择医院或按摩店时，被人忽悠。

这两年，去三甲医院找中医开了三次中药，喝完一个疗程后，感觉帮助不大，倒是在小区的按摩店，通过揉肚子，配合艾灸，能有一定效果。总的来说，我肠胃的问题，主要是吃水果没有节制和吃饭太快引起的，要想根治，得从习惯入手。

除了饮食习惯，还得保持锻炼的习惯，所以22年初，我给自己定了三个习惯：每周至少跑10公里强体魄，每周至少读一本好书启智慧，每周至少做一次公益得快乐。

对了跑步，挺难坚持的，所以我会发动我老婆监督，一次做不到就罚款2万元给她。对于读书，结合育儿的需要，我买了一百本育儿书，正好自己有两个娃，学完就能用得上。而对于公益，我有时会带着大儿子去公园拣烟头，有时会自己到寺庙做义工。

成为技术专家

如果是本科毕业，到了30岁的时候，应该有七八年的工作经验了，硕士的话，也有五六年了，此时不管你愿不愿意，都会成为团队的技术骨干，甚至是架构师。

我是从28岁就开始带团队，在面试30岁左右的候选人时，如果他们还不能成为某个领域的技术专家，我基本上只会意思聊十多分钟，当然如果候选人，应聘的是外包岗位，可能会酌情考虑。

那么怎么样，可以称为技术专家呢，用美团最新职级标准来看的话，就是L7+的同学，差不多对应阿里P7的同学。

我参与过多个公司职级标准的制定，记得曾经和某个HR讨论时，她提出要我用一句话来总结，那就是：不仅能独立完成架构设计、技术难题公关和带领其他研发完成技术实现，而且能从整个研发流程出发提升整体的研发质量、效率和用户体验。

在此基础上，对于前端同学，如果想要获得高薪，就得需要花时间专研一些特定方向的技术，比如图形学(具备自研3D渲染引擎的能力)、音视频处理(掌握WebAssembly技术，深入研究opencv、ffmpeg等)、端智能(需要掌握深度学习及其模型的相关知识)。

从我认识的朋友来看，资深的web图形学技术专家和音视频处理专家，年薪能有150万左右，而端智能前端同学去做的比较少，多数是有算法背景的同学，年薪也有120万起。

从美团合并通道的导向来看，对于技术专家，既有广度的要求，更有特定领域技术深度的要求，你掌握的特定技术越不可替代，越容易拿到高薪。

转型做管理

不管处于什么阶段，管理都是我们需要面对的。从踏入职场开始，我们首先要做好自我管理，高效人士的七个习惯，前三个都是和自我管理有关的。

其次，我们需要做好向上管理，不管是我遇到的几个领导，还是我自己，都是比较喜欢和欢迎，下属做好充分准备好，能够积极主动地约我们，聊聊自己的困惑、工作上的思考和改进建议等。

再次，我们需要做好同事管理，如果不能很好地融入团队及企业文化，不仅自己开展工作比较困难，而且在需要裁员时，这样的同学都是会优先考虑要裁掉的。

最后，对于30岁左右的同学，即使不是实线管理者，通常也需要带着多个同学一起完成工作，就不得不强化自己向下管理的能力。像在美团，我们提拔一个同学做leader的时候，往往会先给几个同学或项目让该同学负责，看看其是否合适，合适的同学，有机会时就会优先考虑他，否则就重新招聘。

互联网研发的流动性很大，对于30岁左右的同学，不管当前有没有向下管理的机会，我都建议大家平时多去观察和思考，从职业发展的角度看，即使得跳槽，也要争取有一段向下管理的实践，否则35岁之后，好的就业机会就非常少了。

寻找副业

程序员可以选择的副业有很多种，以下是一些建议：

• 写作：撰写技术文章或教程，发布在博客、公众号、知乎等平台上。通过广告和付费阅读等方式，可以获得一定的收入。


• 创立个人品牌：通过积累经验和作品，创立自己的个人品牌，提高个人影响力。这可以为你带来更多商业机会，如演讲、顾问、培训等。


• 接私活：在业余时间为其他公司或个人完成项目，如网站开发、小程序、APP 等。你可以在一些平台（如猪八戒、实现网、码市等）上找到相关项目，或者通过朋友和同事介绍获得更多机会。


• 做个人博客或开源项目：通过分享自己的技术经验和心得，吸引更多人关注并建立个人品牌。这可以为你带来一些广告收入和合作机会。同时，参与开源项目可以提高你的技术水平，也有助于拓展人际关系。


• 网络兼职：利用自己的技能在一些在线教育平台上教授前端课程，如慕课网、极客时间等。你还可以在一些问答平台（如知乎、Stack Overflow）上回答问题，帮助他人解决问题，提高自己的知名度。


• 开发移动应用：如果你对移动开发有兴趣，可以尝试开发自己的应用，上架到应用商店。通过广告和内购等方式，你可以获得持续的收入。


• 开发小游戏：如果你对游戏开发有兴趣，可以尝试开发自己的小游戏，发布在微信小程序、抖音等平台上。通过广告和内购等方式，你可以获得持续的收入。

总之，程序员可以选择的副业方向很多，关键在于发掘自己的兴趣和优势，并付诸实践。同时，副业也需要长期坚持和投入，才能获得稳定的收益。

敢于创业

程序员的尽头是什么？有人说，程序员尽头就是不做程序员。那么，不做程序员又能做什么？

信息时代，为90后提供了更多的机会和资源，让他们拥有良好的教育背景和丰富的知识储备，更好地掌握专业知识和技能，为创业打下坚实的基础。

众多创业者在创业前期，或因受到“偶像”或“故事”激励，从而走上创业之路，比如点燃雷军内心的那本《硅谷之火》，他为此认定创业是自己要走的路。

其实，人生的各个阶段都有不同的人激励我创业，以前卓越教育的校长给予我很多工作和人生方向上的指引。但我始终坚信“创业需要发自内心”，我不会因为看到某个人的故事就热血澎湃。

创业者在任何社会的群体中都是少数派，不到 1% 。就算中国最好的理工类大学也没有很多学生创业，反而他们会选择去留学、当科学家、成为公务员。创业要去无人之境、蛮荒之地，要去开创一个新的事业，往往是不被大众认可的。

程序员创富相对比较容易，是因为现在世界上最有价值的都是科技公司，程序员先天离这些公司的核心价值最近。比尔·盖茨、Larry Page、李彦宏、马化腾、张一鸣都是程序员，科技公司预估有超过一半的老板都有程序员背景，从概率的角度来看，程序员创富比其他职业更容易一点。

原因也比较简单，如果是销售人员担任 CEO，他们还得招几个程序员来构建自己的核心竞争力。而程序员作为公司创业的核心，可以不依赖别人就可以启动创业项目，且只要有两个人就可以启动了。

程序员创业有优势，但也并不是适合所有类型的项目。其中，科技创新的项目显然技术人员做 CEO 最为合适，比如研发搜索引擎，不管美国还是中国，CEO 基本上都是技术背景，因为搜索引擎是技术驱动的领域。

然而，我看见了 500~1000 个程序员创业，有 90% 的失败率，多数是回去上班接着打工去了，还有 9% 拥有一个小公司“不死不活”，每年有几十万到一两百万的收入，对个人来讲，算是创业成功。

但从 VC 投资或者个人事业追求的角度，年营业额上了 1,000 万以上，不管是技术驱动、产品驱动、销售驱动型的公司，都是 1% 以下的比例。

程序员创业要闯三关：

• 首先是技术关，通常这是程序员最容易闯的一关，因为程序员创业肯定会找相对熟悉的领域去做。


• 其次业务观，有一定挑战。因为做 2C 要能获客，做 2B 要能搞定客户。逻辑思维能力也很重要，但不是全部。2C 比较适合逻辑思维能力，程序员背景的人肯定能搞得很明白。2B 获客更多是软技能，其中包括察言观色、判断对方角色、决策链决策逻辑等，并不是所有的程序员都能做得好。


• 最后是组织关。公司人很少的时候，20人以内每个人都认识，不太需要过多的管理机制。但如果公司到了 100 人甚至更多，组织能力没到，人越多效率越低，这是非常大的障碍。

所以程序员除了固有的理性思维能力之外，还要能培养跟人打交道的能力，培养个人魅力，同时对组织管理要有敬畏之心。

总结

转眼，我已过30岁有五年了。从本科毕业到军校培训担任班长，到下到连队当排长管理40多人，然后退出现役成为小白程序员，然后在29岁时成为高级技术经理，管理20多人团队，收入也从月薪9k涨到了50k。

30岁以后，尝试过成为图形学和端智能领域的技术专家，也短暂创过业，上班时接过私活，也投入很多精力搞副业，最后美团的合同到期后，选择了先离职休养一段时间。

目前的计划是，再休息一个月，然后决定继续上班，还是基于副业去创业。

相信这个特效你和你的朋友（或对象）一定玩过



当你发送一个便便的表情，对方如果扔一个炸弹表情，就会立刻将这个便便炸开，实现满屏粑粑的“酷炫”画面。可谓是“臭味十足”，隔着屏幕都能感受到来自微信爸爸的满满恶意。

不清楚大家对这个互动设计怎么看，反正一恩当时是喜欢的不行，拉着朋友们就开始“炸”得不亦乐乎。

同样被虏获芳心的设计小哥哥在玩到尽兴后，突然灵感大发，连夜绘制出了设计稿，第二天就拉上产品和研发开始脑暴。

“微信炸💩打动我的一点是他满屏的设计，能够将用户强烈的情绪抒发出来；同时他能够与上一条表情进行捆绑，加强双方的互动性。”设计小哥哥声情并茂道。

“所以，让我们的表情也‘互动’起来吧！”

这不，需求文档就来了：

改掉常见的emoji表情发送方式，替换为动态表情交互方式。即，

当用户发送或接收互动表情，表情会在屏幕上随机分布，展示一段时间后会消失。

用户可以频繁点击并不停发送表情，因此屏幕上的表情是可以非常多且重叠的，能够将用户感情强烈抒发。



（暂用微信的聊天界面进行解释说明，图1为原样式，图2是需求样式）

这需求一出，动态表情在屏幕上的分布方案便引起了研发内部热烈讨论：当用户点击表情时，到底应该将表情放置在屏幕哪个位置比较好呢？

最直接的做法就是完全随机方式：取0到屏幕宽度和高度中随机值，放置表情贴纸。但这么做的不确定因素太多，比如存在一定几率所有表情都集中在一个区域，布局边缘化以及最差的重叠问题。因此简单的随机算法对于用户的体验是无法接受的。

我们开始探索新的方案：

因为目前点的选择依赖于较多元素，比如与屏幕已有点的间距，与中心点距离以及屏幕已有点的数目。因此最终决定采用点权随机的方案，根据上述元素决策出屏幕上可用点的优度，选取优度最高的插入表情。

基本思路

维护对应屏幕像素的二维数组，数组元素代指新增图形时，图形中心取该点的优度。

采用懒加载的方式，即每次每次新增图形后，仅记录现有方块的位置，当需要一个点的优度时再计算。

遍历所有方块的位置，将图形内部的点优度全部减去 A ，将图形外部的点按到图形的曼哈顿距离从 0 到 max (W,H)，映射，减 0 到 A * K2。

每次决策插入位置时，随机取 K + n * K1 个点，取这些点中优度最高的点为插入中心

A, K, K1, K2 四个常数可调整

一次选择的复杂度是 n * randT，n 是场上方块数， randT 是本次决策需要随机取多少个点。 从效率和 badcase来说，这个方案目前最优。

代码展示

```cpp

#include <iostream>

#include <vector>

using namespace std;

 

const int screenW = 600;

const int screenH = 800;

 

const int kInnerCost = 1e5;

const double kOuterCof = .1;

 

const int kOutterCost = kInnerCost * kOuterCof;

 

class square

    int x1;

    int x2;

    int y1;

    int y2;

};

 

int lineDist(int x, int y, int p){

    if (p < x) {

        return x - p;

    } else if (p > y) {

        return p - y;

    } else {

        return 0;

    }

}

 

int getVal(const square &elm, int px, int py){

    int dx = lineDist(elm.x1, elm.x2, px);

    int dy = lineDist(elm.y1, elm.y2, py);

    int dist = dx + dy;

    constexpr int maxDist = screenW + screenH;

    return dist ? ( (maxDist - dist) * kOutterCost / maxDist ) : kInnerCost;

}

 

int getVal(const vector<square> &elmArr, int px, int py){

    int rtn = 0;

    for (auto elm:elmArr) {

        rtn += getVal(elm, px, py);

    }

    return rtn;

}

 

int main(void){

    

    int n;

    cin >> n;

 

    vector<square> elmArr;

    for (int i=0; i<n; i++) {

        square cur;

        cin >> cur.x1 >> cur.x2 >> cur.y1 >> cur.y2;

        elmArr.push_back(cur);

    }

 

 

    for (;;) {

        int px,py;

        cin >> px >> py;

        cout << getVal(elmArr, px, py) << endl;

    }

 

}

优化点

1. 该算法最优解偏向边缘。因此随着随机值设置越多，得出来的点越偏向边缘，因此随机值不能设置过多。


2. 为了解决偏向边缘的问题，每一个点在计算优度getVal需要加上与屏幕中心的距离 * n * k3

效果演示

最后就是给大家演示一下最后的效果啦！



圆满完成任务，收工，下班！

前言

这篇文章的起因是，当时上周部门调整，要调动到其他部门，最开始我以为就走个流程意思意思，一点准备都没有。没想到，去其他部门还经过了3面，感觉挺正式的，在这期间问的问题有些令我印象深刻，发现了许多不足吧，我是去年毕业的，工作了1年多了，本来以为一些基础知识掌握的差不多了，路还远着，还得学啊！本来那天我还准备一下班就回去玩战地2042，免费周啊！啪的一下兴趣全无，总结一下知识吧，指不定什么时候用上（手动狗头）

节流

节流是指一定时间内只触发一次函数调用，如果在指定时间内多次触发，执行第一次，其他的触发将会被忽略，直到过了设定的时间间隔才触发。

function throttle (fn,delay) {

    let timer;

    retrun function (...args) {

        if(!timer) {

            fn(this,args)

             timer = settimeout(()=>{

                timer=null

            },delay)

        }

    }

}

防抖

防抖是在函数调用后，在指定时间间隔后才触发一次。如果在这个时间间隔内再次触发函数，将重新计时，直到过了设定的时间间隔才会触发最后一次函数调用。

function debounce (fn,delay) {

    let timer;

    retrun function (...args) {

        if(timer) {

          clearTimetout(timer)

        }

         timer = settimeout(()=>{

             fn(this,args)

              timer=null

         },delay) 

    }

}

数据扁平化

数组

function flatter(arr) {

    let result = []

    for(let i =0;i<arr.length;i++) {

        if(Array.isArray(arr[i]) {

            result = result.concat(flatter(arr[i]))

        } esle {

            result.push(arr[i])

        }

    }

    return result

}

去重

const arr1 = [...new Set(arr)]

const arr1 = arr.map((item,index)=>{

    return arr.indexof(item)==index

})

查找字符串中出现最多的字符

当时手写了一半，str.split(item).length应该还要-1才是当前字符出现的次数

  const str = ref<string>('sdfgsgdd');

  const fn = (str: string) => {

    const arr = Array.from(str);

    let maxCount = 0;

    let mostFrequentChar = '';

    const Nsome = [...new Set(arr)];

    Nsome.forEach((item) => {

      const count = str.split(item).length - 1;

      if (count > maxCount) {

        maxCount = count;

        mostFrequentChar = item;

      }

    });

    console.log('出现最多的次数，字符', maxCount, mostFrequentChar);

  };

闭包及其应用场景

我的回答是：
函数里面嵌套函数，并且内部函数引用了外部函数的变量，就是函数能访问其作用域外的变量

应用场景：
我的回答其中之一是：vueX中状态共享是使用了闭包，节流，防抖
但在 Vuex 中，闭包主要用于封装和共享状态，而不是用于访问和操作外部函数的变量。它使用了闭包的概念，但不是严格意义上的闭包。

1.模块化开发 2.回调函数 3.延迟执行（节流，防抖）

原型&原型链及其应用场景

1. 原型（Prototype）：

• 每个 JavaScript 对象都有一个原型（prototype），它是一个对象。


• 对象的原型用于共享属性和方法，当我们访问一个对象的属性或方法时，如果对象本身没有该属性或方法，JavaScript 会沿着原型链向上查找，直到找到该属性或方法或者到达原型链的顶端。


• 原型可以通过 proto 属性访问，也可以通过 Object.getPrototypeOf() 方法获取。

2. 原型链（Prototype Chain）：

• 原型链是由对象的原型组成的链式结构，它用于实现对象之间的继承。


• 当我们访问一个对象的属性或方法时，如果对象本身没有该属性或方法，JavaScript 会沿着原型链向上查找，直到找到该属性或方法或者到达原型链的顶端。


• 原型链的顶端是 Object.prototype，它是所有对象的原型。

应用场景：

• 继承：通过原型链，我们可以实现对象之间的继承，一个对象可以继承另一个对象的属性和方法。这样可以避免重复定义和维护相似的代码，提高代码的重用性和可维护性。


• 共享属性和方法：通过原型链，我们可以将属性和方法定义在原型上，从而实现对象之间的共享。这样可以节省内存空间，避免重复创建相同的属性和方法。


• 扩展原生对象：通过修改原型链，我们可以扩展 JavaScript 的原生对象，为其添加新的方法和属性。这样可以为原生对象添加自定义的功能，满足特定的需求。

在没有class之前，js是怎么做面向对象的

没答出来，只知道js可以通过class实现面向对象，然后又被问在没有class之前，js是怎么做面向对象的。这也是原型链的应用场景之一，可能是前面原型链的应用场景没说这个，想给我一个提示。

在没有class关键字之前，JavaScript使用原型继承来实现面向对象编程。
javaScript 中的每个对象都有一个原型（prototype），原型是一个对象，它包含了共享的属性和方法。当我们访问一个对象的属性或方法时，如果对象本身没有该属性或方法，JavaScript 会沿着原型链向上查找，直到找到该属性或方法或者到达原型链的顶端。

通过原型链，我们可以实现对象之间的继承和共享属性和方法。下面是一个使用原型继承的示例：

// 创建一个构造函数

function Person(name, age) {

  this.name = name;

  this.age = age;

}

// 在构造函数的原型上定义方法

Person.prototype.sayHello = function() {

  console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);

};

// 创建一个 Person 对象

const person1 = new Person('Alice', 25);

// 调用对象的方法

person1.sayHello(); // 输出 "Hello, my name is Alice and I am 25 years old."

node是什么，express是什么，node服务中的中间件是用来干什么的

Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行时环境，可以用于构建高性能的网络应用程序。它允许使用 JavaScript 在服务器端运行代码，而不仅仅局限于在浏览器中运行。

Express 是一个基于 Node.js 的 Web 应用程序框架，它提供了一组简洁而灵活的功能，用于构建 Web 应用程序和 API。Express 提供了路由、中间件、模板引擎等功能，使得构建 Web 应用程序变得更加简单和高效。

中间件的作用是增强和扩展 Node.js 服务的功能，使得处理请求和响应的过程更加灵活和可定制。通过使用中间件，可以将常见的功能模块化，提高代码的可维护性和可重用性。

Express 提供了一些内置的中间件，同时也支持自定义中间件。您可以使用内置的中间件，如 express.json()、express.urlencoded() 来处理请求体的解析，或者编写自己的中间件来满足特定的需求。

你h5怎么处理兼容性

因为是vite+v3项目，vite官方有推荐的插件库，在插件库中有一个关于浏览器兼容支持的插件：@vitejs/plugin-legacy

插件@vitejs/plugin-legacy的作用是为打包后的文件提供传统浏览器兼容性支持

1. 首先安装插件：npm i @vitejs/plugin-legacy -D


2. 然后在vite.config.js中配置

import legacyPlugin from '@vitejs/plugin-legacy'

export default defineConfig( {

    plugins: [

        legacyPlugin({

            targets:['chrome 52'],  // 需要兼容的目标列表，可以设置多个

            additionalLegacyPolyfills:['regenerator-runtime/runtime'] // 面向IE11时需要此插件

        })

    ]

})

rem,px,em这些有什么区别

1. 
   

   px（像素）：px 是绝对单位，表示屏幕上的一个物理像素点。它是最常用的单位，具有固定的大小，不会根据其他因素而改变。例如，font-size: 16px; 表示字体大小为 16 像素。

   
   


2. 
   

   rem（根元素字体大小的倍数）：rem 是相对单位，相对于根元素（即 元素）的字体大小。如果根元素的字体大小为 16 像素，那么 1rem 就等于 16 像素。如果根元素的字体大小为 20 像素，那么 1rem 就等于 20 像素。通过设置根元素的字体大小，可以方便地调整整个页面的大小。例如，font-size: 1.5rem; 表示字体大小为根元素字体大小的 1.5 倍。

   
   


3. 
   

   em（相对于父元素字体大小的倍数）：em 也是相对单位，相对于父元素的字体大小。如果父元素的字体大小为 16 像素，那么 1em 就等于 16 像素。如果父元素的字体大小为 20 像素，那么 1em 就等于 20 像素。通过设置父元素的字体大小，可以影响其子元素的大小。例如，font-size: 1.2em; 表示字体大小为父元素字体大小的 1.2 倍。

   
   

总结来说，px 是绝对单位，不会随其他因素改变；rem 是相对于根元素字体大小的倍数，可以方便地调整整个页面的大小；em 是相对于父元素字体大小的倍数，可以影响子元素的大小。

在实际使用中，可以根据需求选择合适的单位。对于响应式设计，使用 rem 可以方便地调整整个页面的大小；对于局部样式，可以使用 px 或 em 来控制具体的大小。

你工作中遇到了什么坑或者解决什么让自己印象深刻的问题

• element-plus的el-table表格的二次封装（可以使用tsx）


• el-table表格的动态合并


• h5 ios时调起键盘会把整个布局往上推


• h5调用封装的app JSbrige完成返回


• 登录的拼图验证


• h5嵌套在微信小程序中时，由我们h5跳到三方提供的安全验证h5页面，返回时，本地存储的东西没了


• 利用git hooks+husky+eslint完成前端代码规范和提交规范


• 银行卡拖拽排序，把排完的顺序返回服务端

上面这些都是我解决了，也不仅仅只有这些，回头想了了下明明自己有很多可以说的，在当时就说了2，3个，然后负责人问我还有吗时，我卡壳了，居然不知道还要说什么。后面我感觉也是根据这个展开来问的

V2混入和V3的hooks，为什么V3要改成hooks的方式

感觉应该是问hooks的好处吧？反正我是答的不太对的，以下是总结：

Vue 3 引入了 Composition API（包括 setup 函数和 hooks），这是一个新的方式来组织和复用代码，与 Vue 2 的混入（mixins）有所不同。

混入在 Vue 2 中被广泛使用，它们允许你在多个组件之间共享行为。然而，混入有一些问题：

1. 命名冲突：如果混入和组件有相同的方法或数据属性，可能会导致冲突。


2. 来源不明：当一个组件使用了多个混入时，可能很难确定一个特定的方法或数据属性来自哪个混入。


3. 复杂性：混入可以包含生命周期钩子、方法、数据等，这可能会增加理解和维护组件的复杂性。
   
   相比之下，Vue 3 的 Composition API（包括 hooks）提供了一种更灵活、更可控的方式来组织和复用代码：


4. 更好的逻辑复用和代码组织：你可以将相关的代码（如数据、方法和生命周期钩子）组织在一起，而不是强制按照 Vue 的选项（data、methods、created 等）来组织代码。


5. 更好的类型推断：对于使用 TypeScript 的项目，Composition API 提供了更好的类型推断。


6. 更清晰的来源：每个函数和响应式数据的来源都非常明确，因为它们都是从特定的 hook 或 setup 函数返回的。
   因此，虽然 Vue 3 仍然支持混入，但推荐使用 Composition API 来组织和复用代码。

vue3中怎么封装一个自定义指令

• 通过app.directive()方法注册指令，该方法接受两个参数，第一个参数是指令的名称，第二个参数是一个对象，包含指令的各个生命周期的钩子函数


• 然后我们就可以在生命周期的钩子函数中定义指令的行为，根据指令的需求，在相应的生命周期钩子函数中编写逻辑代码

什么情况下会使用自定义指令

我的回答是：想要操作dom元素时并且这种类似情况经常出现，如节流和防抖指令，就是给dom加上disabled。按钮权限指令，给当前按钮dom一个显示和隐藏

拖拽排序

拖拽排序的实现原理主要涉及一下几个步骤：

• 1.监听拖拽事件: 浏览器提供了一系列的拖拽事件，设置draggable="true"


• 
  
  
  
  2. 开始拖拽：当用户开始拖拽一个元素时，会触发 dragstart 事件。在这个事件的处理函数中，我们可以通过 传入的dragstart(e,index) ,中的index来设置当前被拖拽元素的下标。
  
  
  
  


• 
  
  
  
  3. 拖拽过程：当用户拖拽元素时，会不断触发 dragover 事件。在这个事件的处理函数中，我们需要调用 event.preventDefault 方法来阻止浏览器的默认行为，否则无法触发 拖拽 事件。
  
  
  
  


• 
  
  
  
  4. 拖拽到另一个元素区域时：当用户拖拽到另一个元素时，会触发 dragenter 事件。在这个事件的处理函数中，我们可以通过 dragente(e,index)方法来获取拖拽到的元素的下标，然后根据获取的两下标来更新列表的排序。
  
  
  
  

表格动态合并

element-plus表格合并（例如前两列合并） | 耀耀切克闹 (yaoyaoqiekenao.com)

模拟new实例创建的过程

• 1.创建了新对象并将._proto_指向构造函数.prototype


• 2.将this指向新创建的对象


• 3.返回新对象

function newSimulator() {

    //1.创建新对象

    const obj = new Object()

    //2.设置_proto_为构造函数prototype

    const constructor = [].shift.call(arguments)

    obj._proto_ = constructor.prototype

    //3.this指向新对象，也就是改变this的指向

    const ret = constructor.apply(obj,arguments)

    //4.返回对象或this

    return typeof ret = 'object' ? ret : obj

}

冒泡排序

const arr = [1,7,9,2,3,5]

for(let i=0;i<arr.length;i++){

    for(let j=0;j<arr.length-i-1;j++){

        let a = []

        if(arr[j]<arr[j+1]){

            a =arr[j]

            arr[j]=arr[j+1]

            arr[j+1]=a

        }

    }

}

深拷贝

1.使用 JSON 序列化和反序列化

const obj={

   arr:[1,2]

}

const clone = JSON.parse(JSON.stringify(obj))

2.使用递归完成深拷贝

这种方式通过递归地遍历原始对象，并对该对象的的属性进行逐一的深拷贝，以创建一个原对象的独立副本。

function deepCloneObject(obj) {

       if(obj ===null||typeof object !='object') {

           return obj

       }

       const clone = Array.isArray(obj)?[]:{}

       for(let key in obj) {

           if(object.prototype.hasOwnProperty.call(obj,key))

           clone[key] = deepClone(obj[key])

       }

       retrun clone

} 

函数柯里化

函数柯里化是一种将具有多个参数的函数转换为逐个应用参数的函数序列的技术。通过柯里化，我们可以将一个函数的多个参数转化为一系列嵌套的函数调用。

柯里化的优点是可以创建可复用的函数模板。通过部分应用来生成新的函数。这样可以更灵活地使用函数，并且可以方便的创建更专注于特定功能的函数。
简单的函数柯里化例子：

function add(x) {

  return function(y) {

    return x + y;

  }

}



// 使用柯里化的add函数

var add5 = add(5);

console.log(add5(3)); // 输出 8

console.log(add5(7)); // 输出 12

封装一下

function curry(fn) {

    return function curried(...args) {

        if(args.length>=fn.length) {

            return fn.apply(this,args)

        } else {

            return function(...moreArgs) {

                return curried.apply(this,args.concat(moreArgs))

            }

        }

    }

}

数组API的实现

forEach

Array.portotype.my_forEach = function(callback) {

    for(let i=0;i<this.length;i++) {

        callback(this[i],i,this)

    }

}

map

Array.portotype.my_map = function(callback) {

    let res= []

    for(let i=0;i<this.length;i++) {

     callback(this[i],i,this)&&res.push( callback(this[i],i,this))

    }

    return res

}

filter

Array.portotype.my_filter = function(callback) {

    let res= []

    for(let i=0;i<this.length;i++) {

       callback(this[i], i, this) && res.push(this[i])

    }

    return res

}

前端模块化

问：你讲讲前端模块化吧
答：模块化的开发方式可以提高代码复用率，方便进行代码的管理，通常一个文件就是一个模块，有自己的作用域，只向外暴露特定的变量和函数。

问：模块化有哪几种标准？
答：目前流行的js模块化规范有CommonJS、AMD、CMD以及Es6的模块系统

问：ES Modules 和CommonJS的一些区别
答：
1.使用语法层面，CommonJs是通过modules.exports,exports导出，require导入；ES Modules则是export导出，import导入
2.CommonJs是运行时加载模块，EsModules是在静态编译期间就确定模块的依赖
3.EsModulse在编译期间会将所有import提升到顶部,CommonJs不会提升require
4.CommonJs导出是一个值拷贝，会对加载结果进行缓存，一但内部再修改这个值，则不会同步到外部。ESModule是导出的一个引用，内部修改可以同步到外部
5. CommonJs中顶层的this指向这个模块本身，而ESModule中顶层this指向undefined
6. CommonJS加载的是整个模块，将所有的接口全部加载进来，ESModule可以单独加载其中的某个接口

vue的数据双向绑定的原理

vue的响应式原理是采用‘发布-订阅’的设计模式结合object.defineProperty()劫持各个属性的getter和setter，在数据发生变动时通过调用Deo.notity函数发布订阅给观察者watcher，让其更新响应的视图。

虚拟dom

虚拟dom是用来表现真实dom结果的javaScript对象树，是构建在浏览器真实dom上的抽象层，虚拟dom是可以直接在内存中操作的，可以通过diff算法来新旧dom的差异，将最终变化应用到真实dom上

diff算法

diff算法又称虚拟Dom的周界算法，vue的diff算法是通过深度优先、先序遍历的方式进行的，它将前后两个虚拟Dom树进行逐层比较，当找到某一层不一样的节点时，停止下降，然后比较这些节点的子节点，当所有的子节点都完成比较之后，算法会由下至上进行回溯，此过程被称为执行patch操作。在执行patch操作时，Vue对于不同类型的节点的更新方式也不同，对于元素节点可以更新他的属性和子节点；对于文本节点，只能更新它的文本内容；对于每个子节点，如果key值相同，可以进行复用或者重新排序，或者将其他的节点移动到这个位置。

vue中nextTick的理解及作用

使用场景描述：更改一个数据，导致dom元素的width发生了更改，但又要获取这个更新后的dom元素的width，可以用nextTick
vue2 中的nextTick是在下次Dom更新循环之后执行回调函数，并且是作为vue实例的方法调用的

this.$nextTick(() => { // 组件的DOM已经更新完毕，可以进行相应操作 // ... });

Vue 3的nextTick作为一个独立的函数导入，返回一个Promise，并且可以直接传递回调函数作为参数。这些变化使得Vue 3中的nextTick更加灵活和易于使用。

// Vue 3 

import { nextTick } from 'vue'; 

nextTick(() => { // 在下次DOM更新循环之后执行 });

vue在实例挂载的过程中发生了什么？

1. 
   

   实例化：首先，Vue.js会创建一个新的Vue实例。在这个过程中，Vue.js会设置实例的各种属性和方法，包括数据对象、计算属性、方法、指令等。

   
   


2. 
   

   编译模板：Vue.js会将模板编译成渲染函数。模板就是包含Vue特定语法的HTML代码。编译过程中，Vue.js会解析模板中的指令（如v-if、v-for等）和插值表达式（如{{ message }}），并将它们转换为JavaScript代码。

   
   


3. 
   

   创建虚拟DOM：渲染函数会被调用，生成一个虚拟DOM树。虚拟DOM是对真实DOM的轻量级表示，它可以更高效地处理DOM的更新。

   
   


4. 
   

   挂载：最后，Vue.js会将虚拟DOM渲染为真实DOM，并将其挂载到指定的元素上。这个过程通常在调用vm.$mount()方法或者在实例化Vue时传入el选项后发生。

   
   


5. 
   

   更新：当数据变化时，Vue.js会重新执行渲染函数，生成新的虚拟DOM，并与旧的虚拟DOM进行对比（这个过程称为diff）。然后，Vue.js会根据diff结果，以最小的代价更新真实DOM。

   
   

这个过程中还会触发一系列的生命周期钩子，如created、mounted等，开发者可以在这些钩子中执行自己的代码。

vue2中data是一个函数而不是对象的原因

data之所以是一个函数，是因为一个组件可能会多处调用，而每一次调用就会执行data函数并返回新的数据对象，这样，可以避免多处调用之间的数据污染。

vue2中给对象添加新属性界面页面不刷新

vue2是用Object.defineProperty实现数据响应式，而后面新增的属性，并没有通过Object.defineProperty设置成响应式数据，所以页面没变化，常用解决方式：

• Vue.set()


• Object.assign()


• $forcecUpdated()

Vue SSR的实现原理

vue.js的ssR是一种在服务器上预渲染Vue.js应用程序的技术。

1. 服务器接收请求：当服务器接收一个请求时，它会创建一个新的Vue实例。


2. 创建渲染器：使用vue-server-renderer包创建一个渲染器。


3. 渲染页面：服务器使用渲染器将Vue实例渲染为Html字符串。


4. 发送响应：服务器将渲染后的Html字符串作为响应发送给客户端。


5. 客户端接收响应：客户端接收到服务器的响应后，将HTML字符串解析为DOM并显示给用户。


6. 激活(Hydration): Vue在客户端创建一个新的Vue实例，将其挂载到服务器收到的Dom上

keep-alive的使用

keep-alive的主要作用是缓存路由组件，以提高性能

<router-view v-slot="{ Component }">  

    <keep-alive :include="permissionStore.keepAliveName">  

        <component :is="Component" :key="$route.path" />  

    </keep-alive>  

</router-view>

1. 
   

   router-view是 Vue Router 的一个组件，用于渲染当前路由对应的组件。

   
   


2. 
   

   v-slot="{ Component }" 是一个插槽，用于获取当前路由对应的组件。

   
   


3. 
   

   keep-alive 是 Vue 的一个内置组件，用于缓存组件，避免重复渲染。

   
   


4. 
   

   :include="permissionStore.keepAliveName" 是 的一个属性，表示只有名称在 permissionStore.keepAliveName 中的组件会被缓存。

   
   


5. 
   

   是一个动态组件，:is="Component" 表示组件的类型由 Component 决定，:key="$route.path" 表示每个路由路径对应一个唯一的组件实例。

   
   

Vue项目中有封装axios吗？主要是封装哪方面的？

• 1.封装前需要和后端协商好一些约定，请求头，状态码，请求时间....


• 2.设置接口请求前缀：根据开发、测试、生产环境的不同，前缀需要加以区分


• 3.移除重复的请求，如果请求在pending中，提示'操作太频繁，请稍后再试'


• 4.用map结构根据相应状态码处理错误信息


• 5.请求拦截，若headers中没有token的，移除请求


• 6.响应拦截器，例如服务端返回的message中有'message'，提示'请求超时，请刷新网页重试'


• 7.请求方法的封装，封装get、post请求方法，使用起来更为方便

css预处理器

css预处理器扩充了css语言，增加了诸如变量、混合（mixin）、函数等功能，让css更易维护、方便。本质上。预处理是css的超集。包含一套自定义的语法及一个解析器，根据这些语法定义自己的样式规则，这些规则最终会通过解析器编译生成对应的css文件。

如何实现上拉加载

触底公式：

scrollTop + clientHeight >= scrollHeight

简单实现：

    let clientHeight = document.documentElement.clientHeight;//浏览器高度

    let scrollHigiht = documnet.body.scrollHeight;//元素内容高度的度量，包括由于溢出导致的视图中不可见内容

    let scrollTop = documnet.body.scrollTop; //滚动视窗的高度距离`window`顶部的距离

    let distance = 50;  //距离视窗还用50的时候，开始触发；



    if ((scrollTop + clientHeight) >= (scrollHeight - distance)) {

        console.log("开始加载数据");

    }

如何实现下拉刷新

关于下拉刷新的原生实现，主要分成三步：

1. 监听原生touchstart事件，记录其初始位置的值，e.touches[0].pageY;


2. 监听原生touchmove事件，记录并计算当前滑动的位置值与初始位置值的差值，大于0表示向下拉动，并借助CSS3的3. translateY属性使元素跟随手势向下滑动对应的差值，同时也应设置一个允许滑动的最大值


3. 监听原生touchend事件，若此时元素滑动达到最大值，则触发callback，同时将translateY重设为0，元素回到初始位置。

封装和使用JSBrige

1. 
   

   定义协议：首先，需要定义一种协议，用于约定H5页面与App之间的通信规则。这可以是一组自定义的URL Scheme或JavaScript函数。

   
   


2. 
   

   注册事件监听：在H5页面中，通过JavaScript代码注册事件监听器，用于接收来自App的消息或回调。可以使用window.addEventListener或其他类似的方法来监听特定的事件。

   
   


3. 
   

   发送消息给App：在H5页面中，通过调用JSBridge提供的方法，将消息发送给App。这可以是通过修改URL Scheme的方式，或者调用App提供的JavaScript接口。

   
   


4. 
   

   处理App的消息或回调：在App原生代码中，通过监听URL Scheme或执行JavaScript代码的方式，接收来自H5页面的消息或回调。根据协议约定，处理相应的逻辑或调用相应的功能。

   
   


5. 
   

   回调结果给H5页面：在App原生代码中，根据协议约定，将处理结果或回调信息发送回H5页面。可以通过修改URL Scheme的方式，或者调用H5页面中注册的JavaScript回调函数。

   
   

个人博客

耀耀切克闹 (yaoyaoqiekenao.com)

gitHub

DarknessZY (zhangyao) (github.com)

10月17日百度世界大会召开，据说文心大模型又牛X了，综合水平相比GPT4毫不逊色，真是个让人激动的消息，国产大模型的进展可以说是日新月异，我这耳朵边一直响彻四个字：遥遥领先。

不过今天我关注的重点不是什么大模型，而是发布会上的一件趣事：相亲。这大模型和相亲有什么关系呢？给大家说关系密切，各位男女光棍们一定要抓住这个机会。

话说在百度世界大会上出现了一位神秘的阿姨，她既不懂AI，也不懂编程，那她来干什么呢？这位阿姨拿着厚厚一叠的宣传页，见到长的有点像李彦宏的帅哥，就赶紧贴身向前，就着宣传页向对方一顿输出，热情开朗，情真意切，搞得小哥哥们都有点不好意思了。

这位阿姨在干什么呢？

原来这位阿姨是给自己的女儿来相亲的。阿姨的女儿是99年的，职业是小学老师，按说这个年龄、这个身份也应该不愁嫁吧。阿姨是怎么想的呐？

阿姨说，这可比那个什么相亲公园靠谱多了，都是高智商的人，都是搞AI的，就有编制的也不如搞编程的，这将来挣钱的一定是搞AI的。男怕入错行，女怕嫁错郎，这男人入对了行，将来挣钱源源不断！

我想这位阿姨一定是受到了张雪峰老师的启发，张老师在之前的直播中就给女孩子的家长们建议过，孩子学习不好，报个计算机专业，但是进去的主要目的不是学计算机，而是找个聪明的小哥哥，以后的生活比较有着落，原因相信大家都懂，挣钱多呗！

记得以前相亲，丈母娘都是看你有没有房，还有人说中国的房价都是丈母娘搞上去的。现在房价涨不动了，以后可能还会跌跌不休，我想其中的一个原因可能是丈母娘的眼光变高了，钱财当然很重要，但是你脑子不够也不行啊，得能挣钱才行，否则就是坐吃山空，不得长久。

再看看各位网友对这件事的看法：

阿姨政策吃的透透的，风口看的准准的！

大妈打算盘的声音，我在合肥都听到了！

阿姨超有远见！

看人家妈妈的行动力，行动起来啊妈妈

看到这里的各位男女光棍们，各位愁娶愁嫁的家长们，赶紧行动起来吧，每年甚至每周都有很多这样的技术大会，网上搜索一大堆，大会上有男有女，大部分都是高科技人才，将来前途和钱途都不可限量。多去看看，多去走走，说不定就能找到对眼的意中人，这个概率可是很高的，是经过丈母娘认可的。

最后，丈母娘也不是好糊弄的！大家一定要有真才实学。给同学们一些建议，打好基础，打好基础，技术不是东拼西凑就可以做好的，勿在浮沙建高台，容易倒；另外多实践多总结，多沟通多交流。

  日志是开发过程中不可或缺的一部分，它可以帮助我们追踪代码的执行过程、排查问题以及监控系统运行状况。然而，大多数开发人员在编写日志时往往只关注于输出必要的信息，而忽略了日志的可读性和美观性。本文将介绍如何在Java项目中实现漂亮的日志输出，提供一些实用的技巧和建议。

1. 使用合适的日志框架

  Java有许多优秀的日志框架可供选择，如Log4j、Logback和java.util.logging等。选择一个适合你项目需求的日志框架是实现漂亮日志输出的第一步。这些框架提供了丰富的配置选项，可以帮助你控制日志的格式和输出方式。这里对几个日志框架做一下简单的介绍。

Log4j

  Log4j是一个Java日志处理的框架，用于在Java应用程序中处理日志记录。它提供了一种灵活的方式来记录日志信息，并允许开发者根据需要配置日志输出的格式和目标。

  在Log4j中，主要有三个组件：Logger、Appender和Layout。Logger用于记录日志信息，Appender用于定义日志的输出目标，例如控制台、文件、数据库等，Layout用于定义日志的输出格式。

  以下是一个简单的Log4j代码示例：

import org.apache.log4j.Logger;  

  

public class MyApp {  

    // 获取Logger实例  

    final static Logger logger = Logger.getLogger(MyApp.class);  

  

public static void main(String[] args) {  

    // 记录不同级别的日志信息  

    logger.debug("Debugging information");  

    logger.info("Informational message");  

    logger.warn("Warning");  

    logger.error("Error occurred");  

    logger.fatal("Fatal error occurred");  

}  

}

  在这个示例中，我们首先导入了Logger类，然后通过Logger.getLogger(MyApp.class)获取了一个Logger实例。在main方法中，我们使用Logger实例记录了不同级别的日志信息，包括Debug、Info、Warn、Error和Fatal。

Logback

  Logback是Log4j的改进版本，是SLF4J（Simple Logging Facade for Java）下的一种日志实现。与Log4j相比，Logback具有更高的性能和更灵活的配置。

  Logback的组件包括Logger、Appender、Encoder、Layout和Filter，其中Logger是最常用的组件。Logger分为rootLogger和nestedLogger，rootLogger是所有Logger的根，nestedLogger则是rootLogger的子级。Logger之间有五个级别，从高到低依次为ERROR、WARN、INFO、DEBUG和TRACE，级别越高，日志信息越重要。

  以下是一个简单的Logback代码示例：

import org.slf4j.Logger;  

import org.slf4j.LoggerFactory;  

  

public class MyClass {  

    private static final Logger logger = LoggerFactory.getLogger(MyClass.class);  

    public void myMethod() {  

        logger.debug("Debug message");  

        logger.info("Info message");  

        logger.warn("Warn message");  

        logger.error("Error message");  

    }  

}

logging

  java.util.logging是Java平台的核心日志工具。

  java.util.logging由Logger、Handler、Filter、Formatter等类和接口组成。其中Logger是日志记录器，用于记录日志信息；Handler是处理器，用于处理日志信息；Filter是过滤器，用于过滤不需要记录的日志信息；Formatter是格式化器，用于格式化日志信息。

  这里介绍的日志框架，在项目当中运用的比较多的是Log4j、Logback，从基本的配置上没有太大的差异，大家也可以根据项目需求选择使用。

2. 定义清晰的日志级别

  在Java项目中，定义清晰的日志级别是非常重要的，以便在调试、监控和解决潜在问题时有效地记录和理解系统行为。下面是一些建议，可以帮助你定义清晰的日志级别：

1. 了解常见的日志级别：Java中常见的日志级别包括DEBUG、INFO、WARN、ERROR和FATAL。每个级别都有特定的含义和用途，首先要了解这些级别的含义。


2. 根据项目需求确定日志级别：在定义日志级别时，需要考虑项目的需求和目标。例如，对于一个简单的演示应用程序，可能不需要记录过多的调试信息。但对于一个复杂的业务系统，可能需要详细的调试信息来跟踪和解决潜在的问题。根据项目的重要性和规模来确定每个级别的日志信息是否必要。


3. 默认级别设置：为项目设置一个默认的日志级别。这通常是INFO级别，用于记录系统的常规操作信息。


4. 根据模块或功能设置日志级别：为每个模块或功能设置不同的日志级别。这有助于在特定部分出现问题时快速定位问题原因。例如，对于数据库模块，可以将其日志级别设置为DEBUG，以便记录详细的数据库操作信息。


5. 日志级别继承：在一个日志级别下定义的日志信息，应该继承到其所有子级别中。这意味着，如果某个日志信息被设置为WARN级别，那么该信息应该同时出现在WARN、ERROR和FATAL日志中。


6. 日志信息清晰明了：在记录日志信息时，要确保信息清晰明了，包含必要的细节。例如，对于错误信息，要包含错误类型、发生错误的方法和时间戳等信息。


7. 日志轮转和清理：及时对日志进行轮转和清理，避免日志文件过大而影响系统性能。可以设置一个合适的大小限制或时间间隔，对旧的日志文件进行归档和清理。


8. 培训开发人员：为开发人员提供关于如何使用日志系统的培训，确保他们了解如何记录适当的日志信息以及如何利用日志级别进行过滤。


9. 参考最佳实践：可以参考一些关于日志编写的最佳实践指南，例如Log4j的官方文档，以获取更多关于如何定义清晰日志级别的建议。

  定义清晰的日志级别对于Java项目来说非常重要。通过了解常见的日志级别、根据项目需求确定级别、设置默认级别、按模块或功能划分级别、继承级别、记录清晰明了的日志信息、及时轮转和清理以及培训开发人员等措施，可以帮助你在项目中实现定义清晰、易于理解和使用的日志级别。

3. 格式化日志输出

  下面以Log4j为例，介绍如何格式化日志输出。

1，引入Log4j依赖

  在Maven项目中，可以在pom.xml文件中添加以下依赖：

<dependency>  

    <groupId>org.apache.logging.log4j</groupId>  

    <artifactId>log4j-core</artifactId>  

    <version>2.x.x</version>  

</dependency>

2. 配置日志格式

  在log4j2.xml配置文件中，可以使用PatternLayout类来配置日志格式。例如，以下配置将日志输出为每行包含时间戳、日志级别、线程名和消息的格式：

<?xml version="1.0" encoding="UTF-8"?>  

<Configuration status="WARN">  

<Appenders>  

    <Console name="Console" target="SYSTEM_OUT">  

    <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>  

    </Console>  

</Appenders>  

<Loggers>  

    <Root level="debug">  

    <AppenderRef ref="Console"/>  

    </Root>  

</Loggers>  

</Configuration>

  其中，%d表示时间戳，%t表示线程名，%-5level表示日志级别（使用五个字符的宽度），%logger{36}表示最长为36个字符的Logger名称，%msg表示消息。在配置文件中可以根据需要调整格式。

3. 在代码中使用Log4j记录日志

在Java代码中，可以使用以下语句记录日志：

import org.apache.logging.log4j.LogManager;  

import org.apache.logging.log4j.Logger;  

  

public class MyClass {  

    private static final Logger logger = LogManager.getLogger(MyClass.class); 

  

    public static void main(String[] args) {  

        logger.debug("Debug message");  

        logger.info("Info message");  

        logger.warn("Warn message");  

        logger.error("Error message");  

    }  

}

  在输出结果中，可以看到每条日志信息都符合之前配置的格式。可以使用不同的配置文件来调整日志格式，以满足不同的需求。

4. 日志轮转和切割

  志切割和轮转在Log4j中主要通过两种策略实现：基于大小（Size-based）和基于日期时间（Time-based）。

1. 基于大小的日志切割和轮转

  这种策略是当日志文件达到指定大小时，会进行切割或轮转。例如，你可以设置当日志文件达到100MB时进行轮转。

<RollingFile name="File" fileName="logs/app.log" filePattern="logs/app-%d{yyyy-MM-dd}.log.gz">  

    <PatternLayout>  

        <pattern>%d %p %c{1.} [%t] %m%n</pattern>  

    </PatternLayout>  

    <Policies>  

        <SizeBasedTriggeringPolicy size="100 MB"/>  

    </Policies>  

    <DefaultRolloverStrategy max="20"/>  

</RollingFile>

  在上述配置中，当app.log文件达到100MB时，它会被切割并存储为app-yyyy-MM-dd.log.gz。并且最多保留20个这样的文件。

2. 基于日期时间的日志切割和轮转

  这种策略是当达到指定的日期时间时，进行日志切割或轮转。例如，你可以设置每天凌晨1点进行轮转。

<RollingFile name="File" fileName="logs/app.log" filePattern="logs/app-%d{yyyy-MM-dd}.log.gz">  

    <PatternLayout>  

        <pattern>%d %p %c{1.} [%t] %m%n</pattern>  

    </PatternLayout>  

    <Policies>  

        <TimeBasedTriggeringPolicy interval="1"/>  

    </Policies>  

    <DefaultRolloverStrategy max="30"/>  

</RollingFile>

  在上述配置中，每天凌晨1点，app.log文件会被切割并存储为app-yyyy-MM-dd.log.gz。并且最多保留30个这样的文件。

  注意：<DefaultRolloverStrategy max="20"/> 或 <TimeBasedTriggeringPolicy interval="1"/> 中的数字可以根据你的实际需要进行调整。

5. 日志过滤器（Filter）的使用

  Log4j中的过滤器（Filter）用于在日志事件发生之前对其进行一些条件判断，以决定是否接受该事件或者更改该事件。这可以让你根据特定的条件过滤日志输出，例如只打印错误级别以上的日志，或者根据线程ID、请求ID等过滤日志。

  在Log4j 2中，你可以通过配置文件（例如log4j2.xml）来为日志事件指定过滤器。以下是一个使用Log4j 2的XML配置文件中的过滤器的示例：

<?xml version="1.0" encoding="UTF-8"?>  

<Configuration status="WARN">  

<Appenders>  

    <Console name="Console" target="SYSTEM_OUT">  

        <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>  

        <Filters>  

            <ThresholdFilter level="ERROR"/>  

            <MarkerFilter marker="FLOW" onMatch="DENY"/>  

            <MarkerFilter marker="EXCEPTION" onMatch="DENY"/>  

        </Filters>  

    </Console>  

</Appenders>  

<Loggers>  

    <Root level="all">  

        <AppenderRef ref="Console"/>  

    </Root>  

</Loggers>  

</Configuration>

  在这个例子中，我们使用了三个过滤器：

  （1）. ThresholdFilter只接受级别为ERROR或更高级别的日志事件。

  （2）. 第一个MarkerFilter会拒绝任何带有"FLOW"标记的日志事件。

  （3）. 第二个MarkerFilter会拒绝任何带有"EXCEPTION"标记的日志事件。

  另外，你还可以创建自定义的过滤器，只需实现org.apache.logging.log4j.core.filter.Filter接口即可。然后你可以在配置文件中通过指定类全名来使用你的过滤器。

  对于更复杂的过滤需求，你还可以使用Condition元素，它允许你使用Java代码来决定是否接受一个日志事件。不过，请注意，因为这可能会影响性能，所以应谨慎使用。

  下面是实际项目中打印的日志，大家可以根据项目的需求满足日志打印的需求。

总结

  通过选择合适的日志框架、定义清晰的日志级别、格式化日志输出、添加时间戳和线程信息、使用日志分级以及处理异常和堆栈跟踪，我们可以实现在Java项目中打印漂亮的日志。漂亮的日志输出不仅可以提高代码的可读性，还可以帮助我们更好地理解和跟踪代码的执行过程，从而提高开发效率和系统稳定性。

拓展阅读

# 35岁愿你我皆向阳而生

# 深入解读Docker的Union File System技术

# 说一说注解@Autowired @Resource @Reference使用场景

# 编写Dockerfile和构建自定义镜像的步骤与技巧

# 说一说Spring中的单例模式

# MySQL的EXPLAIN用法

# Spring的Transactional: 处理事务的强大工具

说来话长，这事还得从我第一份工作说起，那时候纯纯大菜鸡一个，啥也不会，工作中如履薄冰，举步维艰，满屏荒唐码，一把辛酸泪😭

再说句题外话，如果你是中高级程序员，建议您划走离开，否则这篇文章可能会浪费您的宝贵时间☺️

那年

OK，书归正传，得益于本人工作态度良好，同事和领导都给予了我很大的帮助，只记得那是18年的平常打工人的一天，我写了如下很多打工人都会写，甚至每天都在写的代码（当时的具体代码已经记不清了，现在大概模拟一下案发场景）：

    /**

     * 从Order对象中获取id属性并包装成List返回

     *

     * @param orderList Student列表

     * @return idList

     */

    public List<Long> getOrderIds(List<Order> orderList) {

        List<Long> ids = new ArrayList<>();

        for (Order order : orderList) {

            ids.add(order.getId());

        }

        return ids;

    }

对没错，用Stream流可以一行代码解决这个问题，但当时受限于我们使用的JDK还是1.6和1.7，你懂得

我的直属领导看了我的代码后首先问我，你知道ArrayList初始化容量是多少吗？他是怎么扩容的？

我：。。。。。

这俩问题对现在的程序员来说兼职就是小菜一碟，不值一提，但对当时的我来说，可就有亿点难度了，之前面试之前依稀在那个博客上看别人写过，于是乎我就照着脑袋里模糊不清的知识点模棱两可的回答了这俩问题，emmm,

于是乎我领导就跟我说，既然你知道List容量不够会扩容，扩容会带来性能损耗(这个日后再细说，先说正事)那么你应该这么写，来避免它扩容呢？

    public List<Long> getOrderIds(List<Order> orderList) {

        List<Long> ids = new ArrayList<>(orderList.size());

        for (Order order : orderList) {

            ids.add(order.getId());

        }

        return ids;

    }

千万不要小看这些细节哦

听君一席话，如听一席话，于是我悟了，

从那以后再有类似集合初始化的场景，明确知道容量的场景我都会初始化的时候传入构造参数，避免其扩容，无法知道确切容量的时候也会预估一下容量 尽可能的避免减少扩容次数。

去年

时间来到2022年，去年，我已经不是当年的那个懵懵懂懂愣头青了，坐我旁边的一个哥们（技术比我当年强多了去了），他写了一段初始化HashMap的代码也传入了一个初始容量,代码如下：

    public Map<Long, Order> xxx(List<Order> orderList) {

        Map<Long, Order> orderMap = new HashMap<>(orderList.size());

        for (Order order : orderList) {

            orderMap.put(order.getId(), order);

        }

        return orderMap;

    }

敲黑板，重点来了，前面铺垫了那么多，就是为了说这事

历史惊奇在这一天重演，只不过负责问问题的是我

Q: 咳咳~HashMap的初始容量是16，放第几个个元素的时候会触发扩容呢（这题简单）

A: 元素个数超过16x0.75=12的时候进行扩容呗，扩容为16x2=32

Q: 既然容量为16,只能存12个元素，超过就会扩容，那么你写的new HashMap<>(orderList.size()) 这个能防止扩容吗？

A: emmm,不能

Q: 那初始化容量应该设置多少呢？

A: ……

Q: 16x0.75=12这个计算公式中, 初始容量变成未知假设为N 需存放的元素个数为20 Nx0.75=20 求N 是多少？（这大概就是经典的大学数学题吧）

A: 20➗0.75呗, 26.666 四舍五入27个， 设置容量为27，可以存放20个元素并且不触发扩容

所以正确的代码应该这么写: new HashMap<>((int) (orderList.size / 0.75 + 1))

别问为啥要+1,问就是因为小数转成int不会四舍五入直接舍弃小数点后的部分

一次轻松的对话就此结束

来看下大佬们是怎么写的

google的guava包 这是一个非常常用的java开发工具包，我从里面真的学到了很多（后续单独开篇文章记录一下）

//入口

HashMap<String, String> map= Maps.newHashMapWithExpectedSize(20);



  public static <K extends @Nullable Object, V extends @Nullable Object>

      HashMap<K, V> newHashMapWithExpectedSize(int expectedSize) {

    return new HashMap<>(capacity(expectedSize));

  }



  // 看这里看这里， 还考虑了一些其他的情况，专业！

  static int capacity(int expectedSize) {

    if (expectedSize < 3) {

      checkNonnegative(expectedSize, "expectedSize");

      return expectedSize + 1;

    }

    if (expectedSize < Ints.MAX_POWER_OF_TWO) {

      // This is the calculation used in JDK8 to resize when a putAll

      // happens; it seems to be the most conservative calculation we

      // can make.  0.75 is the default load factor.

      return (int) ((float) expectedSize / 0.75F + 1.0F);

    }

    return Integer.MAX_VALUE; // any large value

  }

大佬写的代码就是专业！

org.apache.curator包 无意之间发现的，实现有点意思

//这里写法一样

HashMap<String, String> map = Maps.newHashMapWithExpectedSize(20);



  

    public static <K, V> HashMap<K, V> newHashMapWithExpectedSize(int expectedSize) {

        return new HashMap(capacity(expectedSize));

    }

    

    //看这里 看这里  expectedSize + expectedSize / 3

		static int capacity(int expectedSize) {

        if (expectedSize < 3) {

            CollectPreconditions.checkNonnegative(expectedSize, "expectedSize");

            return expectedSize + 1;

        } else {

            return expectedSize < 1073741824 ? expectedSize + expectedSize / 3 : Integer.MAX_VALUE;

        }

    }

expectedSize + expectedSize / 3 说实话第一次看到这段代码的时候还是有点懵的，wocc这是啥写法，后来用几个数值带入计算了一下，还真是那么回事 👍🏻👍🏻

Hutool工具包

//入口

HashMap<String, String> map = MapUtil.newHashMap(20);



    public static <K, V> HashMap<K, V> newHashMap(int size) {

        return newHashMap(size, false);

    }

    

    //看这里， 平平无奇，什么档次？代码跟我写的一样，😄

    public static <K, V> HashMap<K, V> newHashMap(int size, boolean isOrder) {

        int initialCapacity = (int)((float)size / 0.75F) + 1;

        return (HashMap)(isOrder ? new LinkedHashMap(initialCapacity) : new HashMap(initialCapacity));

    }

    

说实话这个实现相较前者来说就显得不那么细了，居然跟我写的一样。。。

这件事情带来的思考

说起HashMap的知识点，晚上的文章博客简直满天飞，大家现在谁还不能说上几句，但是！ 后来在我面试的很多初中级开发时，我问他们准备往Map中存放20个元素，初始化容量设置多少不会触发扩容 时，基本上很少有人能答上来，10个人当中差不多有一个能回答上来？为什么会这样呢？ 明明这些人是懂的初始容量16，超过出初始容量的75%会触发扩容，反过来问一下就不会了~😒 这充分说明了，学习要融会贯通，举一反三，要细！！！

那段代码现在怎么写

据说JDK都出到21了，最近没怎么关注过~
不过JDK8已经流行很久了，那段代码用JDK8应该这么写：

• list

public List<Long> getOrderIds(List<Order> orderList) {

        List<Long> ids = new ArrayList<>(orderList.size());

        for (Order order : orderList) {

            ids.add(order.getId());

        }

        return ids;

    }

    

    //一行代码搞定，简洁明了

    public List<Long> getOrderIds(List<Order> orderList) {

        return orderList.stream().map(Order::getId).collect(Collectors.toList());

    }

通过Stream的Collectors.toList()来返回一个崭新的List，难道就没人好奇他这个List创建的时候有没有指定容量呢？如过不指定，在上面说到的那些明确知道存放容量的场景里岂不是要白白的扩容耗费性能？？？

答案是：NO 我们看下来Collectors.toList()的实现

public static <T>

    Collector<T, ?, List<T>> toList() {

        return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,

                                   (left, right) -> { left.addAll(right); return left; },

                                   CH_ID);

    }

    

    static class CollectorImpl<T, A, R> implements Collector<T, A, R> {

        private final Supplier<A> supplier;

        private final BiConsumer<A, T> accumulator;

        private final BinaryOperator<A> combiner;

        private final Function<A, R> finisher;

        private final Set<Characteristics> characteristics;



        CollectorImpl(Supplier<A> supplier,

                      BiConsumer<A, T> accumulator,

                      BinaryOperator<A> combiner,

                      Function<A,R> finisher,

                      Set<Characteristics> characteristics) {

            this.supplier = supplier;

            this.accumulator = accumulator;

            this.combiner = combiner;

            this.finisher = finisher;

            this.characteristics = characteristics;

        }



        CollectorImpl(Supplier<A> supplier,

                      BiConsumer<A, T> accumulator,

                      BinaryOperator<A> combiner,

                      Set<Characteristics> characteristics) {

            this(supplier, accumulator, combiner, castingIdentity(), characteristics);

        }

CollectorImpl是Collectors中的一个内部类，构造函数的第一个参数是Supplier<A> supplier这是一个函数式接口，就是说你得传给我一个实现，告诉我应该如何去创建一个集合，上面是这么传参的ArrayList::new, 这个写法其实就是new ArrayList(), 看到没！他并没有指定集合容量哦~~~

那么如果想提前指定好集合容量应该怎么写呢？ 不卖关子了，直接贴代码了，写个B博客，真TM累死个人😌

public List<Long> getOrderIds(List<Order> orderList) {

        return orderList.stream().map(Order::getId).collect(Collectors.toCollection(() -> new ArrayList<>(orderList.size())));

    }

这就行了，看下Collectors.toCollection()的源码

public static <T, C extends Collection<T>>

    Collector<T, ?, C> toCollection(Supplier<C> collectionFactory) {

        return new CollectorImpl<>(collectionFactory, Collection<T>::add,

                                   (r1, r2) -> { r1.addAll(r2); return r1; },

                                   CH_ID);

    }

这和Collectors.toList()基本上市一样的，只不过Collectors.toCollection()把如何创建集合的这个步骤抽象起来叫给我们开发者来个性化实现了,是不是又学到了一招~~~(#^.^#)

• map

public Map<Long, Order> xxx(List<Order> orderList) {

        Map<Long, Order> orderMap = new HashMap<>(orderList.size());

        for (Order order : orderList) {

            orderMap.put(order.getId(), order);

        }

        return orderMap;

    }

    

    

    //这点破代码用Stream也是分分钟搞定

    public Map<Long, Order> xxx(List<Order> orderList) {

        return orderList.stream().collect(Collectors.toMap(Order::getId, Function.identity(), (k1,k2) -> k1));

    }

和上面的List一样，这玩意初始化Map的时候也没有指定容量

public static <T, K, U>

    Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,

                                    Function<? super T, ? extends U> valueMapper) {

        return toMap(keyMapper, valueMapper, throwingMerger(), HashMap::new);

    }

Map的创建也是通过一个函数式接口Supplier<M> mapSupplier定义的，传的参数是 HashMap::new,这也是一个方法引用，写法等于 new hashMap(), 想指定容量怎么办呢？ 看代码

    public Map<Long, Order> xxx(List<Order> orderList) {

        return orderList.stream()

                .collect(Collectors.toMap(Order::getId, Function.identity(), (k1,k2) -> k1, 

                        () -> new HashMap<>((int) (orderList.size() / 0.75 + 1))));

    }

这个写法我们同样自己掌控如何创建需要的Map,容量自己定~

写在末尾

没啥要写的了，就这吧，累挺

”愿世间没有肿瘤，没有疾病，没有痛苦“

朋友圈里前同事的一条消息惊醒了我，震惊的情绪驱散……了睡前的疲惫，上一次有这种情绪是听到同学的噩耗~ 。

每当悲伤的情绪涌上心头，生死之间的恐惧与震惊会让我禁不住的思考我现在的人生是不是有意义的人生。我会想人生的意义在哪里？努力学习，努力拼搏的意义在哪里？仿佛一切努力都不值得~ 在死亡面前一切努力都不值得，反而是笑话。

如果，我是说如果，知道自己死亡的那一天是哪一天，我相信很多人会有另一种不同的活法。

每个人的命运掌握在不同的人手里，有的人掌握在父母手里，有的人掌握在孩子手里，有的人掌握在死神手里，有的人掌握在病魔手里，甚至有的人的命运掌握在酒后驾车司机的手里。

五年前的冬天，我刚毕业一年多，在公司里如鱼得水，每天的状态元气满满，业余时间还会搞开源项目。那个时候还没有体会到北漂的孤独，更几年后，看不到未来的时候对未来的绝望。

给我留下深刻印象的是，那年冬天回到老家，让我第一次感受到，好好活着是一件很难的事。

“林涛, 死了”。四个字就好像晴天霹雳一样在脑袋上炸开。我不记得我爸说话时的语气和表情，我只记得震惊和恐惧的情绪在我脑子里爆炸，好像有人用手掐着我的脖子，我呆住了。

林涛（化名）

愣了一会，才听见我爸说，“林涛出车祸了，和朋友去喝酒，喝完酒一起开车去KTV，路上出事儿的，他坐副驾驶，没系安全带，被甩出去了。”

林涛是我十几年前的发小，那时候天天腻在一起玩，后来渐渐不联系了。偶尔在老家见到，也只是打个招呼……

以后的几年里，时不时的会想起这件事。我第一次意思到，在死神眼里，人人平等，包括90后。

我在想，死亡是我们这个年纪该承受的吗？

如今朋友圈里的消息又让我想到这一切，我又开始思考，人生的意义在哪里？史铁生说，死是一件不必急于求成的事。是啊，任何一个健康的人都不会急于求成这件事。时不时出现的死神仿佛在向我们说：你命由天不由你。

这种情绪时不时的困扰我，每次都会有几天，过几天我又会有 “我命由我不由天”的感觉。没错，过几天就会支棱起来。

我也在想，为什么能支棱起来？主要是命运之神没有狠狠地捶打我。除此之外，我想应该有对美好未来的期待。

当我问老婆，你人生的意义是什么？

“为什么要问人生的意义？” 我老婆反问我。“问这个问题有什么意义，我只想和你快快乐乐的过一辈子。”

是我又矫情了……

我们不再是为赋新词强说愁的少年，我们已经长大，生活工作中有太多的酸甜苦辣，与其再去寻找人生的意义，不如静下心来，想想自己还有哪些人生的愿望，人生的牵挂。

人生苦短，及时行乐。

与其追寻意义，不如快快乐乐的过好每一天。

游戏也不能玩了？

谁也没有想到，美国针对 AI 大模型技术卡脖子的争端，竟然砍到了玩家头上。

本周二，美国商务部放出最严对华出口管制规定，H800 等关键 AI 加速器成为制裁的焦点，然而消息曝出还没几个小时，人们发现各大电商平台上的高端消费级显卡 GeForce RTX 4090 也下架了。

此前一系列对于 AI 芯片的限制已经让人愤怒，这次美国对消费级产品的打击直接影响到了更多人，事件瞬间登上了热搜。

很多人一觉醒来就在问：发生什么事了？

突如其来的消息引发了人们的讨论。游戏圈的人纷纷表示，没想到玩个游戏也能被美国制裁。也有玩生成式 AI 的人说，本来还想攒钱买块显卡跑 AI 画图，现在也不用等了。

但一纸蛮横无理的「禁令」并不能让生活停止，冷静下来之后，很多人进行了分析。首先，更严格的限制会让国内火热的生成式 AI 领域受到影响。

有评论解读认为，按照美国商务部的新规来看，以后出口芯片都要按计算器算一下，芯片的总体性能和性能密度是限制点，因此 RTX 4080 和 AMD 的 7900 XTX 也是有被禁风险的。 

也有人表示，不赚钱让出市场是不可能的，看上次 H800 的做法，英伟达马上就要出 4080Ti 了。

就在我们在计算什么游戏必须要用 4090 才能跑得顺畅的时候，这场闹剧很快又发展到了新的阶段。

禁了，但没完全禁：美商务部澄清

昨天，美国商务部工业和安全局（BIS）更新对华出口管制规定，进一步收紧 AI 芯片等领域的限制。新规显示，此次限制的核心对象是先进计算半导体、半导体制造设备和超级计算机项目，更加严格地限制了中国购买重要的高端芯片。

仔细解读这份新文件可以发现，新规则修改了需要受限的高级芯片的认定规则（参数）。比如删除了「互连带宽」作为识别受限芯片的参数，还设置了一个新的「性能密度阈值」（这个标准更为变通和灵活）来作为参数。

美国政府高级官员说，如果数据中心芯片超过了去年 10 月设定的「性能门槛」，或者超过了以每平方毫米计算的新的「性能密度门槛」基准，美国将限制数据中心芯片的出口。想要向中国或其他禁运地区出口芯片的公司必须通知美国政府。

更新后的禁令还将更多公司列入到「实体清单」，包括两大国产 GPU 显卡厂商摩尔线程、壁仞。

另外在新规定中，香港和澳门地区也在管制区域的范围内。

英伟达在 2022 年 9 月已被禁止向中国出售 A100、H100 等高端 AI 加速器。在当时，英伟达立即设计出了效能、互联性能稍差，但相比前一代提升明显的 A800、H800，作为「特供」中国的替代品。然而在更严格的限制之下，这些产品也被列为禁止出口。

这种管制对于国内科技公司和大模型前沿技术发展的影响，目前还难以分析，但事件的另一个利益相关方英伟达不可避免地再次陷入了被动。

作为上市公司，英伟达立刻提交给美国证监会（SEC）一份报告，主要声明了以下几点：这些限制适用该公司的 A100、A800、H100、H800、L40、L40S 和 RTX 4090 芯片，同时也影响了与这些芯片一起销售的整个系统，包括 DGX 和 HGX 系统。

另外，这些限制可能会损害英伟达按时完成新产品开发的能力。

公告地址：http://www.sec.gov/Archives/ed…

英伟达自己说了，这些你叫得上名的芯片都会受到影响，未来的计划也被打乱了。消息一出，英伟达股价遭遇了大幅缩水，AMD、英特尔也随之下跌，券商也纷纷调低了对于此类公司股价的未来预期。

与此同时，我们看到了在国内的电商平台，RTX 4090 纷纷下架的情景。

消费级显卡被列在了先进计算项目的管制名单里，这并不像是一件正常的事，美国商务部很快对 ECCN 3A090 的高科技出口管制政策做出了澄清。

关于该政策中对 NVIDIA GeForce RTX 4090 显卡的禁令，美国商务部允许对消费性应用的芯片进行出口豁免。不过这里也有争议，并没有明确指出是否包括 RTX 4090。

文件来源：http://www.bis.doc.gov/index.php/d…

这意味着 GeForce RTX 4090 显卡可以在中国（包括香港和澳门）的消费市场进行零售，但不允许将 RTX 4090 芯片用于商业和生产用途。

考虑到目前主流厂商的显卡成品均不是在大陆组装的，新限制对于消费级显卡的影响似乎可以认为是几乎没有。所以此处把问题归于黄牛囤货，是不无道理的。

RTX 4090「算力过高」，5090 怎么办？

所以作为一个玩家，我们就不用担心显卡被禁了，但以后怎么办？

自去年 9 月黄仁勋在 GTC 大会上推出 RTX40 系显卡，已经过去了一年多时间。RTX 4090 相较于 3090Ti 性能翻了一倍，光线追踪性能则提升了 4 倍。

不过，12999 元的起售价似乎让 RTX 4090 在市场上有点卖不动，所以有人调侃称此次 RTX 4090 可能被禁售的传闻是为了用涨价折抵销量的伎俩。

暂且不说被澄清可以消费使用的 RTX 4090，很多人更担忧的是，近来一直爆料不断的下一代旗舰机显卡 RTX 5090 未来会不会步其「前辈」的后尘呢？

据此前消息，RTX 5090 的整体性能会比 4090 提升 70％，其中：

• 
  

  CUDA 内核数增加 50%，达到 24576 个

  
  


• 
  

  内存带宽增加 52%

  
  


• 
  

  缓存增加 78%

  
  


• 
  

  频率提高 15%

  
  

显然，RTX 5090 的算力很强，强到让人担心次一级的 5080 是不是也在美国商务部那个「算力密度」的范围内。毕竟黄仁勋可是说出过自家芯片每代性能都翻倍这种话的。

图源：videocardz.com/newz/nvidia…

目前看来对于出口的限制仅限数据中心使用的产品，纯粹的民用消费级产品则不受影响。

但不到一年的时间就已经两次修改，以后不好说 —— 不过禁售大众商品完全就是自损一千给助攻的行为，拱手让出消费级市场，是英伟达、AMD 等芯片公司不想看到的事。

尤其对于英伟达这个在中国拥有巨量需求的 GPU 厂商，他肯定不希望因为可能的禁售失掉占其全球营收近一半的中国市场（仅就 2023 财年来说）。未来对于国际芯片厂商和国内科技公司来说，日子可能会更不好过。

从另一个角度看，美国对于高端 AI 加速器的限制，让我们对于发展自身硬件技术有了更强的紧迫感。

或许在限制不断加码的背景之下，会有国内的芯片厂商把握住机遇。

参考内容：

http://www.sec.gov/ix?doc=/Arc…

http://www.zhihu.com/question/62…

0x0. 背景介绍

再过几天就是 1024 程序员节了，提前祝广大程序员工友们节日快乐，少写 bug，早点下班回家，不熬夜，尽量 delay 秃头的上线时间😭

上篇文章《因为月薪过高，我的工资发放失败了。。。》中，我分享了中行的骚操作导致我收不到工资的故事。简单的说，就是中行的码农老哥上线了一个 bug，误伤了普通用户，将正常的银行卡标记为风险账户导致入账失败。

这个 bug 看似没有带来实际损失，但是浪费了客户、客服、柜台人员的大量时间，这些都是成本。更重要的是，中行损失了潜在的高净值客户，某网友撰文吐槽此事，试图搞个大新闻，居然获得了几万的阅读。万一读者里有未来的首富，发誓不跟中行做生意，中行怎么也得损失几个小目标吧🐶。

作为码农，我们和 bug 的相处时间可能比另一半都多，毕竟咱们就是以写 bug 为生。写代码赚大钱的故事，大家见的多了，尤以逼乎和卖卖为甚。可能是大多数开发离钱太远，亦或是因为家丑不可外扬，网上鲜有人分享因为 bug 亏大钱的事故。

恰好，我做过日入过亿的大项目，脸皮也足够厚，本文分享3个我亲身经历的简单 bugs，简单到只需几秒钟就能修复。但是它们带来了巨额的亏损，足够在北京四环全款买一套100平的房子，甚至更多。

对了，上文有老哥留言说我废话太多了，这里稍微解释下，我的个人简介里有写的：

本人主业是讲段子，副业才是写 bug

所以，为了避免文章过于枯燥，本文，我依然会按照自己的风格，用「废话」的方式来回答：

bug 产生的原因是什么？为什么没测试出来？给用户带来了什么影响？如何修复？耗时多久？如何避免？

如前所述，都是非常简单的 bug，并没有什么深度和难度，只想看干货的老哥，恕难满足，超市里应该有：

声明：本文内容，毫无虚构，如有雷同，纯属雷同。

0x1. 挤兑的代价

若干年前，北京，12月的某天，23点，-10℃，骑摩托刚到家不久，正坐在暖气片上加热被冻的冰凉的屁股，接到同事电话：

合作团队 X 部门说我们最近几个月的 CDN 带宽陡增，每个月有近千万的成本

千万每月？我以为我听错了，他又重复了一遍，我蹭地一下站了起来，连呼三声卧槽，差点整个人都凉了。彼时，临近年底，老板正在分配年终奖，如果真要支付这么多成本，还发啥年终奖啊，部门都可以就地解散了。

稍后，同事又补充道，这是折扣前的成本，折扣后应该会少很多，具体需要拉上相关同事详细计算。罢了，事已至此，先睡觉吧。

次日，找到相关同事简单讨论了下，基本确定了原因。我们的产品是 SDK，先说下背景：

1. 不久之前的某个版本增加了功能 A，功能 A 需要用到一些配置 C


2. 为了能让用户体验更好，SDK 初始化时会主动从 CDN 下载配置 C

最近，我们完善了功能 A，配置 C 的体积也增大了数倍。同时，为了配合推广功能 A，我们做了一次运营活动，鼓励更多用户升级到最新版本。于是，在用户数量和配置 C 的体积双双陡增的情况下，带来了 CDN 流量的暴涨。

雪上加霜的是，一些宿主 APP 用黑科技对抗 ROM，力求做到「保活」，导致 APP 短时间内多次被系统干掉又自动重启，引发 SDK 初始化并下载配置 C。

另外，CDN 的计费是按照当天的峰值带宽来的，24小时内，哪怕波峰只持续了1秒，当天的成本也是按照最高点的带宽来核算的，如下图就是按照接近80的带宽来计算：

再考虑一下我们平时使用手机的习惯，有明显的3个高峰期：

1. 06:30 ~ 08:30


2. 11:30 ~ 13:00


3. 18:00 ~ 21:00

这3个高峰期与我们观察到的 CDN 带宽曲线非常吻合，而且早晚高峰远高于午高峰。虽然配置文件 C 并不大，但是海量的用户一股脑地同时请求 CDN，直接将瞬时带宽推上天了，进而导致核算成本超高。就像今年初的硅谷银行，因为储户的大量挤兑，直接把它给干倒闭了。

原因找到了，解决就简单了，各个击破之：

1. 找到流量占大头的宿主 APP，与开发者沟通，配置其不请求 CDN，带宽直接降低 90%


2. 确定根本不需要功能 A 的宿主 APP，配置其不请求 CDN，带宽再次降低 50%


3. 减小配置 C 的文件体积，精简、移除不必要的内容


4. 削峰填谷，优化下载策略，平滑 CDN 带宽曲线

前两步在当天就完成了，第3步和第4步是逐步完善的，最终带宽稳定在优化前的5%左右。

我猜，肯定有读者质疑，为何要在 SDK 初始化时就请求 CDN 下载配置？应该先请求某个后台 CGI 接口，由后台决定是否需要下载或更新配置。这就是另一个话题了，历史原因，前后端的合作比较拧巴，许多本该后端完成的工作，下放到客户端了，导致技术方案很山寨。后来通过两次请求 CDN 迂回实现了这个功能：

1. 先以某个固定 URL 请求 CDN，得到配置文件 C 的 URL，URL 中有 C 的哈希


2. 如果 URL 中的哈希与本地配置文件的哈希不同，再次请求 CDN，下载配置文件 C

问题虽然解决了，已经产生的带宽费用怎么办？部门间结算是按季度进行的，但是负责基建的 X 部门，未能及时告知我们带宽异常情况，造成了带宽的浪费。彼时，降本增效尚未开始，经过与 X 部门的协商，对方减免了我们近几个月的带宽费用。

这个问题持续了几个月，粗略的估算，即使打折，实际消耗也有数百万了。虽然 X 部门没要钱，看似是我们赚了，但最终肯定是小马哥给报销，亏的他只能坐公交了。

0x2. 最贵的字符

不久后，轰轰烈烈的降本增效运动开始席卷整个公司。如何降本？最简单粗暴的方法就是开猿节流：

幸运的是，我所在的部门一直有盈利，没有采取这种低级的手段。不开猿，就只能节流了。在解决上面的 bug 后，我们就开始尝试使用不同手段来优化各种机器成本，包括 CDN 带宽、磁盘存储、CPU 资源等等。尤其是 CDN 带宽，每天上班都会看一眼，防止又出事了。

几个月后，优化初见成色，着实为部门省下了一大笔钱。距离当初定的优化目标，每天都在更近一步，心中甚是喜悦。然鹅，快乐的日子总是短暂的，在准备将这份喜悦分享给老板的前夕，出岔子了。

某天，我突然被 Y 部门的人拉到一个群，询问其 CDN 上的某个文件 F 是否归属我的部门。在得到我肯定的答复后，他们说其 CDN 上 99% 的流量来自文件 F，让我们赔付近几个月消耗的数百万元，同时不排除追溯历史费用。

我屮艸芔茻！Yesterday Once More？稍作冷静，直觉告诉我不可能有这么多钱，因为 F 的使用方式如下：

1. 应用中自带一份 F，程序启动时会加载 F


2. 当且仅当本地的 F 与 CDN 上的不一致时，才会重新下载

我们两到三个月才会更新一次 F，理论上，只有在更新 F 时才会产生 CDN 流量，费用最多只有他说的 1/10。彼时，大家都在「降本」，我不敢懈怠，为了尽快把锅甩出去，赶紧找经验丰富的同学的帮忙排查。

很快啊，锅就回来了，因为某处多了一个字符，导致 CDN 带宽暴涨。先暂停1分钟，能猜到可能的原因吗？

---------- 我是没用的分隔符 ----------

问题出在上面的第 2 步，假设 CDN_FILE_HASH 是 CDN 上的文件 F 的哈希值，由后台的 CGI 接口返回给客户端。整个流程的伪代码如下：

 CDN_FILE_HASH = get_cdn_file_hash_from_cgi();

 if (CDN_FILE_HASH != localFile.hash()){

   downloadFile();

 }

简单的 debug 了下，cgi 返回的 CDN_FILE_HASH 比预期多了个换行符 \n，这就导致了 if 语句始终为真。于是，应用每次启动时，都会重新下载 F。谁说人不能两次踏入同一条河流的？这跟第1个 bug 不是一毛一样吗👀。

我们每次在更新 F 后，会将其哈希写入另一个配置文件 H。在收到客户端的请求时，后台读取 H 的内容，返回给客户端。后台相关代码自上线后就没动过，所以多出来的 \n 只能是来自文件 H。

之前，我们是先人肉更新 CDN 上的 F，再将其哈希写入 H，每次都需要在 Web 上填一堆东西，比较麻烦。为了增效，就写了个脚本，一键更新 F 并将其哈希写入 H，真爽！

不用说，肯定是写文件的地方有问题，伪代码如下。暂停1分钟，看出 bug 了吗？

 def write_F_hash_to_H(F)

   with open('H', 'w') as H:

     print(F.hash(), file=H)

---------- 我是没用的分隔符 ----------

对 python 熟悉的小伙伴应该看出来了，print 会自动追加换行符(默认为\n)，而 JAVA 只有 println 才会追加：

就这样，价值数百万的换行符诞生了，这是我见过的最贵的 bug 了，这亏钱速度，大 A 看了都要落泪😭。

修复也极其简单，将 print 函数的 end 参数赋值为空字符串即可。当务之急是减小损失，遂立刻人肉删除文件 H 中的换行符，CDN 流量瞬间就跌下来了：

之后的 CDN 带宽走势与上图箭头右侧非常相似，这是我去年中买的一支股票，买在箭头所示的地方，两个月前割了，仅亏损95%😎。

现在，同样的问题又来了，已产生的几百万的费用咋办？彼时，各部门都在「降本」，我们之前那套说辞不好使了，对方坚称要赔付。经过几轮「友好」的争吵与互相问候，几番讨价还价，赔付自 bug 发生日期之后的费用即可，分期付款。

上面提到，我每天都会看一眼 CDN 带宽，这条大鱼为啥还会漏网呢？这就说来话长了：

很久之前，我们也隶属于 Y 部门，CDN 自然也是同一个。

后来，组织架构调整，我们被“赶出” Y 部门，自立门户了。

因为文件 F 非常重要，为了保证存量客户端版本不受影响，分家的时候，F 没有迁移，仍然保留在原 CDN 上。后续 F 有更新，还是上传到原 CDN。正常情况下，F 的带宽非常小，可能 Y 部门没发现或者懒得计较，放任我们白嫖了。

我没有权限查看 Y 部门的 CDN 的监控面板，亦不了解那段历史，直到因为 bug 暴雷，我才知道是 Y 部门在替我们「负重前行」。

bug 持续了两个多月，粗略估算，我们支付的费用，足够正常情况下使用好几年了。真的是应了那句：

所有命运馈送的礼物，早已在暗中标好了价格

不用说，最终又是老板一个人承担了所有

0x3. 狸猫换太子

前面的 bug，根本原因都是技术方案不完善和细节考虑不周所致，简单的说，是自己人的锅。但，即使把代码写的完美无瑕，就一定能正确运行吗？

11年前，我是个刚出道不久的小菜鸟，接手了一个偶现 bug，涉案金额可以忽略不计。业务逻辑非常简单，如下：

1. 客户端 POST 本地数据库中的数据至服务端，服务端返回响应 rsp


2. 如果上传成功，客户端删除本地已上传数据；否则，再重试一次

零星有几个深圳的用户反馈我们的 APP 消耗了很多流量，最终的排查结果，嘿，您猜怎么着？高情商的说法是「涨见识了」，低情商的说法是「操」！

为了复现这个问题，我尝试了三个运营商的手机卡，在GPRS,EDGE,CDMA 1x,3G等多种网络条件下测试，流量完全正常。因为缺少必要的 log，只能从代码入手，初步怀疑可能有 bug 的地方：

1. 上传成功，但本地数据删除失败，导致每次重复上传旧数据


2. 重试逻辑不严谨，如果上传失败，可能多次重试，浪费流量

喊上导师一起仔细读了几遍代码，确定代码没问题。之后的细节记不清了，最终是在深圳同事的协助下，找到了复现的严苛条件：

深圳，中国电信手机卡，数据流量上网，选择 CTWAP 接入点

复现时，远程 debug 发现，客户端每次都走到了上传失败的分支，但手机的网络是正常的，也能 ping 通我们的域名。

猜测是客户端或服务端收到的数据有问题，亦或二者皆有，用 tcpdump 在客户端和服务端分别抓包，很快确定了:

1. 服务端收到了正确的数据，返回的 rsp 是 gzip 压缩的 JSON 串


2. 但是，客户端收到的 rsp 与服务端发出的不一致，有些字节被篡改了

看到这，可能有读者会说，这不就是「HTTP 劫持」吗？某些无良运营商，利用 iFrame 在网页上插个「性感荷官，在线发牌」的广告，祖传手艺了。

根本原因肯定是 HTTP 中间人攻击，篡改了数据，但我觉得更像是运营商 CTWAP 的 bug，因为以下两种修改都可以收到正确的 rsp，说明并非运营商刻意为之：

0. 手机上将接入点改为 CTNET


1. rsp 不启用 gzip 压缩

在选择 CTWAP 接入点时，手机的 HTTP 请求都会被转发到电信内网的代理服务器 10.0.0.200:80。怀疑是深圳部署的 proxy 有 bug，识别不了 gzip 格式，或者某些二进制字节被误判为「非法」字符，出于好心，就顺手帮我们改了。大概类似这个15年前的笑话吧，异曲同工之妙，我不知道「绿坝」是啥：

因为「绿坝-花季护航」的屏蔽，华为官网的「24口交换机」已改名为「24嘴交换机」

再说回 bug，现在原因很明显了：

上传成功 -> 服务端返回 rsp -> CTWAP 网关篡改 rsp -> 客户端认为上传失败 -> 重试 -> 再次失败 -> 下次满足条件时继续上传...

修复也很简单，因为 gzip 压缩前的 JSON 也就几十个字节，没必要压缩。正好客户端使用的 HTTPClient 可以自动识别 rsp 是否被 gzip 压缩并正确处理，所以只需要服务端关闭 gzip 压缩即可。

彼时 3G 已经普及了，大多数电信手机的默认接入点都是 CTNET，加上网速也不快，所以实际的影响非常有限。当然，针对受影响的用户，我们如实赔付了其损失的流量费。同时，也将这个问题报给了深圳电信，至于是否修复，就不得而知了。

这大概就是「人在家中坐，锅从天上来」吧，所以，bug 不可怕，可怕的是没 bug，那必定是有 bug🐶

0x4. 总结 & 反思

所谓「常在河边走，哪有不湿鞋」，即使经验丰富的大佬，也能写出匪夷所思的 bug，例如臭名昭著的goto fail漏洞：

这段代码存在于 iOS 7.0.6 之前，其正式编号为CVE-2014-1266，会导致非法的 SSL 证书也能被接受，有极大的安全隐患，详细分析见dwheeler.com/essays/appl…。

所以，也没啥好总结的，就像每次版本发布之后，无论针对 bug 的「批斗大会」开的多么成功，码农的反思多么深刻，下次一定还会有 bug，正如黑格尔所说的：

人类从历史中学到的唯一教训，就是人类无法从历史中学到任何教训

虽然无法完全杜绝 bug，但一向好为人师的我，还是想 BB 三句，仅针对本文分享的几个 bug：

1. 提高成本意识：客户端开发大多都没有机器成本的概念，包括我自己，我们需要尽可能优化网络请求次数和数据量，这些都是💰啊，除非你是帮老板解决钱花不完的烦恼🐶


2. 增加白盒测试：程序正确运行，不代表没 bug，本文第2个 bug，如果有白盒测试，上线前一定能发现每次都下载 F 的问题。至于哪里用白盒，没有标准，与💰强相关的地方，优先考虑


3. 一切皆有可能：当出现 bug 时，如果无论如何也找不到原因，也许真的就不是自己代码的 bug，先拖一拖吧，也许它自己就好了，尤其 Android，太多玄学的事情了。。。

再啰嗦一句与技术无关的，发展才是硬道理，随着发展，把蛋糕做大，很多问题会自动解决或可以忽略。例如第1个 bug，降本增效之前，地主家还有点余粮，直接给我们免了；第2个 bug，虽然之前一直是白嫖，但彼时业务在高速增长期，CDN 那点钱比起赚到的钱来说可以忽略不计，所以 Y 部门一直也没计较。就酱，点到为止。

最后，用专治八阿哥的雍正帝镇楼，保佑码农兄弟姐妹们碰到 bug 时都能迎刃而解：

对了，欢迎大家关注我的同名公众号，所有的文章都是首发在公众号，因为他的审核速度最快。

笨文旨在通过 html2canvas 和 jspdf，先将页面的 html 转成 canvas，再将 canvas 转成 pdf，同时解决了分页截断的问题。

安装依赖

yarn add html2canvas

yarn add jspdf

思路

通过网上的一些教程，初步实现了 html 转 pdf 的功能，将一整个 DOM 元素放进去，虽然可以粗糙实现，但是出现了很多地方被分页截断的情况，这个时候就需要在某一张图片被截断时，将其自动切换到下一页中。

1.拆解父节点

所以第一步：拆解父节点，一行一行细分为很多子节点，循环遍历这些子节点，累加这些子节点的高度，如果超出了 a4 纸（210*297）的高度，则分页。

import html2Canvas from "html2canvas";

import JsPDF from "jspdf";



export function oneNodeMultipleChildren(title, node) {

  html2Canvas(node, {

    scale: 2, // 清晰度

  }).then(function (canvas) {

    let PDF = new JsPDF("", "mm", "a4"); // 以mm为单位

    let position = 0; // 页面偏移

    let contentWidth = canvas.width; // 转换成canvas后的宽度

    let contentHeight = canvas.height; // 转换成canvas后的高度

    let proportion = 210 / node.offsetWidth; // html缩小至a4纸大小时的比例

    let currentHeight = 0; // 当前高度

    let imgWidth = 210; // canvas缩小至a4纸大小时的宽度

    let imgHeight = (210 / contentWidth) * contentHeight; // canvas缩小至a4纸大小时的高度

    let pageData = canvas.toDataURL("image/jpeg", 1.0); // 将canvas转成图片



    for (let j = 0; j < node.children.length; j++) {

      let childHeight = (node.children[j].offsetHeight + 8) * proportion; // 页面中每行的间距 margin-bottom: 8px



      if (currentHeight + childHeight > 297) {

        // 如果加上这个子节点后内容超出a4纸高度，就从当前位置开始分页

        addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight);

        position -= currentHeight; // 这一页放了多少高度的内容，下一页就从这个高度开始偏移

        if (position >= -contentHeight) {

          PDF.addPage(); // 添加新pdf页

        }

        currentHeight = childHeight; // 下一页第一个元素的高度

      } else {

        currentHeight += childHeight;

      }

    }

    addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight); // 最后一页

    PDF.save(title + ".pdf");

  });

}



function addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight) {

  PDF.addImage(pageData, "JPEG", 0, position, imgWidth, imgHeight); // 在当前pdf页添加图片

  PDF.setFillColor(255, 255, 255); // 遮挡的颜色

  PDF.rect(0, currentHeight, 210, Math.ceil(297 - currentHeight), "F"); // 添加空白遮挡

  // PDF.rect参数分别为：起始横坐标、起始纵坐标、绘制宽度、绘制高度、填充色

}

2.合并父节点

经过上述步骤，一个父节点多个子节点，并且每个子节点独占一行的布局可以实现分页，那要是有很多父节点呢？就需要遍历每个父节点，合并所有子节点，进行分页截断。

import html2Canvas from "html2canvas";

import JsPDF from "jspdf";



export function exportPdf(title, id) {

  let content = document.querySelector(`#${id}`);

  let first = content.firstElementChild.firstElementChild;

  let second = content.lastElementChild;

  oneNodeMultipleChildren(title, content, [first, second]);

}



export function oneNodeMultipleChildren(title, content, nodes) {

  html2Canvas(content, {

    scale: 2,

  }).then(function (canvas) {

    let PDF = new JsPDF("", "mm", "a4");

    let position = 0;

    let contentWidth = canvas.width;

    let contentHeight = canvas.height;

    let proportion = 200 / content.offsetWidth;

    let currentHeight = 0;

    let imgWidth = 200;

    let imgHeight = (200 / contentWidth) * contentHeight;

    let pageData = canvas.toDataURL("image/jpeg", 1.0);



    for (let i = 0; i < nodes.length; i++) {

      // 根据传入的父节点数量进行循环，遍历父节点，合并所有子节点

      for (let j = 0; j < nodes[i].children.length; j++) {

        let childHeight = (nodes[i].children[j].offsetHeight + 8) * proportion;



        if (currentHeight + childHeight > 287) {

          addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight);

          position -= currentHeight;

          if (position >= -contentHeight) {

            PDF.addPage();

          }

          currentHeight = childHeight;

        } else {

          currentHeight += childHeight;

        }

      }

    }

    addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight);

    PDF.save(title + ".pdf");

  });

}



function addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight) {

  PDF.addImage(pageData, "JPEG", 0, position, imgWidth, imgHeight); // 在当前pdf页添加图片

  PDF.setFillColor(255, 255, 255); // 遮挡的颜色

  PDF.rect(0, currentHeight, 210, Math.ceil(297 - currentHeight), "F"); // 添加空白遮挡

}

3.每行多个元素

这个时候新的问题出现了，由于页面布局为 flex 布局，不同缩放下，每行的元素数量会出现变化。所以我们获取第一个子元素与 a4 纸宽度关系，如果为 n 倍，那后面 n-1 个子元素的高度不进行累加。

warning 注意
这里只解决了一行 n 个子元素宽度相等，且近似等于 a4 纸宽度的 1/n 的情况。

import html2Canvas from "html2canvas";

import JsPDF from "jspdf";



export function exportAssetPdf(title, id) {

  let content = document.querySelector(`#${id}`);

  let first = content.firstElementChild.firstElementChild;

  let second = content.lastElementChild;

  oneNodeMultipleChildren(title, content, [first, second]);

}



export function oneNodeMultipleChildren(title, content, nodes) {

  html2Canvas(content, {

    scale: 2,

  }).then(function (canvas) {

    let PDF = new JsPDF("", "mm", "a4");

    let position = 0;

    let contentWidth = canvas.width;

    let contentHeight = canvas.height;

    let proportion = 200 / content.offsetWidth;

    let currentHeight = 0;

    let imgWidth = 200;

    let imgHeight = (200 / contentWidth) * contentHeight;

    let pageData = canvas.toDataURL("image/jpeg", 1.0);

    let sameIndex = 1;

    let widthX = 1;



    for (let i = 0; i < nodes.length; i++) {

      for (let j = 0; j < nodes[i].children.length; j++) {

        let childHeight = (nodes[i].children[j].offsetHeight + 8) * proportion;

        let childWidth = nodes[i].children[j].offsetWidth * proportion;

        if (sameIndex === 1) {

          widthX = Math.round(200 / childWidth);

        }

        if (sameIndex < widthX) {

          childHeight = 0;

          sameIndex++;

        } else {

          sameIndex = 1;

        }



        if (currentHeight + childHeight > 287) {

          addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight);

          position -= currentHeight;

          if (position >= -contentHeight) {

            PDF.addPage();

          }

          currentHeight = childHeight;

        } else {

          currentHeight += childHeight;

        }

      }

    }

    addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight);

    PDF.save(title + ".pdf");

  });

}



function addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight) {

  PDF.addImage(pageData, "JPEG", 0, position, imgWidth, imgHeight); // 在当前pdf页添加图片

  PDF.setFillColor(255, 255, 255); // 遮挡的颜色

  PDF.rect(0, currentHeight, 210, Math.ceil(297 - currentHeight), "F"); // 添加空白遮挡

}

4.添加左右间距和页眉页脚

为了美化 pdf 布局，上下左右留白，就需要添加左右间距和页眉页脚：减少 html 缩小至 a4 纸大小时的比例和 canvas 缩小至 a4 纸大小时宽高，增加偏移量，并对页眉页脚进行空白遮挡。

import html2Canvas from "html2canvas";

import JsPDF from "jspdf";



export function exportAssetPdf(title, id) {

  let content = document.querySelector(`#${id}`);

  let first = content.firstElementChild.firstElementChild;

  let second = content.lastElementChild;

  oneNodeMultipleChildren(title, content, [first, second]);

}



export function oneNodeMultipleChildren(title, fNode, sNode) {

  html2Canvas(fNode, {

    scale: 2,

  }).then(function (canvas) {

    let PDF = new JsPDF("", "mm", "a4");

    let position = 0;

    let contentWidth = canvas.width;

    let contentHeight = canvas.height;

    let proportion = 200 / fNode.offsetWidth; // 减少10mm

    let currentHeight = 0;

    let imgWidth = 200; // 减少10mm

    let imgHeight = (200 / contentWidth) * contentHeight; // 减少10mm

    let pageData = canvas.toDataURL("image/jpeg", 1.0);

    let sameIndex = 1;

    let widthX = 1;



    for (let i = 0; i < sNode.length; i++) {

      for (let j = 0; j < sNode[i].children.length; j++) {

        let childHeight = (sNode[i].children[j].offsetHeight + 8) * proportion;

        let childWidth = sNode[i].children[j].offsetWidth * proportion;

        if (sameIndex === 1) {

          widthX = Math.round(200 / childWidth); // 减少10mm

        }

        if (sameIndex < widthX) {

          childHeight = 0;

          sameIndex++;

        } else {

          sameIndex = 1;

        }



        if (currentHeight + childHeight > 287) {

          // 减小10mm

          addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight);

          position -= currentHeight;

          if (position >= -contentHeight) {

            PDF.addPage();

          }

          currentHeight = childHeight;

        } else {

          currentHeight += childHeight;

        }

      }

    }

    addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight);

    PDF.save(title + ".pdf");

  });

}



function addImage(PDF, pageData, position, imgWidth, imgHeight, currentHeight) {

  PDF.addImage(pageData, "JPEG", 5, position + 5, imgWidth, imgHeight); // 增加偏移量

  PDF.setFillColor(255, 255, 255);

  PDF.rect(0, 0, 210, 4, "F"); // 添加页眉遮挡

  PDF.rect(0, currentHeight + 5, 210, Math.ceil(292 - currentHeight), "F"); // 添加页脚遮挡

}

成果展示

不同缩放下导出 PDF 对比：

每行一个子元素

每行多个子元素

引言

HTML中  <a>  元素（或称锚元素）可以通过它的 href 属性创建通向其他网页、文件、电子邮件地址、同一页面内的位置或任何其他 URL 的超链接。

<a> 中的内容应该指明链接的目标。如果存在 href 属性，当 <a> 元素聚焦时按下回车键就会激活它。

本文主要讲解如何通过a标签来下载文件。

download属性

浏览器将链接的 URL 视为下载资源。可以使用或不使用 filename 值：

• 
  

  如果没有指定值，浏览器会从多个来源决定文件名和扩展名：

  
  
  
  
  • Content-DispositionHTTP 标头。
  
  
  • URL的最后一段。
  
  
  • 媒体类型。来自 Content-Type 标头，data: URL的开头，或 blob: URL 的 Blob.type
  
  
  
  


• 
  

  filename：决定文件名的值。/ 和 \ 被转化为下划线（_）。文件系统可能会阻止文件名中其他的字符，因此浏览器会在必要时适当调整文件名。

  
  

备注：

• download 只在同源 URL或 blob:、data: 协议起作用。


• 浏览器对待下载的方式因浏览器、用户设置和其他因素而异。在下载开始之前，可能会提示用户，或者自动保存文件，或者自动打开。自动打开要么在外部应用程序中，要么在浏览器本身中。


• 如果 Content-Disposition 标头的信息与 download 属性不同，产生的行为可能不同：


• 如果文件头指定了一个 filename，它将优先于 download 属性中指定的文件名。


• 如果标头指定了 inline 的处置方式，Chrome 和 Firefox 会优先考虑该属性并将其视为下载资源。旧的 Firefox 浏览器（版本 82 之前）优先考虑该标头，并将内联显示内容。

下载方式

1. 直接使用a标签的href属性指定文件的URL

可以在a标签中使用href属性指定文件的URL，点击链接时会直接下载文件。

<a href="file_url">Download</a>

优点：简单易用，只需在a标签中指定文件的URL即可。

缺点：无法控制下载文件的名称和保存位置。

2. 使用download属性指定下载文件的名称

可以在a标签中使用download属性指定下载文件的名称，点击链接时会将文件以该名称保存到本地。

<a href="file_url" download="file_name">Download</a>

优点：可以控制下载文件的名称。

缺点：无法控制下载文件的保存位置。

3. 将文件数据转为Blob进行下载

当需要将文件数据转为Blob或Base64进行下载时，可以使用以下方法：

1. 将文件数据转为Blob进行下载

function downloadFile(data, filename, type) {

  const blob = new Blob([data], { type: type });

  const url = URL.createObjectURL(blob);



  const link = document.createElement('a');

  link.href = url;

  link.download = filename;



  document.body.appendChild(link);

  link.click();



  document.body.removeChild(link);

  URL.revokeObjectURL(url);

}



function fileToBlob(file) {

  return new Promise((resolve, reject) => {

    const reader = new FileReader();



    reader.onloadend = () => {

      resolve(new Blob([reader.result], { type: file.type }));

    };



    reader.onerror = reject;



    reader.readAsArrayBuffer(file);

  });

}



// 使用示例

const fileData = ...; // 文件数据

const fileName = 'example.txt';

const fileType = 'text/plain';



fileToBlob(fileData).then(blob => {

  downloadFile(blob, fileName, fileType);

});

首先，我们定义了一个名为downloadFile的函数，它接受三个参数：文件数据（data），文件名（filename）和文件类型（type）。 在函数内部，我们使用Blob构造函数将文件数据和类型传递给它，从而创建一个Blob对象。然后，我们使用URL.createObjectURL()方法创建一个URL，该URL指向Blob对象。 接下来，我们创建一个<a>元素，并设置其href属性为之前创建的URL，并将下载属性设置为指定的文件名。然后将该元素添加到文档的body中。 最后，我们模拟用户点击该链接进行下载，并在完成后清理相关资源。

在使用时，我们首先调用fileToBlob函数将文件数据转换为Blob对象。该函数返回一个Promise对象，在Promise的resolve回调中返回了转换后的Blob对象。 然后，在Promise的回调中调用了downloadFile函数来进行下载。

2. 将文件数据转为Base64进行下载

function downloadBase64File(base64Data, filename, type) {

  const byteCharacters = atob(base64Data);

  const byteArrays = [];



  for (let i = 0; i < byteCharacters.length; i++) {

    byteArrays.push(byteCharacters.charCodeAt(i));

  }



  const blob = new Blob([new Uint8Array(byteArrays)], { type: type });

  const url = URL.createObjectURL(blob);



  const link = document.createElement('a');

  link.href = url;

  link.download = filename;



  document.body.appendChild(link);

  link.click();



  document.body.removeChild(link);

}



function fileToBase64(file) {

 return new Promise((resolve, reject) => {

   const reader = new FileReader();



   reader.onloadend = () => {

     resolve(reader.result.split(',')[1]);

   };



   reader.onerror = reject;



   reader.readAsDataURL(file);

 });

}



// 使用示例

const fileData = ...; // 文件数据

const fileName = 'example.txt';

const fileType = 'text/plain';



fileToBase64(fileData).then(base64Data => {

  downloadBase64File(base64Data, fileName, fileType);

});

首先，我们定义了一个名为downloadBase64File的函数，它接受三个参数：Base64字符串（base64Data），文件名（filename）和文件类型（type）。 在函数内部，我们首先将Base64字符串解码为字节数组，并将其存储在byteArrays数组中。然后，我们使用这些字节数组创建一个Blob对象，并使用URL.createObjectURL()方法创建一个URL。 接下来，我们创建一个<a>元素，并设置其href属性为之前创建的URL，并将下载属性设置为指定的文件名。然后将该元素添加到文档的body中。 最后，我们模拟用户点击该链接进行下载，并在完成后清理相关资源。

在使用时，我们首先调用fileToBase64函数将文件数据转换为Base64字符串。该函数返回一个Promise对象，在Promise的resolve回调中返回了转换后的Base64字符串。 然后，在Promise的回调中调用了downloadBase64File函数来进行下载。

总结

您可以根据需要选择将文件数据转为Blob或Base64进行下载。如果您已经有文件数据，可以使用fileToBlob函数将其转为Blob对象并进行下载。如果您希望将文件数据转为Base64进行下载，可以使用fileToBase64函数将其转为Base64字符串，并使用downloadBase64File函数进行下载。