拥有自由的人，会想什么是自由吗？

这个问题很动人。

就像从不缺氧的人，不会意识到自己在呼吸；只有气压骤降、肺部抽痛、窒息临近，你才突然意识：空气原来不是理所当然的东西。

自由也是一样的。它真正被觉察的时候，往往是在你被拿走的时候。
不是所有人都有幸拥有“思考自由”的资格——更大的现实是，大多数人连“自由”这个词，在生活中都用不上。

但更残酷的问题是：一旦你开始思考自由，你可能就已经不再自由了。

意识是自由的开始，还是终结？

我们都羡慕小孩的自由，羡慕他们想哭就哭、想跑就跑。那是因为他们没有太多意识，不懂责任，不预设后果。他们拥有的，某种程度上就是我们说的“纯粹的自由”。

但我们一旦有了意识，就不得不开始自我规训。
你不能说错话，不能做错事，不能轻易违背别人的期待，也不能轻易违背自己的设定。这时候，自由就变成了一个带着锁链的词——它不再是“你想干嘛就干嘛”，而是“你要先知道你干嘛，然后想清楚值不值得干”。

你开始意识它，珍惜它，运用它。听上去很高尚，但自由就没那么轻盈了。你得为每一个选择负责。你得考虑代价。你得思考背后有没有人被伤害，代价是否能承受。那时候你拥有的自由，不再是“想干嘛就干嘛”，而是“想清楚还能不能干”。

于是我们陷入悖论：越意识自由，就越离自由远。

真自由，是不是只能不想自由？

也许真自由的极致状态，就是你不再思考自由。

你骑车穿过黄昏，不想目标，不管导航，只有风。那一刻你自由得像只鸟——不是因为你想清楚“我现在自由”，而是因为你根本没想。

但人做不到这一点。
人思考，自我意识，把自己从自然的状态中拉出来。他要赋予意义，要预测后果，要制定计划、要写年中总结。“思考”是人成为人的标志，但恰恰是这种人性，把自由给污染了。

你可以试着淡化思考和责任，去贴近那种“纯粹的自由”。
但走到尽头，你会发现，那个状态更像动物，或者神明——不是人。

佛陀顿悟时抛弃自我，道家讲“无为而无不为”，他们都靠剥离世俗意义、剥离责任来获得自由。但代价是：你不再是你了。你不再参与、不再牵挂、不再卷入——你从人间抽身而出。

那还是你想要的吗？
你想要的自由，真的是那种不思考、不负责、无我无念的“纯粹自由”吗？还是你其实想要的是“有方向、有意义、有选择权的自由”？

那就不是“纯粹的自由”，而是“人的自由”了。
被命名，被负重，被理性打磨过的一种自由。

成年人的自由，成熟还是无奈？

很多人问：我们活在这种“既不能无意识、又不能无限选择”的自由状态里，算不算一种折中？
是深刻的选择，还是没办法的接受？

我想，这两种说法都对。

是选择的深刻，是因为我们终于知道，自由不是想干嘛就干嘛，而是想清楚干嘛还敢干。我们学会了在有限中谋局，在责任中行事，在约束中寻找空间。

是无奈的接受，是因为这世界本就不为个体设计。你生而有父母、有文化、有制度、有边界，你不是赤条条的自由人，而是注定被驯服的社会动物。

所以这就是我们大多数人的状态：在责任和意义之间拉扯，在妥协与坚持中微调。我们既不彻底自由，也没有完全被束缚。我们像在悬崖边站着，一边看风景，一边找落脚点。

真自由的瞬间：不解释、无恐惧、自己买单

有没有真正自由的时刻？有。

也许它不是持续性的，不是状态，而是一个个“瞬间”：

• 你做了一个决定，没有任何人强迫，也没有任何人能为你负责，但你依然选了它。


• 你拒绝了别人的定义，不害怕后果，不需要解释，也不留退路。


• 你明知代价高昂，但你还是咬牙说：“是我选的。”

这些时刻，就是成年人的自由瞬间。它不一定光鲜，但它是真实的。

不是没有限制，而是你在限制中还敢动，还想选，还愿意承担结果。

小时候我们追求的自由，是不要规则、不要约束。
长大后我们追求的自由，是在规则中拥有自己的边界感，在约束中活出自己的形状。

我们不会再轻易喊口号，也不会高谈“我要自由”。因为我们知道，自由并不是要来讲的，而是用来活的。

自由从来不是站在天台上的呼喊，而是你在清晨醒来，决定今天以什么方式活。

有些人一生都在寻找自由，却不知：
你敢为自由付出代价的那一刻，你就已经自由了。

推荐阅读

房产票据价值模型：7张票拆解一套房的真正价值，推演未来涨跌

什么是好婚姻？一场人类与AI直指婚姻本质的深度对话，带你认清自己

互联网打工人如何构建稳定的社会身份？——从腾讯离职到圈层断崖的思考

互联网人，为什么你越来越能干，路却越走越窄？换个体制内视角看看

从“奶妈”的消失看“母职外包”：自由是建立在别人无法选择的人生之上

我技术成长了，但人生没痕迹，可能这就是程序员的遗憾吧

我用扣子空间制作了档小宇宙播客《语出惊人》，借AI之口犀利对谈人生困境，效果惊艳

程序员如何在家庭、工作、健康之间努力找平衡

前言

作为程序员，我们每天都要面对 工作、家庭、健康 的三重压力。加班是常态，学习新技术是必须，家人的期待也不能忽视，而自己的身体却在无声抗议……

如何在代码、生活和健康之间找到平衡？ 今天，我想分享自己的实践心得——时间管理、高效工作（甚至合理摸鱼）、坚持运动和培养爱好，让生活不再只有996。

1. 时间分配：你不是没时间，只是没规划

很多人抱怨"太忙了，根本没时间"，但其实：

• 时间就像海绵里的水，挤一挤总会有


• 关键在于优先级，而不是时长

（1）工作日时间分配（参考）

关键点：

• 早起1小时 > 熬夜3小时（效率更高，不影响健康）


• 午休小睡能提升下午效率（NASA研究证实）


• 晚上固定家庭时间（让家人感受到你的存在）

2. 上班摸鱼的正确姿势（高效工作法）

摸鱼 ≠ 偷懒，而是 科学调整工作节奏，避免 burnout（职业倦怠）。

（1）合理摸鱼技巧

✅ 番茄工作法：25分钟专注 + 5分钟休息（刷掘金、喝水、拉伸）

✅ 每1小时起身活动：接水、上厕所、简单拉伸（预防颈椎病）

✅ 利用自动化工具：写脚本省时间（比如自动生成周报、批量处理数据）

✅ 学会"战略性拖延"：非紧急需求先放一放，等PM改需求（你懂的）

（2）减少无效加班

❌ 无意义会议：能异步沟通的绝不开会

❌ 过度追求完美：代码能跑就行，别陷入"过度优化陷阱"

❌ 盲目卷工时：效率 > 工作时长，早点干完早点走

摸鱼的核心是：用更少的时间完成工作，把省下的时间留给生活。

3. 下班后：运动 + 兴趣，找回生活掌控感

（1）运动：程序员最值得的投资

• 每天10分钟拉伸（改善肩颈酸痛）


• 每周3次有氧运动（跑步、游泳、骑行）


• 利用通勤时间运动（骑车上班、步行回家）

（亲测有效） 自从坚持运动，我的腰不酸了，debug效率都提高了！

（2）培养兴趣爱好，对抗职业倦怠

• 学一门非技术技能（摄影、吉他、烹饪）


• 参加线下活动（技术沙龙、运动社群）


• 每周留出"无屏幕时间"（比如读书、拼乐高）

生活不能只有代码，否则你会变成一个无聊的人。

4. 家庭时间：质量 > 数量

• 每天30分钟专注陪伴（不刷手机，认真听家人说话）


• 周末至少半天家庭日（哪怕只是逛超市、一起做饭）


• 重要日子提前安排（生日、纪念日，绝不缺席）

孩子不会记住你加了多少班，但会记住你是否陪他踢过球。

结语：平衡是动态的，不是完美的

程序员的生活就像 多线程编程——工作、家庭、健康，每个线程都要分配好资源，否则就会死锁。

我的经验是：

掘友们，你们是如何平衡工作、家庭和健康的？欢迎在评论区分享你的经验！

（如果觉得有用，点个赞吧～ 🚀 你的支持是我分享的动力！）

关于作者

一个拒绝996的程序员，相信 代码是为了更好的生活，而不是取代生活。

关注我，了解更多程序员成长 & 生活平衡技巧！

引言

前两天有个朋友劝我：“你写作一年半了，再不搞点产品变现，继续写作两三年，可能还是原地踏步。”

写了一年半，80多篇文章，没涨粉、没变现、也没10w+。很多人觉着我白干了，可我反而觉着，这是我这几年做的最对的一件事情。

现在回头看看，真正让我成长的，恰恰是那些“什么都没做”的时光。

浪费时间才能感受到自由且主观的愿望

我们这一代人对时间的利用，已经开发到了极致，有着极强的目的性。

高中时，排队打饭背单词，午休趴在床上背公式。

大学毕业，为了面试背八股文、刷算法。

在大厂，一空下来就去研究新技术、优化工作流......

我从未停下来过，连休息都像在为下一次奔跑而准备。

我们太怕浪费时间了。

怕没成果，怕落后，怕被这个飞速发展的社会淘汰掉。

可你想想，我们来到这个世界，不应该是来探索和体验的吗，我们看似高效利用了时间，可有多少时间是真的为了你自己呢。

上篇文章我提到，回到济南之后，相比在北京有了更多空闲时间，并且开始“补偿性浪费”，刷短视频、打游戏、炒股，算得上不务正业。

有一天孩子睡觉后，我从8点刷抖音刷到凌晨，但没有记住任何内容，那一刻我有一种无所事事的空虚感。

于是我开始换口味，刷一些技术社区、公众号文章。偶尔点进一些作者的首页，我发现他们很多并不是大V，也没有露脸，但写的文字有一种特别的力量。

他们写自己的经历、认知的变化、对技术和生活的思考，字里行间有诚意也有深度，我有点羡慕，也有点触动。

既然他们可以写，我也可以。

那一刻我才想起来，我好像很早之前就喜欢写东西，只不过后来成家立业，一路奔波，把这件事丢在了脑后而已。

这么多年，我总是忙着成为别人期待的样子，却很少问自己一句：我到底喜欢什么？

于是我开始尝试着表达自己，一开始不为流量也不为变现，就只是为了找回一点属于自己的空间，

现在回头看，那段“虚度光阴”的日子，并不是浪费，而是我停下来，等到了那个被遗忘很久的自己。

时间看似浪费，但是在塑造你

有一次晚上睡觉前，随手打开了一篇去年写下的文章。

看着看着感到睡意全无，逻辑混乱、语句稚嫩，没有原创的观点，更没有什么进步，可怕的是这样的文章我重复了这么多遍，我忍不住怀疑自己这一年到底在干些什么。

还有一次我花了4、5天写下了3000字，写完读了一遍，发现整个逻辑有些牵强，于是我把写下的内容挪到了“回收站”里，那一刻我感觉我自己浪费了好几天的时间。

这些文章，没有涨粉，也没有变现，也没写出个10w+，那种感觉我自己都很难说清楚，明明花了时间和精力，却有一种什么都没留下的“无力感”。

有几个一起做公众号的朋友，已经走通了自己的商业闭环，而我却连个精准的定位都没有。有一段时间我经常会陷入自我怀疑，我这样的坚持到底有没有意义。

一直以来好像都很着急，我习惯了“投入—产出—收益”的闭环，反倒忘了有些事情短期就是看不到结果。

可就是在这样反复挣扎的过程中，我好像有了一点变化，并不是我变得更高效了，而是我越来越清楚自己想表达些什么，想成为什么样的人。

我做自媒体之初并没有定位，可慢慢的我在过去80多篇文章中，我慢慢发现了几条主线。

比如作为这个时代的一个普通人，我喜欢分析一下时代困局，比如越来越卷的互联网，比如AI飞速发展下，我们面临的存在主义危机；

我热衷谈论认知提升的话题，如果我们要和那些优秀的人去对比，我们会发现除了财富和见识，差距最大的可能是认知边界；

我会谈论一些写作相关的东西，因为写作在这个人人都可以是一个品牌的时代，写作本身就是竞争力。

这几个方向不是我刻意设计出来的，而是过去敲下的每一个字塑造出来的。

我想起乔布斯在斯坦福大学演讲时分享的故事，乔布斯曾在大学退学后，痴迷于书法，选修    了一门看似“无用”的课程：书法美学。

直到十年后，他在打造第一代 Macint0sh 时，那些关于字体的记忆突然涌上心头。他让电脑第一次有了漂亮的字体系统，正是这件“没用的事”，让 Apple 成为了极少数“兼具科技与艺术”的品牌。

很多事情只有回头看，点才会连接成线，你想想是不是这样。

而这一切的前提是：你愿意为此“浪费时间”。

我现在怎么与时间相处的

最后一点想聊聊提升效率这回事——真正的高效，不是把时间填满，而是敢于浪费一些时间。

有孩子的人一定都有体会，娃绝对算的上是一个「时间剥夺兽」。

我为了抢夺时间，做了特别多的尝试：比如孩子一安静下来，我就赶紧打开手机看篇文章；给娃刷奶瓶刷碗的时候，我就打开听书；甚至陪孩子的时候，嘴上给他讲着故事，脑海里还不停的想一些自己的事情。

我一直试图绷紧脑海里的一根弦，觉着只要把时间用满了，就没有浪费。

但现实是，我越来越累，状态越来越差，效率越来越低。

其实我们没必要给自己较劲。

直到读了《超高效》这本书，我才意识到，大脑的原始设定，并不是持续“高负荷”的，而是分成了三种运行状态，符合幂律分布的节奏。

横坐标代表了工作强度，纵坐标代表频率。书里面列举了很多人类学家对原始部落的观察：那些采集、狩猎为生的人，绝大部分时间都是在放松，走走停停，一点也不忙碌。只有在必要的情况下，才会去长时间奔跑去追踪一个猎物，而且干一次得休息好几天。

大部分时间做轻松的事情，偶尔上个强度，才是我们人类天然适合的状态。

而我们日常的工作和生活却反过来了，试图每小时都高产，每天都有 产出，哪怕放假都不敢停歇。

你想想是不是很多人都这样？多少大厂的程序员，被一个bug卡住半天，却死盯着屏幕不愿站起身。明明已经困的上下眼皮打架，还是逼着自己熬夜敲着代码。领导看着没完成的工作量很大，就强迫大家周六周日加班赶进度。

你想想你身边是不是还有另一种人？

你在工位磨磨蹭蹭写代码的时候，同事下楼散散步，买了杯咖啡，再次坐回工位上时，一个小时的工作量比你半天的还要多。

更讽刺的是，代码质量还比你高。

我们为什么不允许自己休息休息呢，让自己“浪费”点时间呢？

后来我做出了个改变，我再带孩子出去玩的时候，试着清空大脑，绝不再想下一篇文章的选题，也不想工作上的事情，就是专心的陪着孩子玩。他跑我就追，他笑我便笑，他想要只小虫子，我就抓只蚂蚁放到他手里。

看似一整天我都“没干正事”，可大脑深度放松之后，迅速让我进入高效状态。有时候写着写着没思路了，下楼转一圈卡点就能被解开。

我突然认识到，娃哪是“时间剥夺兽”，而是一个提醒我“别太紧绷”的小天使。

你也可以当自己的小天使。

如果你感到很累，就去看会轻松的小说、看看搞笑的短视频吧，只要让自己的注意力放松下来就好。如果你很累，还对工作和生活的事很担心，就出去跑一圈、打局游戏或者正念冥想，先把那个担心放下再说。

更简单的方法是订一个闹钟，千万别让自己持续工作超过90分钟，15分钟的小睡能让你迅速恢复精力。

你需要停一停，你值得等一等。

说在最后

现在越来越多的年轻人，哪怕是换份工作，都不敢在这个时候多休息几天。比如我自己，几次跳槽，从来都是今天离职，明天入职。

“浪费时间”说起来容易，可我们心理的的确确存在一些不安全感：怕别人说自己躺平，怕简历又多出一个空档期，更害怕自己没有薪资无法证明自己的价值。

可你知道吗，这些不安全感，并不是我们自身的问题，而是这个时代的结构性压力。

教育体系从小把“高效”描述成美德，互联网把内卷和35岁危机当成噱头大肆宣传，自媒体正贩卖着“日入过万”、“自由职业”的焦虑。

可丁可卯，做每一件事都只注重效率绝不浪费时间，一天到晚跟打仗一样连说闲话的时间都没有，很难做真正重要的事，高水平工作需要浪费时间。

你有多久，没允许自己浪费点时间了？

这是东东拿铁的第83篇原创文章，欢迎关注。

引言

你还记得，上一次真正感受到快乐，是在什么时候吗？

认真想了想，我好像很久没有体会过那种真正让人开心的时刻了。朋友和家人问我最近怎么样，我会回答“还行”、“还不错”，但实际上家庭的琐事，工作的压力，对未来的焦虑，让我连半刻的放松都是一种“奢侈”。

这种状态不只我一个人，身边的朋友也是如此，日常聊天里被越来越多的烦、忙、累填满，有时候甚至“无聊”都成为了一种常态。

可我们小时候，一件新衣服、一个新游戏、一集刚更新的《火影忍者》就能让自己兴奋得整夜睡不着觉。

而现在，曾经喜欢的游戏懒得打开；过去喜欢约上三五好友聚会，现在休息的时候只想窝在家里；哪怕是自己最喜欢的动漫和电影，也没有按下播放键的冲动。

是因为我们长大了、变成熟了，身上的担子越来越重，以至于连快乐都无处安放了吗？

如果你对凡事都提不起兴趣，找不到快乐的方向，那得小心了——心理学上有一个术语，叫做「快感缺乏症」。长期的快感缺失会让我们失去对生活的敏感度，不仅难以感受快乐，还容易陷入负面情绪无法自拔，还有可能导致抑郁。

那么——快乐为什么消失了？我们又该如何找回它？

要找回快乐，就要从我们那个既熟悉又陌生的名字说起：多巴胺。

多巴胺不是快乐源泉

很多人以为，多巴胺是“快乐荷尔蒙”，但其实，它并不直接带来快乐，而是——激励。它并不会让你沉浸在此刻的满足，而是让你对现状“不满足”。它让我们不满足于现状，而是不断前进。

多巴胺能强烈驱动动机，但是它的激励效应转瞬即逝。一旦我们吃饱喝足、或者满足了我们的什么愿望之后，多巴胺的奖励作用就会消失，促使着我们去寻找下一份刺激。

在远古时代，这对于人类来说是一个非常重要的生存机制。因为食物短缺，安全难求，原始人几乎需要用80%的时间去觅食和寻找庇护上。大脑通过分泌多巴胺，促使他们保持求生欲，永不停歇。

然而到了现代社会，我们的生活方式彻底发生转变，而大脑的运作方式没有得到进化。于是大脑的多巴胺通路被频繁激活，远超我们所能接受的频率。

除了食物和性这些本能，酒精、电子游戏、网购，甚至是社交媒体的点赞，都在无时无刻挑动着我们体内的多巴胺。原始人辛苦一天才能换回的一丝快感，我们轻而易举的就能让它泛滥。

快乐太容易得到了，于是它反而越来越难感受到了。

多巴胺会激活「D2」型受体， 它的特点是收到太多多巴胺之后会产生“脱敏”，并且还会启动抑制机制，一旦被过度刺激，就会容易“疲劳”，最终让我们变得迟钝、不再敏感。

其实还有另一个罪魁祸首是「皮质醇」，它由肾上腺分泌，能够加速我们的代谢和心跳，让我们随时应对可能出现的威胁，让我们处于专注紧张的状态，但是它会抑制多巴胺的释放。

其实这也是远古时期人类的一种自保机制，可是现代社会节奏忙碌紧张，我们时刻都在为某些事情感到焦虑，比如学习成绩没能提高，工作迟迟没有涨薪，甚至是领导安排的任务马上到了Dead Line。

人体的压力系统，本身是为了突发事件而准备的，并不适合现代社会全天候的压力输入，在随时随地都能接收到各种信息的智能时代，我们的压力系统也被滥用了。

最终结果就是，即使身边的事物都在营造愉悦感，我们也很难感受到愉悦了。

重拾快乐

有一本书叫《消失的多巴胺》，作者在书中给我们提供了一个治愈快感缺乏症的方法，叫做「行为激活法」，这个方法非常简单，用一句话总结就是：记录情绪，列出快乐清单，开始行动，感受快乐，锁定美好。

那具体怎么做呢？首先你要先记录下自己的情绪的初始情况，然后持续记录变化，当你看到变化的发生，你就会有坚持的动力。

然后，找到自己喜欢的事情。你可以为自己列一份快乐清单，比如看电影、逛街，甚至是浇花、换一身新衣服，或者是去买一杯自己喜欢的咖啡，都可以。

接着就是按照清单来行动了，可我们不开心的时候有一个表现就是只想躺平，没有做事的动力。作者告诉我们，在没有做事动力的时候，做事本身就能打破缺乏动力的循环，你应该打消那些让你退缩的念头，说了就去做！

一旦有了行动，心情就可能得到改善，这时候我们就要抓住快乐。方法非常简单，因为我们的大脑一次只能处理一个想法，我们在感受到快乐的时候，集中注意力，在快乐的时刻什么都不想，用心去感受这种体验。

就是在你感受到快乐的时候，别想领导安排的工作，别想马上要还的信用卡和房贷，就感受当下的快乐。

一项研究发现，大脑腹侧纹状体区域的长时间激活与维持积极情绪和奖励直接相关，通过集中精力体会奖励时刻，可以保持高水平的心理健康，同时降低皮质醇的分泌量。

最后一步就是锁定美好时刻，最简单的做法就是感恩。有一种非常流行的方法是写感恩日记，在一天结束时，写下今天你所感激的经历。许多研究都表明，感恩可以增加大脑奖励通路中多巴胺的分泌，大脑会鼓励里去寻找更值得感恩的事物，产生正反馈。

写到这里，我感觉有点疲惫，于是我下楼，站到了阳光底下。

阳光很刺眼，我下意识闭上了眼睛，任由太阳铺满脸庞。阳光有些刺眼、有些灼热，但那一刻，但似乎有某种能量慢慢渗到身体内，驱散了心里的疲惫。

我不和同事说话，不考虑手头的工作，也不去想生活的琐事。只是站在那里，感受阳光，感受微风拂过脸颊，感受自己活在当下。

几分钟而已，心里好像解开了某个结，整个人都变得放松下来。

重拾快乐，其实并不难，其实并不是快乐离我们远去了，而是我们被快节奏的生活裹挟，忘记了如何该寻找它。

到这里，你或许已经从烦躁的情绪中脱身，重新感受到生活中久违的松弛和愉悦。但故事还没有结束——你值得拥有的，不只是回归日常的小快乐，更是那种深层次、持续、更高级的快乐。

更高级的快乐

刚刚提到感恩，可以增加大脑中多巴胺的分泌，也许你会有疑问，现代社会不是多巴胺泛滥了吗？刷短视频、打游戏一样可以获得多巴胺，那感恩带来的多巴胺有什么不一样呢？

当然不一样，不过我们先聊一句我们从小听到大的“金句”——做难而正确的事情。

许多成功者特别喜欢说这句话，那到底怎么做呢？是靠意志力和吃苦吗，是吃得苦中苦，方为人上人吗？是书山有路勤为径，学海无涯苦作舟吗？

成功者没有告诉我们的是，他们做那些难而正确的事情，他们「乐」在其中。这个乐，就来自于多巴胺，而多巴胺分为了「快多巴胺」和「慢多巴胺」。

还记得在介绍多巴胺之前，我说过多巴胺的作用吗？多巴胺并不带给我们快乐，而带给我们的是激励，是让我们兴致勃勃的做事，是一种追逐的快乐。

快多巴胺的触发模式是预测->实现，抽烟、喝酒、打游戏、刷短视频，你预测到了这些行为带给你的奖励，立刻就感受到快乐，简单直接。但是快多巴胺释放门槛低，可重复性高，来得快去的也快。

而慢多巴胺触发的模式是努力->进展。比如跑完今天的五公里，就会感受到今天一天都神清气爽；完成一篇文章，你感觉你的写作和思考能力都加深了一层。你必须先努力一番取得进展，它才能释放。慢多巴胺来得慢，去的也慢。

在字节的时候，有一次和10几个同事封闭在会议室开发一个大项目，临近项目上线的那几天，几乎都到2、3点才下班。每当0点以后都是大家最累的时候，虽然每个人脸上充满困意和疲惫，但是看着项目逐渐成型，功能越来越完善，每个人依然干劲十足。

我们或许都有做大项目的经历，在项目即将完成前，你会叫苦叫累吗？你的目标就在眼前，你做事充满动力，这才是健康的状态。做难而正确的事情，是很爽的。

这段经历过去好多年了，说实话当时做的什么项目我都记不清了，但是我记得一群人在会议室里，一同为项目上线熬夜到凌晨的那几个夜晚。

简单说：快多巴胺是“高起点、小波动、快消退”；慢多巴胺是“低起点、慢上升、慢消退”。两种多巴胺最重要的区别，是它们在大脑中的“接收区”不同，我们的感受也不同。

快多巴胺让我们成瘾，慢多巴胺可以给我们赋能。 我们应该防止自己沉溺于快多巴胺，多来点慢多巴胺。

理解了快多巴胺和慢多巴胺的原理，我们就能明白一个道理，为什么人生需要一个长远的目标。

有目标才能有行动，有行动就会有进展，追逐目标的过程能够带来慢多巴胺，而慢多巴胺对我们而言多多益善。

说在最后

所以，快乐并没有从我们身边消失，它只是在等着我们把它找回。

我们需要的不是更快的满足，也不是更高频的刺激，而是更沉浸的体验和更深入的积累。

“还行、还不错”不是标准答案，“很好、很开心”才是你的原本色彩，你永远值得拥有那种不焦虑、不躁动，却一直点亮我们生活的快乐。

那么你呢，你今天开心吗？

这是东东拿铁的第79篇原创文章，欢迎关注。

提到 Jetbrains 这家公司，相信搞开发的同学应该都不陌生。

该公司盛产各种编程 IDE 和开发工具，虽然2000年才成立，到现在却已经发布了超 30 款世界顶级的编程软件，同时也收获了来自全球范围内开发者和用户的青睐。

众所周知，在去年10月份的时候，Jetbrains 曾经搞过一个大动作，那就是：

官宣 WebStorm 和 Rider 这两款强大的 IDE 对非商业用途全面免费！

当时这个消息出来的时候，就曾在开发者圈子里引起了一阵轰动和讨论。

而且我清楚地记得，在当时的评论区，还有小伙伴这样问道：

“啥时候轮到 CLion 也免费呢？”

这不，好消息再次来临了！！

最近 Jetbrains 再度官宣：

CLion 从现在开始，对非商业用途全面免费！

众所周知，CLion 是由 JetBrains 设计开发的跨平台 C/C++ 集成开发环境，通过智能代码补全、深度代码分析和集成调试工具，为开发者提供高效、现代化的 C 语言和 C++ 开发体验。

然而，CLion 一直以来的高昂授权费用也让不少初学者和开源爱好者为之望而却步。

因此这回消息一出，又再次在开发者圈子里引起了一阵热烈的讨论，不少网友直呼 Jetbrains 这波格局打开了。

看到这里，相信大家也挺好奇，那他们这里所说的 「非商业用途免费」具体指的是哪些情形呢？

对此，Jetbrains 官方也给出了对应的说明，目前的非商业用途情形包括像：学习、自我教育、开源项目开发、内容创作、业余爱好开发等场景就可以免费使用这个 IDE 。

所以现在无论是学生、Arduino 开发者，还是无惧 C 语言和 C++ 重重挑战的忠实爱好者，只要使用场景不涉及商业活动，都可以来免费使用 CLion 进行开发。

说到这里，那具体的非商业用途免费版 CLion 怎么申请和使用呢？

操作其实也非常简单。

1、首先，去官网下载 CLion 安装包并安装。

不过这里要注意的是，用户需要确保下载的 IDE 版本是支持非商业许可证的最新版本即可。

2、启动运行 IDE 后，将会看到一个许可证对话框。

在该对话框中，用户可以在其中选择 Non-commercial use（非商业用途）选项。

3、登录自己的 JetBrains Account 或创建一个新的帐户。

4、登录完成后，用户需要接受 Toolbox 非商业用途订阅协议。

5、尽情享受在 IDE 中的开发。

包括如果用户已经开始了试用期或使用付费许可证激活了自己的 IDE，也仍然可以改用非商业订阅，只需要转到帮助|注册里，并在打开的窗口中点击 Remove License（移除许可证）按钮，然后再选择 Non-commercial use（非商业用途）就行了。

不过这里依然还有两个点需要格外注意。

第一点，也是官方公告里明确所说的。

如果用户选择使用 Non-commercial use 非商业用途的免费版，那软件是有可能会向 JetBrains 发送 IDE 遥测信息的，包括像：框架、产品中使用的文件模板、调用的操作，以及与产品功能的其他交互，但是官方提到不会包含个人数据。

另外还有一点需要注意的是，虽说免费版本的 IDE 在功能上与付费版本并无二致，但在某些特定功能上可能存在一定的限制。例如，免费版本的 Code With Me 功能将仅限于 Community 版本。

不过对于大多数非商业用途的开发者们来说，这些限制并不会对日常开发工作造成太大的影响。

所以总而言之，JetBrains 推出的这些非商业用途免费使用政策，虽说有一些要求，但是总体来说还是极大地降低了 JetBrains IDE 的使用门槛。

同时也会让更广泛的用户群体更容易获取并使用，从而鼓励更多的人投身于编程学习，参与到开源项目的建设，共同推动技术的进步与发展。

文章的最后，我们也不妨再次大胆憧憬一下：

既然目前的 WebStorm、Rider 以及 CLion 都已经开放了非商业用途的免费使用，那么接下来像： GoLand、IntelliJ IDEA 等的免费开放还会不会远呢？

再次期待 Jetbrains 的下一步操作。

注：本文在GitHub开源仓库「编程之路」 github.com/rd2coding/R… 中已经收录，里面有我整理的6大编程方向(岗位)的自学路线+知识点大梳理、面试考点、我的简历、几本硬核pdf笔记，以及程序员生活和感悟，欢迎star。

点赞 + 关注 + 收藏 = 学会了

在 p5.js 中，arc() 函数用于绘制圆弧，它是创建各种圆形图形和动画的基础。圆弧本质上是椭圆的一部分，由中心点、宽度、高度、起始角度和结束角度等参数定义。通过灵活运用 arc() 函数可以轻松创建饼图、仪表盘、时钟等常见 UI 组件，以及各种创意图形效果。

arc() 的基础语法

基础语法

arc() 函数的完整语法如下：

arc(x, y, w, h, start, stop, [mode], [detail])

核心参数解释：

• x, y：圆弧所在椭圆的中心点坐标


• w, h：椭圆的宽度和高度，如果两者相等，则绘制的是圆形的一部分


• start, stop：圆弧的起始角度和结束角度，默认以弧度（radians）为单位

可选参数：

• mode：定义圆弧的填充样式，可选值为OPEN（开放式半圆）、CHORD（封闭式半圆）或PIE（闭合饼图）


• detail：仅在 WebGL 模式下使用，指定组成圆弧周长的顶点数量，默认值为 25

角度单位与转换

在 p5.js 中，角度可以使用弧度或角度两种单位表示：

• 默认单位是弧度：0 弧度指向正右方（3 点钟方向），正角度按顺时针方向增加


• 使用角度单位：可以通过 angleMode(DEGREES) 函数将角度单位设置为角度

两种单位之间的转换关系：

• 360 度 = 2π 弧度


• 180 度 = π 弧度


• 90 度 = π/2 弧度

p5.js 提供了两个辅助函数用于单位转换：

• radians(degrees)：将角度转换为弧度


• degrees(radians)：将弧度转换为角度

举个例子（基础示例）

举个例子讲解一下如何使用 arc() 函数绘制不同角度的圆弧。

function setup() {

  createCanvas(400, 400);

  angleMode(DEGREES); // 使用角度单位

}



function draw() {

  background(220);

  

  // 绘制不同角度的圆弧

  arc(100, 100, 100, 100, 0, 90); // 90度圆弧

  arc(250, 100, 100, 100, 0, 180); // 180度圆弧

  arc(100, 250, 100, 100, 0, 270); // 270度圆弧

  arc(250, 250, 100, 100, 0, 360); // 360度圆弧（整圆）

}

这段代码会在画布上绘制四个不同角度的圆弧，从 90 度到 360 度不等。注意，当角度为 360 度时，实际上绘制的是一个完整的圆形。

三种圆弧模式：OPEN、CHORD 与 PIE

arc() 函数的第七个参数mode决定了圆弧的填充方式，有三种可选值：

• OPEN（默认值）：仅绘制圆弧本身，不填充任何区域


• CHORD：绘制圆弧并连接两端点形成闭合的半圆形区域


• PIE：绘制圆弧并连接两端点与中心点形成闭合的扇形区域

这三种模式不需要手动定义，p5.js 已经在全局范围内定义好了这些常量。

举个例子：

function setup() {

  createCanvas(400, 200);

  angleMode(DEGREES);

}



function draw() {

  background(220);

  

  // 绘制不同模式的圆弧

  arc(100, 100, 100, 100, 0, 270, OPEN);

  arc(220, 100, 100, 100, 0, 270, CHORD);

  arc(340, 100, 100, 100, 0, 270, PIE);

}

这段代码会在画布上绘制三个 270 度的圆弧，分别展示 OPEN、CHORD 和 PIE 三种模式的效果。可以明显看到，OPEN 模式只绘制弧线，CHORD 模式连接两端点形成闭合区域，而 PIE 模式则从两端点连接到中心点形成扇形。

如何选择合适的模式

选择圆弧模式时，应考虑以下因素：

• 视觉效果需求：需要纯弧线效果时选择 OPEN，需要闭合区域时选择 CHORD 或 PIE


• 应用场景：饼图通常使用 PIE 模式，仪表盘可能使用 CHORD 模式，而简单装饰线条可能使用 OPEN 模式


• 填充与描边需求：不同模式对填充和描边的处理方式不同，需要根据设计需求选择

值得注意的是，arc() 函数绘制的默认是填充的扇形区域。如果想要获取纯圆弧（没有填充区域），可以使用 noFill() 函数拒绝 arc() 函数的填充。

做几个小demo玩玩

简易数字时钟

在这个示例中，我将使用 arc() 函数创建一个简单的数字时钟，显示当前的小时、分钟和秒数。

let hours, minutes, seconds;



function setup() {

  createCanvas(400, 400);

  angleMode(DEGREES); // 使用角度单位

}



function draw() {

  background(220);

  

  // 获取当前时间

  let now = new Date();

  hours = now.getHours();

  minutes = now.getMinutes();

  seconds = now.getSeconds();



  // 绘制时钟边框

  stroke(0);

  strokeWeight(2);

  noFill();

  arc(width/2, height/2, 300, 300, 0, 360);



  // 绘制小时刻度

  strokeWeight(2);

  for (let i = 0; i < 12; i++) {

    let angle = 90 - i * 30;

    let x1 = width/2 + 140 * cos(radians(angle));

    let y1 = height/2 + 140 * sin(radians(angle));

    let x2 = width/2 + 160 * cos(radians(angle));

    let y2 = height/2 + 160 * sin(radians(angle));

    line(x1, y1, x2, y2);

  }



  // 绘制分钟刻度

  strokeWeight(1);

  for (let i = 0; i < 60; i++) {

    let angle = 90 - i * 6;

    let x1 = width/2 + 150 * cos(radians(angle));

    let y1 = height/2 + 150 * sin(radians(angle));

    let x2 = width/2 + 160 * cos(radians(angle));

    let y2 = height/2 + 160 * sin(radians(angle));

    line(x1, y1, x2, y2);

  }



  // 绘制小时指针

  let hourAngle = 90 - (hours % 12) * 30 - minutes * 0.5;

  let hourLength = 80;

  let hx = width/2 + hourLength * cos(radians(hourAngle));

  let hy = height/2 + hourLength * sin(radians(hourAngle));

  line(width/2, height/2, hx, hy);



  // 绘制分钟指针

  let minuteAngle = 90 - minutes * 6;

  let minuteLength = 120;

  let mx = width/2 + minuteLength * cos(radians(minuteAngle));

  let my = height/2 + minuteLength * sin(radians(minuteAngle));

  line(width/2, height/2, mx, my);



  // 绘制秒针

  stroke(255, 0, 0);

  let secondAngle = 90 - seconds * 6;

  let secondLength = 140;

  let sx = width/2 + secondLength * cos(radians(secondAngle));

  let sy = height/2 + secondLength * sin(radians(secondAngle));

  line(width/2, height/2, sx, sy);

  

  // 显示当前时间文本

  noStroke();

  fill(0);

  textSize(24);

  text(hours + ":" + nf(minutes, 2, 0) + ":" + nf(seconds, 2, 0), 50, 50);

}

关键点解析：

饼图

在这个示例中，我将创建一个简单的饼图，展示不同类别数据的比例。

let data = [30, 10, 45, 35, 60, 38, 75, 67]; // 示例数据

let total = 0;

let lastAngle = 0;



function setup() {

  createCanvas(720, 400);

  angleMode(DEGREES); // 使用角度单位

  noStroke(); // 不绘制边框

  total = data.reduce((a, b) => a + b, 0); // 计算数据总和

}



function draw() {

  background(100);

  pieChart(300, data); // 调用饼图绘制函数

}



function pieChart(diameter, data) {

  lastAngle = 0; // 重置起始角度

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

    // 设置圆弧的灰度值，map函数将数据映射到0-255的灰度范围

    let gray = map(i, 0, data.length, 0, 255);

    fill(gray);

    

    // 计算当前数据点的角度范围

    let startAngle = lastAngle;

    let endAngle = lastAngle + (data[i] / total) * 360;

    

    // 绘制圆弧

    arc(

      width / 2,

      height / 2,

      diameter,

      diameter,

      startAngle,

      endAngle,

      PIE // 使用PIE模式创建扇形

    );

    

    lastAngle = endAngle; // 更新起始角度为下一个数据点做准备

  }

}

关键点解析：

这个饼图示例可以通过添加标签、交互效果或动态数据更新来进一步增强功能。

描边效果

在 p5.js 中，我们可以通过以下函数定制圆弧的描边效果：

• stroke(color)：设置描边颜色


• strokeWeight(weight)：设置描边宽度


• strokeCap(cap)：设置描边端点样式（可选值：BUTT, ROUND, SQUARE）


• strokeJoin(join)：设置描边转角样式（可选值：MITER, ROUND, BEVEL）

以下示例展示了如何定制圆弧的描边效果：

function setup() {

  createCanvas(400, 200);

  angleMode(DEGREES);

}



function draw() {

  background(220);

  

  // 示例1：粗红色描边

  stroke(255, 0, 0);

  strokeWeight(10);

  arc(100, 100, 100, 100, 0, 270);

  

  // 示例2：带圆角端点的描边

  stroke(0, 255, 0);

  strokeWeight(10);

  strokeCap(ROUND);

  arc(220, 100, 100, 100, 0, 270);

  

  // 示例3：带阴影效果的描边

  stroke(0, 0, 255);

  strokeWeight(15);

  strokeCap(SQUARE);

  arc(340, 100, 100, 100, 0, 270);

  

  // 恢复默认设置

  noStroke();

}

关键点解析：

填充效果

在 p5.js 中，我们可以通过以下函数定制圆弧的填充效果：

• fill(color)：设置填充颜色


• noFill()：禁用填充效果


• colorMode(mode)：设置颜色模式（RGB、HSB 等）


• alpha()：设置颜色透明度

以下示例展示了如何定制圆弧的填充效果：

function setup() {

  createCanvas(400, 200);

  angleMode(DEGREES);

  colorMode(HSB, 360, 100, 100); // 使用HSB颜色模式

}



function draw() {

  background(220);

  

  // 示例1：单色填充

  fill(120, 100, 100); // 绿色

  arc(100, 100, 100, 100, 0, 270);

  

  // 示例2：渐变填充

  noFill();

  stroke(0, 0, 100);

  strokeWeight(10);

  for (let i = 0; i < 360; i += 10) {

    fill(i, 100, 100);

    arc(220, 100, 100, 100, i, i+10);

  }

  

  // 示例3：透明填充

  fill(240, 100, 100, 50); // 半透明蓝色

  arc(340, 100, 100, 100, 0, 270);

  

  // 恢复默认设置

  noFill();

  stroke();

}

关键点解析：

旋转圆弧

在 p5.js 中创建圆弧动画非常简单，主要通过以下方法实现：

• **draw()**函数：每秒自动执行约 60 次，用于更新动画帧


• 变量控制：使用变量控制圆弧的参数（如位置、大小、角度等）


• frameRate(fps)：设置动画帧率（可选）


• millis()：获取当前时间（毫秒），用于精确控制动画时间

圆弧动画效果示例：

let angle = 0;



function setup() {

  createCanvas(400, 400);

  angleMode(DEGREES);

}



function draw() {

  background(220);

  

  // 绘制旋转的红色圆弧

  stroke(255, 0, 0);

  strokeWeight(10);

  arc(width/2, height/2, 300, 300, angle, angle + 90);

  

  // 更新角度值，实现旋转效果

  angle += 2; // 调整这个值可以改变旋转速度

  

  // 恢复默认设置

  noStroke();

}

关键点解析：

弧度与角度的转换技巧

在 p5.js 中，arc()函数默认使用弧度作为角度单位，但我们通常更习惯使用角度。以下是一些转换技巧：

• 角度转弧度：使用 radians(degrees) 函数将角度转换为弧度


• 弧度转角度：使用 degrees(radians) 函数将弧度转换为角度


• 设置角度单位：使用 angleMode(DEGREES) 函数将全局角度单位设置为角度，这样 arc() 函数就可以直接使用角度值


• 常见角度值：记住一些常用角度的弧度值，如 90 度 = PI/2，180 度 = PI，270 度 = 3PI/2，360 度 = 2PI

圆弧绘制的常见问题与解决方案

在使用 arc() 函数时，可能会遇到以下问题：

以上就是本文的全部内容啦，如果想了解更多 p5.js 的玩法可以关注 《P5.js中文教程》

点赞 + 关注 + 收藏 = 学会了

docker 项目的部署，具有一次构建，多地部署的通用性。所以，你可以在本地 docker 环境部署、nas环境部署、云服务器环境部署。

3.1 部署环境 - 脚本

通过以下脚本，安装mysql、redis等。

3.2 项目部署 - 脚本

镜像，liwenchao_test/riderwuyou-admin:1.0 如果使用阿里云Docker仓库，那么可以使用 image: crpi-ioutcr0ojmsa4ham.cn-beijing.personal.cr.aliyuncs.com/liwenchao_test/riderwuyou-admin:1.0-SNAPSHOT 或者用 docker tag crpi-ioutcr0ojmsa4ham.cn-beijing.personal.cr.aliyuncs.com/liwenchao_test/riderwuyou-admin:1.0-SNAPSHOT liwenchao_test/riderwuyou-admin:1.0 设定镜像名称。

4. 服务部署

4.1 上传脚本

4.2 执行脚本

• 执行脚本01；docker-compose -f docker-compose-environment-aliyun.yml up -d
• 执行脚本02；docker-compose -f docker-compose-app-v1.0.yml up -d
• 运行完成后，就可以运行测试了

这是昨天发生在开源圈子里的一件事情，在不少开发者论坛和社区里也炸开了锅，相信不少同学也刷到了。

具体怎么回事呢？

原来是知名开源项目 Alist 被爆疑似悄悄出售，原开发者退出了项目。

注意，这里有一个词，是“悄悄”。

原来就在之前的某一天，有细心的网友突然发现，该项目的中文文档开始出现不寻常的修改，比如添加了商业化信息，新增了QQ群和VIP技术支持的内容。

再后来，有网友发现其项目官网域名完成了切换，并且这一变更也没有任何官方声明，从而引发了社区的警觉和质疑。

而事件再进一步升级的导火索则是有社区开发者在项目 PR 中发现了可疑的代码提交。

一位用户提交了包含用户数据收集功能的代码，该代码片段旨在收集用户操作系统信息并上报，尽管该 PR 最终被拒绝合入，但社区不少开发者担心这仅仅是冰山一角。

当社区质疑声浪日渐高涨，就在昨天，Alist 项目原开发者 Xhofe 在订阅频道发布公告，称：

“项目已交由公司运营，之后我会帮忙审查开源版本仓库的代码，以及确保 release 的分发由 ci 自动构建，main 分支已开启分支保护，后续所有的提交都会经过 pr 审核。”

至此，社区正式炸锅了...

众所周知，AList 是一个基于 Go 语言编写的开源文件列表与 WebDAV 程序，可能有不少同学都用过。

AList 提供了一个统一的云存储管理解决方案，支持多平台文件挂载、预览以及操作。

在此次风波爆发之前，AList 在开发者圈是不少同学的必备工具。

不仅如此，甚至还有不少相关的软件或服务是基于 AList 来做的。

这款开源项目支持几十款主流网盘的一站式管理，提供统一的网页界面，能实现跨平台文件管理、在线视频播放等功能。

从该项目的 GitHub 主页上也可以看到，目前 Alist 收获了近 50000 颗的 star 星标，这也足以说明了其在开发者圈子中的受欢迎程度。

按照作者的回应，既然 Alist 项目是被公司所接手了，那它的买家到底是哪家公司呢？

有细心的网友发现，从其官网的定价页面尝试联系下去发现，该公司正是贵州bg科技。

没错，这个公司正是之前收购 Java工具库 Hutool（A set of tools that keep Java sweet）的那个公司。

至于其在开发者圈子里的一些评论，这里就不作过多评述了。

目前，AList 项目的 Issues 区基本是沦陷了，不少开发者们都在这里输出了自己的意见与不满。

聊到开源项目被收购的事情，其实早就不是第一次发生了。

正如网友们所讨论的，商业化其实无可厚非，开发者的心血也需要回报，不同的开源项目作者可以有不同的选择。

但是如果在开源的商业化过程中存在一些让用户不明就里的暗手操盘，那事情往往就会开始变得微妙起来，毕竟开源项目的背后就是广大的用户和社区，大家时刻都在注视和监督着。

文章的最后，这里还想再聊一聊有关开源作者的生存现状。

我不知道本文被收购项目 AList 的作者是不是在全职独立做开源项目，但是在我自己的圈子里，我私下就认识好几个独立维护开源项目的朋友。

有一说一，个人开源作者其实挺不容易的，像上面这样的开源项目被公司收购的毕竟是少数个例，其实好多个人的开源项目到后期由于各种主客观原因，渐渐都停止更新和维护了。

大家都知道，伴随着这两年互联网行业的寒意，软件产业里的不少环节也受到了波动，行业不景气，连开源项目的主动维护也变得越来越少了。

毕竟连企业也要降本增效，而开源往往并不能带来快速直接的实际效益，付出了如果没有回报，便会很难坚持下去。

而如果从一名学习者的角度来看，参与开源项目的意义则是不言而喻的。

参与开源项目除了可以提升自身技术能力，收获项目开发经验之外，还可以让自己保持与开源社区其他优秀开发者之间的联系与沟通，并建立自己的技术影响力，另外参与优秀开源项目的经历也会成为自己求职简历上的一大亮点。

所以如果精力允许，利用业余时间来参与一些开源项目，这对技术开发者来说，也未尝不是一段难得的经历。

本文首发于公众号：托尼学长，立个写 1024 篇原创技术面试文章的flag，欢迎过来视察监督~

最近有好几个同学跟我说，他在技术面试过程中被问到这个问题了，让我找时间系统地讲解一下。

其实从某种意义上来说，这并不是一个严谨的面试题，接下来 show me the SQL，我们一起来看一下。

如下图所示，一张有 3000多万行记录的 user 表，执行全表 count 操作需要 14.8 秒的时间。

接下来我们稍作调整再试一次，神奇的一幕出现了，执行全表 count 操作竟然连 1 毫秒的时间都用不上。

这是为什么呢？

其实原因很简单，第一次执行全表 count 操作的时候，我用的是 MySQL InnoDB 存储引擎，而第二次则是用的 MySQL MyISAM 存储引擎。

这两者的差别在于，前者在执行 count(*)  操作的时候，需要将表中每行数据读取出来进行累加计数，而后者已经将表的总行数存储下来了，只需要直接返回即可。

当然，InnoDB 存储引擎对 count(*)  操作也进行了一些优化，如果该表创建了二级索引，其会通过全索引扫描的方式来代替全表扫描进行累加计数，

毕竟，二级索引值只存储了索引列和主键列两个字段，遍历计数肯定比存储所有字段的数据表的 IO 次数少很多，也就意味着其执行效率更高。

而且，MySQL 的优化器会选择最小的那个二级索引的索引文件进行遍历计数。

所以，这个技术面试题严谨的问法应该是 —— MySQL InnoDB 存储引擎单表过亿数据，如何优化 count(*) 全表的操作？

下面我们就来列举几个常见的技术解决方案，如下图所示：

（1）Redis 累加计数

这是一种最主流且简单直接的实现方式。

由于我们基本上不会对数据表执行 delete 操作，所以当有新的数据被写入表的时候，通过 Redis 的 incr 或 incrby 命令进行累加计数，并在用户查询汇总数据的时候直接返回结果即可。

如下图所示：

该实现方式在查询性能和数据准确性上两者兼得，Redis 需要同时负责累加计数和返回查询结果操作，缺点在于会引入缓存和数据库间的数据一致性的问题。

（2）MySQL 累加计数表 + 事务

这种实现方式跟“Redis 累加计数”大同小异，唯一的区别就是将计数的存储介质从 Redis 换成了 MySQL。

如下图所示：

但这么一换，就可以将写入表操作和累加计数操作放在一个数据库事务中，也就解决了缓存和数据库间的数据一致性的问题。

该实现方式在查询性能和数据准确性上两者兼得，但不如“Redis 累加计数”方式的性能高，在高并发场景下数据库会成为性能瓶颈。

（3）MySQL 累加计数表 + 触发器

这种实现方式跟“MySQL 累加计数表 + 事务”的表结构是一样的，如下图所示：

****

唯一的区别就是增加一个触发器，不用在工程代码中通过事务进行实现了。

CREATE TRIGGER `user_count_trigger` AFTER INSERT ON `user` FOR EACH ROW BEGIN    UPDATE user_count SET count = count + 1 WHERE id = NEW.id;END

该实现方式在查询性能和数据准确性上两者兼得，与“MySQL 累加计数表 + 事务”方式相比，最大的好处就是不用污染工程代码了。

（4）MySQL 增加并行线程

在 MySQL 8.014 版本中，总算增加了并行查询的新特性，其通过参数 innodb_parallel_read_threads 进行设定，默认值为 4。

下面我们做个实验，将这个参数值调得大一些：

set local innodb_parallel_read_threads = 16;

然后，我们再来执行一次上文中那个 3000 多万行记录 user 表的全表 count 操作，结果如下所示：

参数调整后，执行全表 count 操作的时间由之前的 14.8 秒，降低至现在的 6.1 秒，是可以看到效果的。

接下来，我们继续将参数值调整得大一些，看看是否还有优化空间：

set local innodb_parallel_read_threads = 32;

然后，我们再来执行一次上文中那个 3000 多万行记录 user 表的全表 count 操作，结果如下所示：

参数调整后，执行全表 count 操作的时间竟然变长了，从原来的 6.1 秒变成了 6.8 秒，看样子优化空间已经达到上限了，再多增加执行线程数量只会适得其反。

该实现方式一样可以保证数据准确性，在查询性能上有所提升但相对有限，其最大优势是只需要调整一个数据库参数，在工程代码上不会有任何改动。

不过，如果数据库此时的负载和 IOPS 已经很高了，那开启并行线程或者将并行线程数量调大，会加速消耗数据库资源。

（5）MySQL 增加二级索引

还记得我们在上文中说的内容吗？

InnoDB 存储引擎对 count()  操作也进行了一些优化，如果该表创建了二级索引，其会通过全索引扫描的方式来代替全表扫描进行累加计数，*

毕竟，二级索引值只存储了索引列和主键列两个字段，遍历计数肯定比存储所有字段的数据表的IO次数少很多，也就意味着执行效率更高。

而且，MySQL 的优化器会选择最小的那个二级索引的索引文件进行遍历计数。

为了验证这个说法，我们给 user 表中最小的 sex 字段加一个二级索引，然后通过 EXPLAIN 命令看一下 SQL 语句的执行计划：

果然，这个 SQL 语句的执行计划会使用新建的 sex 索引，接下来我们执行一次看看时长：

果不其然，执行全表 count 操作走了 sex 二级索引后，SQL 执行时间由之前的 14.8 秒降低至现在的 10.6 秒，还是可以看到效果的。

btw：大家可能会觉得效果并不明显，这是因为我们用来测试的 user 表中算上主键 ID 只有七个字段，而且没有一个大字段。

反之，user 表中的字段数量越多，且包含的大字段越多，其优化效果就会越明显。

该实现方式一样可以保证数据准确性，在查询性能上有所提升但相对有限，其最大优势是只需要创建一个二级索引，在工程代码上不会有任何改动。

（6）SHOW TABLE STATUS

如下图所示，通过 SHOW TABLE STATUS 命令也可以查出来全表的行数：

我们常用于查看执行计划的 EXPLAIN 命令也能实现：

只不过，通过这两个命令得出来的表记录数是估算出来的，都不太准确。那到底有多不准确呢，我们来计算一下。

公式为：33554432 / 33216098 = 1.01

就这个 case 而言，误差率大概在百分之一左右。

该实现方式一样可以保证查询性能，无论表中有多大量级的数据都能毫秒级返回结果，且在工程代码方面不会有任何改动，但数据准确性上相差较多，只能用作大概估算。

前言

还在手动重复写 margin: 0; padding: 0;？还在为兼容性疯狂加 -webkit- 前缀？大厂前端早已不用原始 CSS 硬刚了！Stylus 作为一款现代化 CSS 预处理器，让你写样式像写 JavaScript 一样爽快。

Stylus：高效的CSS预处理器

基本特性

Stylus是一种CSS预处理器，提供了许多CSS不具备的高级功能：

// 定义变量

$background_color = rgba(255, 255, 255, 0.95)



.wrapper

  background $background_color

  box-shadow 0 0 0 10px rgba(0, 0, 0, 0.1)

优势与使用场景

1. 变量支持：避免重复值，便于主题切换
2. 嵌套规则：更清晰的DOM结构表示
3. 混合(Mixins) ：复用样式块
4. 函数与运算：动态计算样式值
5. 简洁语法：可选的花括号、分号和冒号

编译与使用

安装Stylus后，可以通过命令行编译.styl文件：

npm install -g stylus

stylus -w common.styl -o common.css

1. 第一个语句是用来安装stylus的直接运行就好
2. 第二个语句是你编译common.styl文件时使用的，也就是你写CSS代码时使用的，因为浏览器并不能直接编译.styl文件，所以你要先将.styl文件编译成.css文件，也就是用上面给的那个命令，注意要自己切换成自己的.styl文件名，后面的css名可以随便取一个自己想要的

插件的使用

我们要想使用stylus，除了要全局安装之外还要下载一下下面的这个插件。

我们要先进入插件市场，然后搜索stylus，点击我选择的那个插件点击安装即可

案例实战

先看效果，再上代码，最后在分析考点易错点

效果

下面是我们实现的一个简单的效果界面图

代码

$background_color = rgba(255, 255, 255, 0.95)



html 

    box-sizing border-box

    min-height 100vh

    display flex

    flex-direction column

    justify-content center

    align-items center

    text-align center

    background url('http://wes.io/hx9M/oh-la-la.jpg') center no-repeat

    background-size cover



* 

    box-sizing border-box



.wrapper

    padding 20px

    min-width 350px   

    background $background_color

    box-shadow 0 0 0 10px rgba(0, 0, 0, 0.1)

    h2 

        text-align center

        margin 0

        font-weight 200





body 

    color pink



.plates

    margin 0

    padding 0

    text-align left

    list-style: none

    li      

        border-bottom 1px solid rgba(0, 0, 0, 0.2)

        padding 10px 0px 

        display flex

    label 

        flex 1

        cursor pointer

    input

        display none





.add-items

    margin-top 20px

    input 

        padding 10px 

        outline 0

        border 1px solid rgba(0, 0, 0, 0.1)

        

我们可以看到.styl文件不用去写:和{}了，而且可以直接层叠样式

当我们运行stylus -w common.styl -o common.css命令时，它会实时的将common.styl文件编译成common.css，你可以根据自己的需求来编写，让我们看看它帮我写好的common.css文件吧

html {

  box-sizing: border-box;

  min-height: 100vh;

  display: flex;

  flex-direction: column;

  justify-content: center;

  align-items: center;

  text-align: center;

  background: url("http://wes.io/hx9M/oh-la-la.jpg") center no-repeat;

  background-size: cover;

}

* {

  box-sizing: border-box;

}

.wrapper {

  padding: 20px;

  min-width: 350px;

  background: rgba(255,255,255,0.95);

  box-shadow: 0 0 0 10px rgba(0,0,0,0.1);

}

.wrapper h2 {

  text-align: center;

  margin: 0;

  font-weight: 200;

}

body {

  color: #ffc0cb;

}

.plates {

  margin: 0;

  padding: 0;

  text-align: left;

  list-style: none;

}

.plates li {

  border-bottom: 1px solid rgba(0,0,0,0.2);

  padding: 10px 0px;

  display: flex;

}

.plates label {

  flex: 1;

  cursor: pointer;

}

.plates input {

  display: none;

}

.add-items {

  margin-top: 20px;

}

.add-items input {

  padding: 10px;

  outline: 0;

  border: 1px solid rgba(0,0,0,0.1);

}

// 获取DOM元素

// 获取添加项目的表单元素

const addItems = document.querySelector('.add-items');

// 获取显示项目列表的元素

const itemsList = document.querySelector('.plates');

// 从本地存储获取项目数据，如果没有则初始化为空数组

let items = JSON.parse(localStorage.getItem('tapasItems')) || [];



// 添加新项目函数

function addItem(e) {

  // 阻止表单默认提交行为

  e.preventDefault();

  // 获取输入框中的文本值

  const text = this.querySelector('[name=item]').value;

  // 创建新项目对象

  const item = {

    text,        // 项目文本

    done: false  // 完成状态初始为false

  };

  // 将新项目添加到数组中

  items.push(item);

  // 更新列表显示

  populateList(items, itemsList);

  // 将更新后的数组保存到本地存储

  localStorage.setItem('tapasItems', JSON.stringify(items));

  // 重置表单

  this.reset();

}



// 渲染项目列表函数

function populateList(plates = [], platesList) {

  // 使用map方法将数组转换为HTML字符串

  platesList.innerHTML = plates.map((plate, i) => {

    return `

      


        

        ${i} id="item${i}" ${plate.done ? 'checked' : ''}>

        

        ${i}">${plate.text}

      


    `;

  }).join(''); // 将数组转换为字符串

}



// 切换项目完成状态函数

function toggleDone(e) {

  // 如果点击的不是input元素则直接返回

  if (!e.target.matches('input')) return;

  // 获取被点击元素的data-index属性值

  const el = e.target;

  const index = el.dataset.index;

  // 切换项目的完成状态

  items[index].done = !items[index].done;

  // 更新本地存储

  localStorage.setItem('tapasItems', JSON.stringify(items));

  // 重新渲染列表

  populateList(items, itemsList);

}



// 添加事件监听器

// 表单提交事件 - 添加新项目

addItems.addEventListener('submit', addItem);

// 列表点击事件 - 切换项目完成状态

itemsList.addEventListener('click', toggleDone);



// 初始化加载 - 页面加载时渲染已有项目

populateList(items, itemsList);

html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no, viewport-fit=cover">

    <title>Documenttitle>

    <link rel="stylesheet" href="./common.css">

head>

<body>

    <div class="wrapper">

        <h2>Local TAPASh2>

        <p>请添加您的TAPASp>

        <ul class="plates">

            <li>Loading Tapas ...li>

        ul>

        <form action="" class="add-items">

            <input 

                type="text"

                placeholder="Item Name"

                required  -- 让输入框变成必须填写 -->

                name="item"

            >

            <input type="submit" value="+ Add Item">

        form>

    div>



    <script src="./common.js">



    script>

body>

html>

分析考点易错点

1. Stylus 变量 $background_color

考点：

• Stylus 中变量的定义和使用
• RGBA 颜色值的表示方法

答案：

• $background_color = rgba(255, 255, 255, 0.95) 定义了一个半透明白色背景变量
• 在 Stylus 中，变量名可以包含 $ 符号，但不是必须的
• 可以直接在样式中引用变量，如 background $background_color

易错点：

• 忘记变量名前加 $（虽然 Stylus 允许不加，但加了更清晰）
• RGBA 值写错格式，如漏掉 alpha 通道或使用错误范围值
• 变量作用域问题（Stylus 变量有作用域概念）

2. 背景图片设置

考点：

• CSS 背景属性的简写方式
• background-size: cover 的作用
• 多背景属性的正确顺序

答案：

background url('http://wes.io/hx9M/oh-la-la.jpg') center no-repeat

background-size cover

等价于 CSS：

background-image: url('http://wes.io/hx9M/oh-la-la.jpg');

background-position: center;

background-repeat: no-repeat;

background-size: cover;

易错点：

• 混淆 cover 和 contain 的区别：
  • cover：完全覆盖容器，可能裁剪图片
  • contain：完整显示图片，可能留白
• 背景图片 URL 未加引号导致错误
• 多个背景属性顺序错误（简写时有特定顺序要求）
• 忘记设置 no-repeat 导致图片平铺

3. localStorage 使用

考点：

• localStorage 的 API 使用
• JSON 序列化与反序列化
• 数据持久化策略

答案：

// 存储数据

localStorage.setItem('tapasItems', JSON.stringify(items));



// 读取数据

let items = JSON.parse(localStorage.getItem('tapasItems')) || [];

易错点：

• 忘记使用 JSON.stringify 直接存储对象，导致存储为 [object Object]
• 读取时忘记使用 JSON.parse，导致得到的是字符串而非对象
• 未处理 getItem 返回 null 的情况（代码中使用 || [] 做了默认值处理）
• 存储大量数据超出 localStorage 容量限制（通常 5MB）
• 不考虑隐私模式下 localStorage 可能不可用的情况

4. Viewport Meta 标签

考点：

• 响应式设计基础
• 移动端视口控制
• 各属性的含义

答案：

<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no, viewport-fit=cover">

各属性含义：

• width=device-width：视口宽度等于设备宽度
• initial-scale=1：初始缩放比例为1
• user-scalable=no：禁止用户缩放
• viewport-fit=cover：覆盖整个屏幕（针对刘海屏设备）

易错点：

• 拼写错误如 user-scalable 写成 user-scalabe
• 错误理解 initial-scale 的作用
• 在需要用户缩放功能的场景错误地设置 user-scalable=no
• 忽略 viewport-fit=cover 导致刘海屏设备显示问题
• 多个属性间缺少逗号分隔（viewport 内容是用逗号分隔的）

小知识

最后再讲一个我也是刚刚才了解到的小知识，毕竟我还是小白嘛🚀🚀

1. 首先打开自己的手机开启热点，然后用自己的电脑连接手机上的热点
2. 在电脑上按住Win+R键，输入cmd，进入终端

 3. 在终端中输入ipconfig的命令，找到一个名为IPv4的地址，复制一下

4. 然后运行html文件，要用Open with Live Serve运行项目

5. 将你之前复制的IPv4的地址更改到下面的位置，也就是在我图片的127.0.0.1的位置上填写上你自己之前复制的地址

6. 之后可以先运行一下，运行成功的话，将这整个链接复制发给你的手机，然后你手机点击这个链接就可以登录上这个网页了。
7. 如果出现了一些BUG，有可能是防火墙的问题，或者你没有IPv4的地址，那就在终端的那个页面复制一个你显示了的地址就可以了，如果是其它问题自行上网搜索吧，小白的我也解决不了🚀🚀

作者：绅士玖
来源：juejin.cn/post/7516797727066406966

前两天在某鱼闲逛，本来想找个二手机械键盘，结果刷着刷着突然看到有人在卖——Word 批量转 PDF 小工具，还挺火，价格也不高，但销量出奇地高，评论里一堆人在夸“好用”、“终于不用一篇篇点了”啥的。

说实话，当时我人都愣住了——

这个功能我用 Python 十分钟能写完啊！

然后我又搜了其它小工具，pdf转Word，Word转图片，Word加水印什么的……好多

好家伙，花姐以前教大家做的办公自动化小工具原来都能卖钱呀！

那咱今天先复刻一个Word 批量转 PDF 小工具，顺便升级点功能，做个更丝滑的版本。

保准你看完就能自己写个卖钱去。

💡思路先摆明：Word 转 PDF，其实没那么复杂

你别看这功能听起来挺“高端”的，其实本质上干的事就是——

把一堆 Word 文档用程序打开，然后保存为 PDF 格式。

换句话说，这活本质就是个“批处理”。用 Python 来干，简直再合适不过。

我们需要的工具是 python-docx？NoNoNo——这个库不支持保存为 PDF。真正的主角其实是：

• win32com.client：用来操作 Word 应用（需要 Windows 系统+装了 Office）


• 或者跨平台一点的玩法，用 LibreOffice + subprocess，不过今天我们先来讲讲最稳最简单的方式：用 Word 本尊来干活。

🔧上代码：几行就能跑起来的 Word 转 PDF 脚本

好，开门见山，先上最基础的版本：

import os

import win32com.client



def word_to_pdf(input_path, output_path):

    word = win32com.client.Dispatch("Word.Application")

    word.Visible = False  # 不弹窗，后台运行

    doc = word.Documents.Open(input_path)

    doc.SaveAs(output_path, FileFormat=17)  # 17 是 PDF 格式

    doc.Close()

    word.Quit()



# 示例用法

word_to_pdf("C:/Users/你的用户名/Desktop/测试文档.docx", 

            "C:/Users/你的用户名/Desktop/测试文档.pdf")

✍️几句解释：

• Dispatch("Word.Application") 就是打开 Word 应用；


• FileFormat=17 是告诉它“嘿，我要存成 PDF”；


• 结尾的 Quit() 很重要，不然 Word 可能会在后台一直挂着，占资源。


• 如果你电脑里安装的是WPS，Dispatch("Word.Application")这里改成Dispatch("kwps.Application")，不然会报错

是不是很简单？连我猫都看懂了。

📂扩展：支持批量转换，一次性把一整个文件夹干掉！

很多人痛苦的点是“文档太多，一个个转太麻烦”。

那好说，我们搞个批量版本，让它一口气全转了：

def batch_convert(folder_path):

    word = win32com.client.Dispatch("Word.Application")

    word.Visible = False



    for file in os.listdir(folder_path):

        if file.endswith(".doc") or file.endswith(".docx"):

            doc_path = os.path.join(folder_path, file)

            pdf_path = os.path.splitext(doc_path)[0] + ".pdf"

            try:

                doc = word.Documents.Open(doc_path)

                doc.SaveAs(pdf_path, FileFormat=17)

                doc.Close()

                print(f"✅ 转换成功：{file}")

            except Exception as e:

                print(f"❌ 转换失败：{file}，原因：{e}")



    word.Quit()

使用方式：

batch_convert(r"C:\Users\你的用户名\Desktop\word文件夹")

🧐常见坑点，花姐来帮你避一避

写得简单不难，难的是兼容和细节。

✅1. 系统必须是 Windows，而且得装了 MS Office

这玩意底层其实就是用 COM 调用了 Word 的功能，所以没有装 Word 是用不了的。

✅2. 文档里有宏的、被保护的，可能转不了

有些文档打开会弹窗提示宏或者密码，那个得手动改设置，程序跑不过去。

✅3. 文件名不要太长、路径不要有中文/空格

有时候路径太奇怪，Word 会打不开，转不了，建议统一放到纯英文文件夹里。

🎁额外加点料

⏱️ 一、生成时间戳文件夹

def gen_output_folder():

    folder = os.path.dirname(os.path.abspath(__file__))

    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")

    output_folder = os.path.join(folder, f"pdf_{timestamp}")

    os.makedirs(output_folder, exist_ok=True)

    return output_folder

📁 二、自动获取当前脚本目录下的 Word 文件

这太简单了：

import os



def get_word_files_from_current_folder():

    folder = os.path.dirname(os.path.abspath(__file__))

    word_files = []

    for file in os.listdir(folder):

        if file.endswith(".doc") or file.endswith(".docx"):

            word_files.append(os.path.join(folder, file))

    return word_files

🔍 三、检测 Office 和 WPS 的方法

我们可以尝试用 win32com.client.gencache.EnsureDispatch() 去判断这两个程序是否存在。

import win32com.client



def detect_office_or_wps():

    try:

        word = win32com.client.gencache.EnsureDispatch("Word.Application")

        return "office"

    except:

        try:

            wps = win32com.client.gencache.EnsureDispatch("Kwps.Application")

            return "wps"

        except:

            return 

🔄 三、自动选择引擎并批量转换

import os

import win32com.client



def convert_word_to_pdf_auto(input_path, output_path, engine):

    if engine == "office":

        app = win32com.client.Dispatch("Word.Application")

    elif engine == "wps":

        app = win32com.client.Dispatch("Kwps.Application")

    else:

        print("❌ 没有检测到可用的 Office 或 WPS")

        return



    app.Visible = False



    try:

        doc = app.Documents.Open(input_path)

        doc.SaveAs(output_path, FileFormat=17)

        doc.Close()

        print(f"✅ 转换成功：{input_path}")

    except Exception as e:

        print(f"❌ 转换失败：{input_path}，原因：{e}")



    try:

        app.Quit()

    except:

        print("⚠️ 当前环境不支持 Quit，跳过退出。")

🚀 四、整合所有内容，一键搞定脚本所在目录下的所有 Word 文件

def batch_convert_here():

    engine = detect_office_or_wps()

    if not engine:

        print("😭 系统里没有安装 Office 或 WPS，没法转换")

        return



    folder = os.path.dirname(os.path.abspath(__file__))

    word_files = get_word_files_from_current_folder()



    if not word_files:

        print("🤷‍♀️ 当前文件夹没有发现 Word 文件")

        return



    output_folder = os.path.join(folder, "pdf输出")

    os.makedirs(output_folder, exist_ok=True)



    for word_file in word_files:

        filename = os.path.splitext(os.path.basename(word_file))[0]

        pdf_path = os.path.join(output_folder, f"{filename}.pdf")

        convert_word_to_pdf_auto(word_file, pdf_path, engine)



    print("🎉 所有文件转换完成啦！PDF 都在 'pdf输出' 文件夹里")

🧪 运行方式（放在脚本结尾）：

if __name__ == "__main__":

    batch_convert_here()

📦五、 做成 EXE 给小白用户用（pyinstaller）

最后一步，把咱的脚本打包成 .exe，丢到某鱼卖钱（手动狗头🐶）

命令就一句话：

pyinstaller -F word2pdf.py

生成的 dist/word2pdf.exe 就是可执行文件，随便拿给谁用都行（当然系统要有 Word）。

完整代码

import os

import win32com.client

import sys

import datetime



def get_real_path():

    """兼容开发与打包环境的路径获取"""

    if getattr(sys, 'frozen', False):

        base_dir = os.path.dirname(sys.executable)  # EXE文件所在目录[1,7](@ref)

    else:

        base_dir = os.path.dirname(os.path.abspath(__file__))

        

    return base_dir



# 生成时间戳文件夹

def gen_output_folder(folder):

    # folder = os.path.dirname(os.path.abspath(__file__))

    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")

    output_folder = os.path.join(folder, f"pdf_{timestamp}")

    os.makedirs(output_folder, exist_ok=True)

    return output_folder

    

# 自动获取当前脚本目录下的 Word 文件

def get_word_files_from_current_folder(folder):

    # folder = os.path.dirname(os.path.abspath(__file__))

    word_files = []

    for file in os.listdir(folder):

        if file.endswith(".doc") or file.endswith(".docx"):

            word_files.append(os.path.join(folder, file))

    return word_files



# 检测 Office 和 WPS 的方法

def detect_office_or_wps():

    try:

        word = win32com.client.gencache.EnsureDispatch("Word.Application")

        return "office"

    except:

        try:

            wps = win32com.client.gencache.EnsureDispatch("Kwps.Application")

            return "wps"

        except:

            return 



# 自动选择引擎并批量转换

def convert_word_to_pdf_auto(input_path, output_path, engine):

    if engine == "office":

        app = win32com.client.Dispatch("Word.Application")

    elif engine == "wps":

        app = win32com.client.Dispatch("Kwps.Application")

    else:

        print("没有检测到可用的 Office 或 WPS")

        return



    app.Visible = False



    try:

        doc = app.Documents.Open(input_path)

        doc.SaveAs(output_path, FileFormat=17)

        doc.Close()

        print(f"转换成功：{input_path}")

    except Exception as e:

        print(f"转换失败：{input_path}，原因：{e}")



    try:

        app.Quit()

    except:

        print("当前环境不支持 Quit，跳过退出。")



# 主函数  

def batch_convert_here():

    engine = detect_office_or_wps()

    if not engine:

        print("系统里没有安装 Office 或 WPS，没法转换")

        return



    folder = get_real_path()

    word_files = get_word_files_from_current_folder(folder)

    



    if not word_files:

        print("当前文件夹没有发现 Word 文件")

        return



    output_folder = gen_output_folder(folder)



    for word_file in word_files:

        filename = os.path.splitext(os.path.basename(word_file))[0]

        pdf_path = os.path.join(output_folder, f"{filename}.pdf")

        convert_word_to_pdf_auto(word_file, pdf_path, engine)



    print("所有文件转换完成啦！PDF 都在 'output_folder' 文件夹里")

    

if __name__ == "__main__":

    try:

        batch_convert_here()

        print("按 Enter 键退出...")

        input()  # 等待用户按 Enter 键

    except Exception as e:

        print(e)

        print("程序运行错误，按 Enter 键退出...")

        input()  # 等待用户按 Enter 键

你可能觉得：“这不就是几十行代码嘛，卖这个会有人买吗？”

我一开始也这么想。后来我想通了，某鱼上很多买家，根本不懂技术，他们在意的是：

✅ 能不能一键搞定？

✅ 会不会太复杂？

✅ 省不省事？

所以啊，写工具 + 提供说明 + 包装打包，这些就构成了“产品”。

我们程序员有时候太低估自己的能力了——其实你随手写的脚本，真的能解决很多人的问题。

小张是一名刚入职的前端开发工程师，某天，他的领导给他布置了一个看似简单的任务：

让用户能够通过文件链接下载多个文件

小张信心满满，觉得这不过是个小问题。然而，当他真正动手时，才发现这个需求并不简单。不同的下载方式各有优缺点，甚至有些方法会带来意想不到的问题，他决定一一尝试，探索最优解。

方案一：window.open——简单粗暴，但会打开新标签页

小张首先想到的是 window.open(url)，它可以让浏览器直接打开下载链接。

window.open('https://example.com/file.pdf');

优点：

• 代码简单，直接调用即可。


• 适用于单个文件的下载。

缺点：

• 每次下载都会打开一个新的浏览器标签页，影响用户体验。


• 部分浏览器可能会拦截 window.open，导致下载失败。

方案二：window.location.href 简单有效，但不能同时下载多个文件

小张发现，window.location.href 也可以实现下载，且不会打开新标签页。

window.location.href = 'https://example.com/file.pdf';

优点：

• 适用于单文件下载。


• 不会像 window.open 那样打开新页面。

缺点：

• 无法循环下载多个文件。如果连续多次赋值 window.location.href，后一个请求会覆盖前一个，导致只能下载最后一个文件。

方案三：iframe 支持多文件下载，但无法监听完成状态

为了让多个文件能够顺利下载，小张尝试用 iframe。

function downloadFile(url) {

  const iframe = document.createElement('iframe');

  iframe.style.display = 'none';

  iframe.src = url;

  document.body.appendChild(iframe);

  setTimeout(() => {

    document.body.removeChild(iframe);

  }, 5000); // 延迟移除 iframe，防止影响下载

}

优点：

• 适用于多文件下载。

缺点：

• iframe 无法监听文件下载是否完成。


• 需要在合适的时机移除 iframe，否则可能会影响页面性能。

方案四：fetch + blob——最优雅的下载方式

小张最终发现，fetch 可以获取文件数据，再通过 Blob 处理并使用 a 标签下载。

async function downloadFile(url, fileName) {

  const response = await fetch(url);

  if (!response.ok) throw new Error('Download failed');

  const blob = await response.blob();

  const blobUrl = URL.createObjectURL(blob);

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

  a.href = blobUrl;

  a.download = fileName;

  document.body.appendChild(a);

  a.click();

  document.body.removeChild(a);

  URL.revokeObjectURL(blobUrl);

}



function download(fileList){

   for(const file of fileList) {

     await downloadFile(file.url,file.name)

   }

}

优点：

• 不会打开新标签页。


• 可以同时下载多个文件。


• 适用于现代浏览器，兼容性较好。

缺点：

• 需要处理异步 fetch 请求。


• 服务器必须支持跨域资源共享（CORS），否则 fetch 请求会失败。


• 多次文件下载会导致多个浏览器下载图标：每次调用 a.click() 时，浏览器都会显示一个下载图标，影响用户体验。

方案五：jsZip 打包多个文件为 ZIP 下载——避免多次下载图标

为了进一步优化方案四，避免浏览器每次下载时显示多个下载图标，小张决定使用 jsZip 插件将多个文件打包成一个 ZIP 文件下载。

import JSZip from 'jszip';



async function downloadFilesAsZip(files) {

  const zip = new JSZip();

  // 循环遍历多个文件，获取每个文件的数据

  for (const file of files) {

    const response = await fetch(file.url);

    if (!response.ok) throw new Error(`Failed to fetch ${file.name}`);

    const blob = await response.blob();

    zip.file(file.name, blob); // 将文件添加到 ZIP 包中

  }



  // 生成 ZIP 文件并触发下载

  zip.generateAsync({ type: "blob" })

    .then(function(content) {

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

      const blobUrl = URL.createObjectURL(content);

      a.href = blobUrl;

      // 给压缩包设置下载文件名

      a.download = 'files.zip';

      document.body.appendChild(a);

      a.click();

      document.body.removeChild(a);

      // 释放 URL 对象

      URL.revokeObjectURL(blobUrl);

    });

}

优点：

• 提升用户体验：用户下载一个压缩包后，只需解压就可以获取所有文件，避免了多次点击和等待的麻烦。


• 适用于多文件下载：非常适合需要批量下载的场景。

缺点：

• 浏览器对大文件的支持：如果要下载的文件非常大，或者文件总大小很大，可能会导致内存消耗过高，甚至在浏览器中崩溃。


• 下载速度受限于压缩处理：打包文件为 ZIP 需要时间，尤其是文件较多时，会稍微影响压缩的速度，只适用于文件不是很大且数量不是很多的时候

结语：小张的最终选择

经过一番探索，小张最终选择了 jsZip 打包文件的方案，因为它不仅解决了多个文件下载时图标显示的问题，还提高了用户体验，让下载更加流畅，没有哪个方案比另外一个方案好，只有最适合的方案，根据实际的场景能满足需求最优解就是最好的。

引言

在当今组件化开发时代，知识库建设已成为提升开发效率的重要环节。然而传统爬虫方式在获取结构化组件文档时往往面临诸多挑战。为此，开发了 antd-doc-gen 工具，用来快速生成 antd 系列组件库的文档，将其作为大模型补充的知识库，生成的文档可以非常方便的导入到 像 ima，cursor，Obsidian 等支持知识库的工具。本文将解析其技术实现与设计理念。

npm 地址：http://www.npmjs.com/package/ant…

github 仓库：github.com/xuanxuan321…

一、核心功能概览

antd-doc-gen 作为专业的命令行工具，具备以下核心能力：

二、使用指南

快速安装

npm install -g antd-doc-gen

典型用例

生成 antd 文档

antd-doc-gen -d -r https://github.com/ant-design/ant-design

生成 antd-mobile 文档

antd-doc-gen -d -r https://github.com/ant-design/ant-design-mobile

生成 antd-mini 文档

antd-doc-gen -d -r https://github.com/ant-design/ant-design-mini

生成 antd-x 文档

antd-doc-gen -d -r https://github.com/ant-design/x

生成 antd-web3 文档

antd-doc-gen -d -r https://github.com/ant-design/ant-design-web3

三、技术实现解析

智能文档处理流程

工具通过五层处理流程实现文档自动化生成：

其他：

● 智能路径处理：支持跨平台路径分隔符自动转换，兼容绝对/相对路径

● 文档格式统一：保留原始结构，将示例代码以 Markdown 代码块嵌入

● 容错机制：提供分支/协议降级策略，支持无示例文档的直接复制

技术栈与扩展性

核心技术栈

● Node.js 生态：fs/path 模块实现文件操作，readline 处理用户交互

● 第三方库：commander（命令行）、simple-git（Git 操作）、ora（加载动画）

扩展能力

工具支持通过代码修改实现：

适用场景

需要 antd 系列组件库文档作为知识库的场景

局限性与优化方向

当前版本依赖特定文档结构（需包含 index.md 及 code 标签），未来计划：

● 增强非标准文档的兼容性

● 支持更多文档格式输出

● 集成文档预览功能

结语

antd-doc-gen 通过自动化文档处理流程，显著提升了组件库文档的维护效率。文档可以直接导入像 ima，cursor，Obsidian 等知识库工具，进一步提升大模型的能力

一. LangGraph简介

LangGraph 是基于 LangChain 的扩展框架，专为构建有状态（Stateful） 的大模型工作流而设计。它通过图结构（Graph）定义多个执行节点（Node）及其依赖关系，支持复杂任务编排，尤其适合多智能体协作、长对话管理等场景。

1.1 核心优势

• 状态持久化：自动维护任务执行过程中的上下文状态


• 灵活编排：支持条件分支、循环、并行等控制流


• 容错机制：内置错误重试、回滚策略


• 可视化调试：自动生成执行流程图

二. LangGraph最佳实践

2.1 基础代码结构

from langgraph.graph import StateGraph, END  

from typing import TypedDict, Annotated  

import operator  

# 定义状态结构  

class AgentState(TypedDict):  

    input: str  

    result: Annotated[list, operator.add]  # 自动累积结果  

# 初始化图  

graph = StateGraph(AgentState)  

# 添加节点与边（后续章节详解）  

...  

# 编译并运行  

app = graph.compile()  

result = app.invoke({"input": "任务描述"})

2.2 开发原则

模块化设计：每个节点只完成单一职责

状态最小化：仅保留必要数据，避免内存膨胀

幂等性保证：节点可安全重试

三. 状态设计（State Design）

3.1 状态定义规范

使用 Pydantic模型 或 TypedDict 明确状态结构：

from pydantic import BaseModel  

class ProjectState(BaseModel):  

    requirements: str  

    draft_versions: list[str]  

    current_step: int  

# 初始化状态  

initial_state = ProjectState(  

    requirements="开发一个聊天机器人",  

    draft_versions=[],  

    current_step=0  

)

3.2 状态自动管理

LangGraph通过注解（Annotation） 实现状态字段的自动更新：

from langgraph.graph import add_messages  

class DialogState(TypedDict):  

    history: Annotated[list, add_messages]  # 自动追加消息  

def user_node(state: DialogState):  

    return {"history": ["用户: 你好"]}  

def bot_node(state: DialogState):  

    return {"history": ["AI: 您好，有什么可以帮您？"]}

四. 节点函数（Node Functions）

4.1 节点定义标准

节点是工作流的基本单元，接收状态并返回更新：

from langchain_core.runnables import RunnableLambda  

# 简单节点  

def data_loader(state: dict):  

    return {"data": load_dataset(state["input"])}  

# 包含LLM调用的节点  

llm_node = RunnableLambda(  

    lambda state: {"answer": chat_model.invoke(state["question"])}  

)  

# 注册节点  

graph.add_node("loader", data_loader)  

graph.add_node("llm", llm_node)

4.2 多智能体协作

def designer_agent(state):  

    return {"design": "界面草图"}  

def developer_agent(state):  

    return {"code": "实现代码"}  

# 并行执行  

graph.add_node("designer", designer_agent)  

graph.add_node("developer", developer_agent)  

graph.add_edge("designer", "reviewer")  

graph.add_edge("developer", "reviewer")

五. 边的设计（Edge Design）

5.1 条件分支（Conditional Edges）

根据状态值动态路由：

from langgraph.graph import conditional_edge  

def should_continue(state):  

    return "continue" if state["step"] < 5 else "end"  

graph.add_conditional_edges(  

    source="decision_node",  

    path_map={"continue": "next_node", "end": END},  

    condition=should_continue  

)

5.2 循环结构

graph.add_edge("start", "process")  

graph.add_conditional_edges(  

    "process",  

    lambda s: "loop" if s["count"] < 3 else "end",  

    {"loop": "process", "end": END}  

)

六. 错误处理（Error Handling）

6.1 重试机制

from langgraph.retry import RetryPolicy  

policy = RetryPolicy(  

    max_retries=3,  

    backoff_factor=1.5,  

    retry_on=(Exception,)  

)  

graph.add_node(  

    "api_call",   

    api_wrapper.with_retry(policy)  

)

6.2 回滚策略

def compensation_action(state):  

    # 执行补偿操作  

    rollback_transaction(state["tx_id"])  

    return {"status": "rolled_back"}  

graph.add_edge("failed_node", "compensation")  

graph.add_edge("compensation", END)

注：本文代码基于LangGraph 0.1+版本实现，需预先安装依赖：

pip install langgraph langchain pydantic

更多AI大模型应用开发学习内容，尽在聚客AI学院。

在前端开发圈，JavaScript（简称JS）几乎无处不在。但你有没有发现，越来越多的大型项目和团队都在用 TypeScript（简称TS）？明明 JS 已经这么强大，为什么还要多此一举用 TS 呢？今天就用通俗易懂的语言，结合具体例子，带你彻底搞懂这个问题！🌟

1. JS的弱类型让大型项目“踩坑”不断

JavaScript 是一种弱类型语言，也就是说，变量的类型可以随时变化。虽然这让 JS 写起来很灵活，但在大型项目中却容易埋下隐患。

举个例子：

// JS 代码

function sum(a, b) {

  return a + b;

}



console.log(sum(1, 2));      // 输出 3

console.log(sum('1', 2));    // 输出 '12'，字符串拼接

console.log(sum(true, []));  // 输出 'true'，奇怪的结果

在 JS 里，sum 函数参数类型完全不受限制，传什么都行。小项目还好，项目一大，团队一多，类型混乱就会导致各种难以发现的bug，甚至上线后才暴雷，影响开发效率和用户体验。

2. TS的类型检查让错误“消灭在摇篮里”

TypeScript 是 JS 的超集，在 JS 的基础上增加了类型系统。这意味着你可以在写代码时就发现类型错误，而不是等到运行时才发现。

同样的例子，用 TS 改写：

// TS 代码

function sum(a: number, b: number): number {

  return a + b;

}



sum(1, 2);        // 正常

sum('1', 2);      // ❌ 报错：参数类型不匹配

TS 会在你写代码时就提示错误，防止类型不一致带来的 bug。这样，开发效率和代码质量都大大提升！

3. TS的类型推断让开发更智能

你可能担心，TS 要写很多类型声明，会不会很麻烦？其实不用担心，TS 有类型推断功能，能根据你的代码自动判断类型。

例子：

let age = 18; // TS 自动推断 age 是 number 类型

age = '二十'; // ❌ 报错：不能把 string 赋值给 number

你只需要在关键地方声明类型，其他地方 TS 会帮你自动推断，大大减少了重复劳动。

4. TS让团队协作更高效

在多人协作的大型项目中，TS 的类型系统就像一份“契约”，让每个人都能清楚知道每个函数、对象、变量的类型，极大减少沟通成本和踩坑概率。

例子：

// 定义一个工具函数

function formatUser(user: { name: string; age: number }) {

  return `${user.name} (${user.age})`;

}



// 调用时，TS 会自动检查参数类型

formatUser({ name: '小明', age: 20 }); // 正常

formatUser({ name: '小红', age: '二十' }); // ❌ 报错

有了类型约束，团队成员只要看类型定义就能明白怎么用，不用再靠口头说明或文档补充，协作效率大大提升。

5. TS支持现代开发工具，体验更丝滑

TS 的类型信息可以被编辑器和IDE（如 VSCode）利用，带来更智能的自动补全、跳转、重构、查找引用等功能，让开发体验飞升！

例子：

• 输入对象名时，编辑器会自动提示有哪些属性；


• 修改类型定义，相关代码会自动高亮出错，方便全局重构；


• 查找函数引用时，TS 能精确定位所有用到的地方。

这些功能在 JS 里是做不到的，TS 让开发更高效、更安全、更快乐！ 😄

TS的常见类型一览表

小贴士：

• any 虽然灵活，但会失去类型检查，不推荐使用；


• unknown 更安全，推荐用来接收不确定类型的数据。

TS的安装与使用

TypeScript 的安装和使用也非常简单：

npm install -g typescript

npm install -g ts-node

• typescript 用于编译 .ts 文件, 在当前目录生成一个同名的 .js 文件；


• ts-node 可以直接运行 TS 文件，开发更方便。

总结

有了 JS，为什么还要用 TS？

归根结底，TS 让代码更安全、开发更高效、协作更顺畅、体验更丝滑。尤其是在大型项目和团队协作中，TS 的优势会越来越明显。

5个理由再回顾：

如果你还没用过 TypeScript，不妨试试，相信你会爱上它！💙

我们做前端的，为了让网站在不同设备上都好看，天天都在和“响应式”打交道。其中最常见的一个场景，就是处理字体大小。

通常，我们是这么做的：

/* 手机上是16px */

h1 {

  font-size: 16px; 

}



/* 平板上大一点 */

@media (min-width: 768px) {

  h1 {

    font-size: 24px;

  }

}



/* 电脑上再大一点 */

@media (min-width: 1200px) {

  h1 {

    font-size: 32px;

  }

}

这套代码能用，但它有一个问题：字体大小的变化，是“跳跃式”的，像在走楼梯。 当你的屏幕宽度从767px变成768px时，字体会“Duang”地一下突然变大。这种体验，不够平滑。

今天，我想聊一个能让我们告别大部分这种繁琐媒体查询的CSS函数：clamp()。它能让我们的元素尺寸，像在走一个平滑的斜坡一样，实现真正的 “流体式”缩放。

clamp() 到底是个啥？

clamp() 的中文意思是“夹子”或“钳子”，非常形象。它的作用就是把一个值的范围，“夹”在一个最大值和一个最小值之间。

它的语法极其简单：

width: clamp(最小值, 理想值, 最大值);

你可以把它理解成，你在设定一个规则：

它的工作逻辑是：

• 如果“理想值”小于“最小值”，那就取“最小值”。


• 如果“理想值”大于“最大值”，那就取“最大值”。


• 如果“理想值”在两者之间，那就取“理想值”。

使用场景：流体字号（Fluid Typography）

这是clamp()最经典，也是最强大的用途。我们来改造一下文章开头的那个例子。

以前（媒体查询版）：

h1 { font-size: 16px; }

@media (min-width: 768px) { h1 { font-size: 24px; } }

@media (min-width: 1200px) { h1 { font-size: 32px; } }

现在（clamp()版）：

h1 {

  /* 最小值是16px，

    理想值是视口宽度的4%，

    最大值是32px。

  */

  font-size: clamp(16px, 4vw, 32px);

}

看，一行代码，代替了原来的一堆媒体查询。

现在你拖动浏览器窗口，会发现标题的大小是在平滑地、线性地变化，而不是“阶梯式”地跳变。它在小屏幕上不会小于16px，在大屏幕上不会大于32px，而在中间的尺寸，它会根据4vw这个值自动调整。