这样就写好一个游戏了.

游戏逻辑开发是和 html5 游戏一样的, 最后一小节我再赘述下吧.

游戏逻辑编写

游戏逻辑在 ts 的脚本文件中编写.

所有新建的 ts 文件都会有一个初始模板. 内容是export class XXX extends cc.Component {}.

这个类有2个生命周期方法. start()和update().

update()方法的参数deltatime是离上一帧的时间, 不了解的去看下 h5 游戏的执行就好了.

游戏逻辑一定涉及到元素, 只要在脚本文件里声明一个属性, 就能在节点属性面板上看到一个属性.

把这个属性需要控制的元素拖过去就行.

然后元素节点也可以绑定脚本. 这个脚本可以通过this.node提供的 api 来操作元素的位置.

元素节点一般会绑定动画, 也需要把动画声明在属性里, 然后从资源列表把动画拖动到自己的节点属性面板上, 就可以在脚本里调用动画了.

我现在理解的层级是这样的:

• 总脚本gameControl写在单独节点里. 写游戏逻辑与结算判断.
• 会动的元素, 自己绑定节点, 写一些方法供总脚本调用.
• 编辑一些动画, 供上一步"会动的元素"调用. 一般是和元素位置的移动同时调用的.

贴一些代码

这里分享个具体的demo代码. demo内容很简单, 按方向键角色就会在地图上走路.

走路的时候会播放一个帧动画, 是从微信表情里导出的20个png.

脚本文件只有2个. 一个是gameControl游戏控制, 只做了监听键盘事件, 并调用player脚本的对应方法.

另一个player脚本写了对应的方法, 改变一些参数, 在update()方法根据参数来设置角色的位置.

gameControl.ts

import { _decorator, Component, Node, input, Input, EventKeyboard } from 'cc'

const { ccclass, property } = _decorator



import { player } from './player'



@ccclass('gameControl')

export class gameControl extends Component {

    @property(player)

    public player: player = null



    start() {

        input.on(Input.EventType.KEY_DOWN, (event) => {

            switch (event.keyCode) {

                case 37:

                    this.player.left()

                    break

                case 38:

                    this.player.up()

                    break

                case 39:

                    this.player.right()

                    break

                case 40:

                    this.player.down()

                    break



            }

        })

    }



    update(deltaTime: number) {



    }

}

player.ts

import { _decorator, Component, Node, Animation, tween, Vec3, math } from 'cc'

const { ccclass, property } = _decorator



@ccclass('player')

export class player extends Component {



    @property(Animation)

    anim: Animation = null



    @property(Node)

    lulu: Node = null



    private direction = new Vec3(1, 0, 0)

    private isMoving = false

    private movePeriod = 0



    start() {



    }



    update(deltaTime: number) {

        if (this.isMoving) {

            if (this.movePeriod < 1) {

                let target = this.node.position

                Vec3.add(target, this.node.position, this.direction)

                this.node.setPosition(target)

                this.movePeriod += deltaTime

            } else {

                this.isMoving = false

            }

        }

    }



    left() {

        if (!this.isMoving) {

            this.lulu.setRotationFromEuler(0, 0, 180)

            this.direction = new Vec3(-1, 0, 0)

            this.startMove()

        }

    }



    right() {

        if (!this.isMoving) {

            this.lulu.setRotationFromEuler(0, 0, 0)

            this.direction = new Vec3(1, 0, 0)

            this.startMove()

        }

    }



    up() {

        if (!this.isMoving) {

            this.lulu.setRotationFromEuler(0, 0, 90)

            this.direction = new Vec3(0, 1, 0)

            this.startMove()

        }

    }



    down() {

        if (!this.isMoving) {

            this.lulu.setRotationFromEuler(0, 0, 270)

            this.direction = new Vec3(0, -1, 0)

            this.startMove()

        }

    }



    startMove() {

        this.anim.play()

        this.isMoving = true

        this.movePeriod = 0

    }

}

另外做的demo是跟着cocos creator 文档的2d游戏做的. 有兴趣的也可以跟我一样, 先照着这个做一遍, 再自己新建个空项目自己操作.

最后

我认为 cocos creator 对 web 开发者来说真的是非常好上手了.

我认为小游戏的设计分为2个吧. 核心游戏场景, 与, 游戏运营.

其实核心游戏场景都不复杂的, 那怎么能让玩家一直玩呢.

其实就是策划运营, 操作一些数据, 让每次玩同一个场景, 看到不同的数字, 和不同的皮肤.

用户就会为了这些数字(pay for ability), 和皮肤(pay for love)来付费了.

我认为游戏脚本不难. 难在2点:

真的烦躁，一个月拿着死工资，每天写着增删改查，不知道以后能做什么，有时候真的想离职，进广东电子厂....

这段时间，XXXX 要加一个海康监控，哎。

苦命开发

从官网下载下来的web包

\webs\codebase 目录中有，第一个是插件，必须安装的， 后面两个JS文件是开发必要的。还要一个 JQ的，它内部使用了jq

初始化插件

引入了提供的jS后，就可以开始牛马了。。。。

首先注册插件，并检查更新

因为我这是4个摄像头，所以窗口是 2 * 2

WebVideoCtrl.I_InitPlugin 是用于初始化插件，成功回调是cbInitPluginComplete

WebVideoCtrl.I_CheckPluginVersion 用于检查更新。

在自动登录这里，我准备了数组，包含登录端口密码等信息，建议每一个之后都要等1秒。多个账号登录，插件只加载一次即可。

init() {

    // 这里的代码会在文档完全加载后执行

    WebVideoCtrl.I_InitPlugin({

        iWndowType: 2,    // 设置分屏类型为 2*2，显示 4 个窗口

        bWndFull: true,    // 支持单窗口双击全屏

        bDebugMode: true, // 关闭调试模式

        cbInitPluginComplete: async () => {

            console.log("插件初始化完成")

            try {

                // 加载插件

                await WebVideoCtrl.I_InsertOBJECTPlugin("divPlugin")

                // 检查插件是否最新

                const bFlag = await WebVideoCtrl.I_CheckPluginVersion()

                if (bFlag) {

                    alert("检测到新的插件版本，双击开发包目录里的HCWebSDKPlugin.exe升级！")

                }



                for (const item of this.channel) {

                    // 自动登陆

                    this.clickLogin(item)

                    await new Promise(resolve => setTimeout(resolve, 1000))

                }

            } catch {

                alert("插件初始化失败，请确认是否已安装插件；如果未安装，请双击开发包目录里的HCWebSDKPlugin.exe安装！")

            }

        },

        iTopHeight: 0 // 插件窗口的最高高度

    })

}

实现登录

WebVideoCtrl.I_Login 是登录接口

• 参数1：ip地址


• 参数2：1 是http，2 是https


• 参数3：端口


• 参数4：平台账户


• 参数5：平台密码

// 登陆

clickLogin(item) {

    WebVideoCtrl.I_Login(item.ip, 1, item.port, 'admin', 'admin123', {

        timeout: 3000,

        success: () => {

            console.log('登陆成功')

            setTimeout(() => {

                setTimeout(() => {

                    this.getChannelInfo(item)

                }, 1000)

            }, 10)

        },

        error: (oError) => {

            if (this.ERROR_CODE_LOGIN_REPEATLOGIN === oError.errorCode) {

                console.log('已登录过！')

            } else {

                console.log(" 登录失败！", oError.errorCode, oError.errorMsg)



            }

        }

    })

}

获取通道信息

getChannelInfo 函数需要传递一个当前控制摄像头的信息对象。

模拟通道接口：WebVideoCtrl.I_GetAnalogChannelInfo

这里会使用 jq的一些方法，会对获取的xml元素进行遍历，并将获取的信息，加入到数组集合中，进行预览视频。

• id：获取的通道号是预览的必要字段。


• 数字通道：支持高清甚至超高清分辨率，如 1080P、2K、4K 等，但是对网络要求较高


• 零通道：无法播放，坏掉了。


• 模拟通道：成本小，实时性高。

// 初始化通道

getChannelInfo(item) {

    // 模拟通道

    WebVideoCtrl.I_GetAnalogChannelInfo(item.ip, {

        success: (xmlDoc) => {

            const oChannels = $(xmlDoc).find('VideoInputChannel')

            $.each(oChannels, (i, channelObj) => {

                let id = $(channelObj).find('id').eq(0).text(),

                    name = $(channelObj).find('name').eq(0).text()

                if ("" === name) {

                    name = "Camera " + (i < 9 ? "0" + (i + 1) : (i + 1))

                }

                const ch = this.channel.find(arr => arr.ip === item.ip)

                ch.channelId = id

                ch.name = name

            })

            console.log(item.ip + '获取模拟通道成功！')



        },

        error: function (oError) {

            console.log(ip + '获取模拟通道失败！', oError.errorCode, oError.errorMsg)



        }

    })

    // 数字通道

    WebVideoCtrl.I_GetDigitalChannelInfo(item.ip, {

        success: function () {

            // console.log(item.ip + '获取数字通道成功！')

        },

        error: function (oError) {

            // console.log(item.ip + '获取数字通道失败！', oError.errorCode, oError.errorMsg)

        }

    })

    // 零通道

    WebVideoCtrl.I_GetZeroChannelInfo(item.ip, {

        success: function () {

            // console.log(item.ip + '获取零通道成功！')

        },

        error: function (oError) {

            // console.log(item.ip + '获取零通道失败！', oError.errorCode, oError.errorMsg)

        }

    })

    // 直接预览

    this.clickStartRealPlay(item)

}

预览窗口

clickStartRealPlay 函数需要传递一个当前控制摄像头的信息对象。

WebVideoCtrl.I_GetWindowStatus 可以获取窗口的状态，比如传递 0 ，可以查看 第一个窗口的状态。返回值如果不是null，表示在播放了。

WebVideoCtrl.I_Stop 用于关闭当前播放的窗口，参数 iWndIndex 用于控制关闭的那个窗口，默认会根据当前选中的窗口。

WebVideoCtrl.I_StartRealPlay 预览视频

• 参数一：ip地址 + 下划线 + 端口，拼接的字符串，比如：'192.168.1.101_80'


• 参数二：是码流，1 主码流，2 子码流


• 参数三：是前面通过通道获取的通道ID


• 参数四：默认是false，表示是否播放零通道


• 参数五：RTSP端口号

// 预览窗口

clickStartRealPlay(item) {

    const ips = item.ip + '_' + item.port

    // 获取窗口的状态

    const oWndInfo = WebVideoCtrl.I_GetWindowStatus(item.g_iWndIndex)

    const iRtspPort = ''

    const iChannelID = item.channelId

    const bZeroChannel = item.zeroType

    const szInfo = ''



    const startRealPlay = function () {

        WebVideoCtrl.I_StartRealPlay(ips, {

            iWndIndex: item.g_iWndIndex,

            iStreamType: 1,

            iChannelID: iChannelID,

            bZeroChannel: bZeroChannel,

            iPort: iRtspPort,

            success: function () {

                console.log(ips + '开始预览成功！')

            },

            error: function (oError) {

                console.log(ips + " 开始预览失败！", oError.errorCode, oError.errorMsg)

            }

        })

    }



    if (oWndInfo != null) { // 已经在播放了，先停止

        WebVideoCtrl.I_Stop({

            success: function () {

                startRealPlay()

            }

        })

    } else {

        startRealPlay()

    }

}

摄像头功能控制

接口：WebVideoCtrl.I_PTZControl

• 参数一：操作类型（1-上，2-下，3-左，4-右，5-左上，6-左下，7-右上，8-右下，9-自转，10-调焦+， 11-调焦-, 12-F聚焦+, 13-聚焦-, 14-光圈+, 15-光圈-


• 参数二：true 停止，false 启动


• 参数三：对象：iWndIndex 窗口号，默认为当前选中窗口，iPTZSpeed 云台速度，默认为4

<div class="jiu" :style="{display: isOpen ? 'flex': 'none'}">

    <div class="remote-control">

        <el-tooltip content="向左上转动" placement="top-start" effect="light">

            <div class="button top-left" @mousedown="mouseDownPTZControl(5, false)"

                @mouseup="mouseDownPTZControl(1, true)"></div>

        </el-tooltip>

        <el-tooltip content="向上转动" placement="top-start" effect="light">

            <div class="button" @mousedown="mouseDownPTZControl(1, false)"

                @mouseup="mouseDownPTZControl(1, true)">

                <i class="iconfont icon-shangjiantou1"></i>

            </div>

        </el-tooltip>

        <el-tooltip content="向右上转动" placement="top-start" effect="light">

            <div class="button top-right" @mousedown="mouseDownPTZControl(7, false)"

                @mouseup="mouseDownPTZControl(1, true)"></div>

        </el-tooltip>

        <el-tooltip content="向左转动" effect="light">

            <div class="button" @mousedown="mouseDownPTZControl(3, false)"

                @mouseup="mouseDownPTZControl(1, true)">

                <i class="iconfont icon-zuojiantou"></i>

            </div>

        </el-tooltip>

        <el-tooltip content="开启自动旋转" effect="light">

            <div class="button center" @click="mouseDownPTZControl(9, false)">

                <i class="iconfont icon-zidongxuanzhuan"></i>

            </div>

        </el-tooltip>

        <el-tooltip content="向右转动" effect="light">

            <div class="button" @mousedown="mouseDownPTZControl(4, false)"

                @mouseup="mouseDownPTZControl(1, true)">

                <i class="iconfont icon-youjiantou"></i>

            </div>

        </el-tooltip>

        <el-tooltip content="向左下转动" effect="light">

            <div class="button bottom-left" @mousedown="mouseDownPTZControl(6, false)"

                @mouseup="mouseDownPTZControl(1, true)"></div>

        </el-tooltip>

        <el-tooltip content="向下转动" effect="light">

            <div class="button" @mousedown="mouseDownPTZControl(2, false)"

                @mouseup="mouseDownPTZControl(1, true)">

                <i class="iconfont icon-xiajiantou1"></i>

            </div>

        </el-tooltip>

        <el-tooltip content="向右下转动" effect="light">

            <div class="button bottom-right" @mousedown="mouseDownPTZControl(8, false)"

                @mouseup="mouseDownPTZControl(1, true)"></div>

        </el-tooltip>

    </div>

</div>

<!-- 下方操作按钮 -->

<div class="div-group" :style="{display: isOpen ? 'block': 'none'}">

    <div style="display: flex; justify-content:space-around;">

        <el-button-group>

            <el-tooltip content="焦距变大" placement="top" effect="light">

                <div class="btn-groups" @mousedown="mouseDownPTZControl(10, false)" @mouseup="mouseDownPTZControl(11, true)">

                    <i class="iconfont icon-fangdajing-jia"></i>

                </div>

            </el-tooltip>

            <el-tooltip content="焦距变小" placement="top" effect="light">

                <div class="btn-groups" @mousedown="mouseDownPTZControl(11, false)" @mouseup="mouseDownPTZControl(11, true)">

                    <i class="iconfont icon-fangdajing-jian"></i>

                </div>

            </el-tooltip>

        </el-button-group>

        <el-button-group>

            <el-tooltip content="焦点前调" placement="top" effect="light">

                <div class="btn-groups" @mousedown="mouseDownPTZControl(12, false)" @mouseup="mouseDownPTZControl(12, true)">

                    <i class="iconfont icon-jiaodianqiantiao"></i>

                </div>

            </el-tooltip>

            <el-tooltip content="焦点后调" placement="top" effect="light">

                <div class="btn-groups" @mousedown="mouseDownPTZControl(13, false)" @mouseup="mouseDownPTZControl(12, true)">

                    <i class="iconfont icon-jiaodianhoutiao"></i>

                </div>

            </el-tooltip>

        </el-button-group>

        <!-- <el-button-group>

            <el-tooltip content="光圈扩大" placement="top" effect="light">

                <el-button>

                    <i class="iconfont icon-guangquankuoda"></i>

                </el-button>

            </el-tooltip>

            <el-tooltip content="光圈缩小" placement="top" effect="light">

                <el-button>

                    <i class="iconfont icon-guangquansuoxiao"></i>

                </el-button>

            </el-tooltip> -->

        </el-button-group>

    </div>

</div>

mouseDownPTZControl(iPTZIndex, selection) {

    // 获取窗口状态

    const oWndInfo = WebVideoCtrl.I_GetWindowStatus(this.item.g_iWndIndex)

    if (oWndInfo == null) {

        return

    }



    // 如果是零通道，直接返回

    if (this.item.zeroType) {

        return

    }

    let iPTZSpeed = selection ? 0 : 4

    // 表示开启了自动

    if (9 === iPTZIndex && this.g_bPTZAuto) {

        // 将速度置为 0

        iPTZSpeed = 0



    } else {

        this.g_bPTZAuto = false

    }



    // 控制云平台

    WebVideoCtrl.I_PTZControl(iPTZIndex, selection, {

        iWndIndex: this.item.g_iWndIndex, iPTZSpeed,

        success: (xmlDoc) => {

            if (9 == iPTZIndex) {

                this.g_bPTZAuto = !this.g_bPTZAuto

            }

        },

        error: function (oError) {

            console.log(oWndInfo.szDeviceIdentify + " 开启云台失败！", oError.errorCode, oError.errorMsg)

        }

    })



}

到此就结束了，海康这个还不错，就是没有vue webpack的包，在webpack 的环境下，是会报错的。

扯皮

最近接到了一个需求：前端点击按钮触发某个任务并开启轮询获取任务进度，直至 100% 任务完成后给予用户提示

这个业务场景还挺常见的，但是突然上周后端联系到我说现在的效果有点差，之前都是小任务那进度条展示还挺不错的，现在有了一些大任务且会存在排队阻塞的情况，就导致视图上经常卡 0% 排队，用户体验太差了，问能不能在刚开始的时候做个假进度先让进度条跑起来😮

因此就有了这篇文章，简单做一下技术调研以及在项目中的应用

正文

其实假进度条也不难做，无非是轮询的时候我们自己做一个随机的自增，让它卡到 99% 等待后端真实进度完成后再结束

只不过还是想调研一下看看市面上有没有一些成熟的方案并去扒一下它们的源码🤓

NProgress

首先当我听到这里的需求后第一时间想到的就是它：rstacruz/nprogress: For slim progress bars like on YouTube, Medium, etc

记得大学期间做的一些中后台系统基本都少不了路由跳转时的顶部进度条加载，那时候就有了解到 NProgress，它的使用方式也很简单，完全手控：NProgress: slim progress bars in JavaScript，去文档里玩一下就知道了

视图呈现的效果就是如果你不手动结束那它就会一直缓慢前进卡死 99% ，挺符合我们这里的需求，可以去扒一下它内部进度计算相关的逻辑

NProgress 的内容实际上比较少，源码拉下来可以看到主要都在这一个 JS 文件里了：

需要注意的是我们看的是这个版本：rstacruz/nprogress at v0.2.0，master 分支与 npm 安装的 0.2.0 内部实现还是有些差别的

我们这里不关注它的样式相关计算，主要来看看对进度的控制，直奔 start 方法：

还是比较清晰的，这里的 status 就是内部维护的进度值，默认为 null，所以会执行 NProgress.set，我们再来看看 set 方法：

set 方法里有一大堆设置动画样式逻辑都被我剪掉了，关于进度相关的只有这些。相当于利用 clamp 来做一个夹层，因为初始进来的 n 为 null，所以经过处理后进度变为 0.08

再回到 start 的逻辑，其中 work 就是内部轮询控制进度自增的方法了，初始配置 trickle 为 true 代表自动开启进度自增，由于进度条在 set 方法中已经设置为 0.08，所以走到后面的 NProgress.trickle 逻辑

看来这里就是进度控制的核心逻辑了， trickle 里主要调用了 inc，在 trickle 中给 inc 传递了一个参数：Math.random() * Settings.trickleRate，显然这里范围是：0 <= n < 0.02

而在 inc 中，如果传递的 amount 有值的话那就每次以该值进行自增，同时又使用 clamp 将最大进度卡在 0.994

最后再调用 set 方法，set 里才是更新进度和视图进度条的方法，涉及到进度更新时都需要回到这里

当然 NProgress.inc 也可以手动调用，还对未传参做了兼容处理：

amount = (1 - n) * clamp(Math.random() * n, 0.1, 0.95)

即根据当前进度 n 计算剩余进度，再随机生成自增值

再来看 done 方法，它就比较诡异了：

按理来说直接将进度设置为 1 就行，但它以链式调用 inc 再调用 set，相当于调用了两次 set

而这里 inc 传参又没什么规律性，推测是为了 set 中的样式处理，感兴趣的可以去看看那部分逻辑，还挺多的...😶

一句话总结一下 NProgress 的进度计算逻辑：随机值自增，最大值限制

但是因为 NProgress 与进度条样式强绑定，我们肯定是没法直接用的

fake-progress

至于 fake-progress 则是我在调研期间直接搜关键词搜出来的😶：piercus/fake-progress: Fake a progress bar using an exponential progress function

很明显看介绍就是干这个事的，而且还十分专业，引入数学函数展示假进度条效果，具有说服力：

所以我们项目中其实就是用的这个包，只不过和 NProgress 类似，两个包都比较老了，瞟一眼源码发现都是老 ES5 了🤐

因为我们项目中用的是 React，这里给出 React 的 demo 吧，为了编写方便使用了几个 ahooks 里的 hook：

其实使用方法上与 NProgress 都类似，不过两者都属于通用的工具库不依赖其他框架，所以像视图渲染都需要自己手动来做

注意实例化中的传参 timeConstant，某种意义上来讲这个值就相当于“进度增长的速率”，但也不完全等价，我们来看看源码

因为不涉及到样式，fake-progress 源码更简单，核心就在这里：

下方的数学公式就是介绍图中展示的，只能说刚看到这部分内容是真的是死去的数学只是突然又开始攻击我😅，写了那么多函数，数学函数是啥都快忘了

我们来简单分析一下这个函数 1 - Math.exp(-1 * x)，exp(x)= $e^x$，$e^x$ 的图像长这样，高中的时候见的太多了：

那假如这里改成 exp(-x) 呢？有那味了，以前应该是有一个类似的公式 $f(x)$ 与 $f(-x)$ 图像效果是关于 y 轴对称，好像是有些特殊的不符合这个规律？🤔反正大部分都是满足的

OK，那我们继续进行转换，看看 -exp(-x) 的效果

同样有个公式 $f(x)$ 与 $-f(x)$ 图像效果是关于 x 轴对称：

初见端倪，不知道你们有没有注意 -exp(-x) 最终呈现的图像是无限接近于 x 轴的，也就是 0：

那有了🤓，假如我再给它加个 1 呢？它不就无限接近于 1 了，即 -exp(-x) + 1，这其实就是 fake-progress 里公式的由来：

但你会发现如果 x 按 1 递增就很快进度就接近于 1 了，所以有了 timeConstant 配置项来控制 x 的增长，回看这个公式：1 - Math.exp(-1 * this._time / this.timeConstant)

this._time 是一直在增长的，而 this.timeConstant 作为分母如果被设置为一个较大的值，那可想而知进度增长会巨慢

所以 fake-progress 的核心原理是借助数学函数，以函数值无限接近于 1 来实现假进度条，但是这种实现有一个 bug，可以看我提的这个 issues，不过看这个包的更新时间感觉作者也不会管了😅：

bug: progress may reach 100% · Issue #7 · piercus/fake-progress

useFakeProgress

虽然我们现在项目中使用的是 fake-progress，但是个人感觉用起来十分鸡肋，而且上面的 bug 也需要自己手动兼容，因此萌生出自己封装一个 hook 的想法，让它更符合业务场景

首先我们确定一下进度计算方案，这里我毫不犹豫选择的是 NProgress 随机值增长方案，为什么？因为方便用户自定义

而且 NProgress 相比于 fake-progress 有一个巨大优势：手动 set 进度后仍然保持进度正常自动递增

这点在 fake-progress 中实现是比较困难的，因为你无法保证手动 set 的进度是在这个函数曲线上，相当于给出函数 y 值反推 x 值，根据反推的 x 值再进行递增，想想都麻烦

确定好方案后我们来看下入参吧，参考 NProgress 我定义了这几个配置项：

这里我简单解释一下 rerender 和 amount 配置：

实际上在封装这个 hook 的时候我一直在纠结这里的 progress 到底是 state 还是 ref，因为大多数场景下 hook 内部通过轮询定时器更新进度，而真实业务代码中也会开启定时器去轮询监听业务接口的

所以如果写死为 state，那这个场景 hook 内部的每次更新 render 是没必要的，但是假如用户又想只是使用假进度展示，没有后端业务接口呢？

思来想去其实完全可以放权给用户进行配置，因为 state = ref + update，统一使用 ref，用户配置 rerender 时我们在每次更新时 update 即可

至于 amount 我是希望放权给用户进行自定义递增值，你可以配置成一个固定值也可以配置成随机值，更可以像 NProgress master 分支下这样根据当前进度来控制自增，反正以函数参数的形式能够拿到当前的 progress：

至于实现细节就不再讲述了，实际上就是轮询定时器没什么复杂的东西，直接上源码了：

import { useRef, useState } from "react";



interface Options {

  minimun?: number;

  maximum?: number;

  speed?: number;

  rerender?: boolean;

  amount?: (progress: number) => number;

  formatter?: (progress: number) => string;

  onProgress?: (progress: number) => void;

  onFinish?: () => void;

}



export function useFakeProgress(options?: Options): [

  { current: string },

  {

    inc: (amount?: number) => void;

    set: (progress: number) => void;

    start: () => void;

    stop: () => void;

    done: () => void;

    reset: () => void;

    get: () => number;

  }

] {

  const {

    minimun = 0.08,

    maximum = 0.99,

    speed = 800,

    rerender = false,

    amount = (p: number) => (1 - p) * clamp(Math.random() * p, minimun, maximum),

    formatter = (p: number) => `${p}`,

    onProgress,

    onFinish,

  } = options || {};



  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);

  const progressRef = useRef(0);

  const progressDataRef = useRef(""); // formatter 后结果

  const [, update] = useState({});



  const clamp = (value: number, min: number, max: number) => Math.min(Math.max(value, min), max);



  const setProgress = (p: number) => {

    progressRef.current = p;

    progressDataRef.current = formatter(p);

    onProgress?.(p);

    if (rerender) update({});

  };



  const work = () => {

    const p = clamp(progressRef.current + amount(progressRef.current), minimun, maximum);

    setProgress(p);

  };



  const start = () => {

    function pollingWork() {

      work();

      timerRef.current = setTimeout(pollingWork, speed);

    }



    if (!timerRef.current) pollingWork();

  };



  const set = (p: number) => {

    setProgress(clamp(p, minimun, maximum));

  };



  const inc = (add?: number) => {

    set(progressRef.current + (add || amount(progressRef.current)));

  };



  const stop = () => {

    if (timerRef.current) clearInterval(timerRef.current);

    timerRef.current = null;

  };



  const reset = () => {

    stop();

    setProgress(0);

  };



  const done = () => {

    stop();

    setProgress(1);

    onFinish?.();

  };



  return [

    progressDataRef,

    {

      start,

      stop,

      set,

      inc,

      done,

      reset,

      get: () => progressRef.current,

    },

  ];

}

这里需要补充一个细节，在返回值里使用的是 progressDataRef 是 formatter 后的结果为 string 类型，如果用户想要获取原 number 的 progress，可以使用最下面提供的 get 方法拿 progressRef 值

一个 demo 看看效果，感觉还可以：

当然由于直接返回了 ref，为了防止用户篡改可以再上一层代理劫持，我们就省略了

这也算一个工具偏业务的 hook，可以根据自己的业务来进行定制，这里很多细节都没有补充只是一个示例罢了🤪

End

以上就是这篇文章的内容，记得上班之前还在想哪有那么多业务场景需要封装自定义 hook，现在发现真的是各种奇葩需求都可以封装，也算是丰富自己武器库了...

背景

转眼写代码有10多年了，林林总总花费了很多的钱，现在主要按照4大件来盘点下我都买了啥。

电脑

acer 4741g ¥4500+

这是我入门时的一款电脑，整体配置在当时还是属于中等的。



当时用的编辑器还是notepad++，在这个配置下，还是可以愉快的编码的。

mac air 2013 ¥8800+

当时被苹果的放进信封的广告创意所折服，这也是我的第一台apple，在之后就一直用苹果了。到手后的感觉是，薄，确实薄，大概只有我宏基的1/3-1/4厚。

当时apple的简洁，快速，很少的配置，让我在环境变量上苦苦挣扎的心酸得以释放。以后也不用比较各种笔记本参数了

mac book pro13 2015 ¥9000+

当时买这台的原因是因为air进水了，经常死机，修了2次后，又坏了。一怒之下，直接买了一台。

换了新的retina屏之后，色彩质量和效果都提升了不少，对比原来的air性能也是拉升了超级多。但是因为是16上半年买的，所以没体验到toch bar，到现在都没体验过。。。

这是我真正意义上的第一台十分满意的电脑，大概是当时的理想型了。

公司电脑

2016年下半年进了一家创业公司，公司配置了mac book pro，比我的配置还高，所以之后一直就是用公司的。

2021年换新公司，公司配了thinkpad，又一次开始用win。然后又被win各种打败，有时又有了换回mac的想法。

当前–mac book pro14 2021 ¥21999

主要入手的原因是公司的电脑我觉得太慢了。当时开发小程序，脚手架是公司自己的，每次打包都是全量的，没有缓存。所以每次打包短则7，8分钟，长则10多分钟。加上切分支/安装依赖（如果两个分支依赖版本不同，需要强制更新），导致我每天花费大量的时间等待上。

同事早于我入手了M1，反馈巨好，于是我也买了，想着配置拉的满点，但是还是高估了自己的钱包，低估了苹果的价格，只能退而求其次的选择了中档配置。

每次看着低低的负载，都是满满的安全感。



另外m1是支持stable diffusion的，所以偶尔我也会炼丹

显示器

dell U2424H ¥1384

其实在写代码之前也买过几台显示器，但是以程序员视角来说，第一台是这台。原因是当时公司也是这个型号，主要是能旋转，谁能拒绝一台自由旋转的显示器呢？

而且dell的质量和做工都不错，在当时是十分喜欢的。

小米 Redmi 27 ¥789.9

dell那台显示器是放在家里的，公司也需要显示器，而且自带设备每个月可以补贴100，所以就入手了这款，原因无他：便宜，也够大。

但是用久了，发现也有些问题。例如失真等，但是真的便宜，

厂家送寄，但因为合作内容没谈拢，本周寄回

键盘

当前-cherry G80-3000 ¥689

一把真正可以用到包浆的键盘，大多数看到这个键盘的感觉应该都是黄色，而不是原本的白色，不知道是不是材质的问题，极其容易变黄。同时由于键帽又不变黄，所以呈现了诡异的脏脏的颜色。

因为本身机械键盘的高度，所以建议加个手托比较好。各种轴也齐全，任君选择。

目前这个键盘在家里游戏了，毕竟是个全键盘

当前–京造C2 ¥253

选择这个键盘的原因嘛，同事有了，并且是一个带灯的键盘。手感比cherry硬一些，但还属于是能接受的程度，整体延迟比较低（也可能是因为有线的原因）。目前是在办公室使用的一款，当前这篇文章就是用这个敲出来的。

鼠标

总览

鼠标其实留在手边的不太多，大多数都是消耗品了，这么些年，各种有用过。大概用了不下10个鼠标，我只挑2个重点的说吧。

微软ie 3.0 ¥359

这是我用过最好的鼠标，没有之一。握感极佳，用久了也不累，比其他的鼠标都舒服万分。

当前–apple magic trapad ¥899

mac用户的最终归属就是板子，如果你刚开始用mac，那么建议直接用板子吧。支持原生手势操作，各种mac本身触控板的事情都完美适用，真正的跟你的电脑和为一体。

欢迎评论区留言你的设备

如上所述，我这年的大头是电脑，消耗品是鼠标、，那么你都花了多少钱呢？

引言

Rust语言是一门现代系统编程语言，由Mozilla Research于2009年开始开发，Mozilla Research 是 Mozilla 基金会旗下的一个研究部门，专注于推动开放网络和创新技术的发展，Rust语言正是在 Mozilla Research 中孕育并发展的。

Rust 最早是 Mozilla 雇员 Graydon Hoare 的个人项目，在2006年开始了Rust语言的初步设计，Mozilla 随后投入资源，支持Rust的发展，并最终于2010年公开这个项目，2015年发布1.0版本。

以下引用自Rust 语言圣经

大家可能疑惑 Rust 为啥用了这么久才到 1.0 版本？与之相比，Go 语言 2009 年发布，却在 2012 年仅用 3 年就发布了 1.0 版本[^1]。

● 首先，Rust 语言特性较为复杂，所以需要全盘考虑的问题非常多；

● 其次，Rust 当时的参与者太多，七嘴八舌的声音很多，众口难调，而 Rust 开发团队又非常重视社区的意见；

● 最后，一旦 1.0 快速发布，那绝大部分语言特性就无法再被修改，对于有完美强迫症的 Rust 开发者团队来说，某种程度上的不完美是不可接受的。

因此，Rust 语言用了足足 6 年时间，才发布了尽善尽美的 1.0 版本。

大家知道 Rust 的作者到底因为何事才痛下决心开发一门新的语言吗？

说来挺有趣，在 2006 年的某天，作者工作到精疲力尽后，本想回公寓享受下生活，结果发现电梯的程序出 Bug 崩溃了，要知道在国外，修理工可不像在中国那样随时待岗，还要知道，他家在 20 多楼！

最后，他选择了妥协，去酒店待几天等待电梯的修理。

当然，一般人可能就这样算了，毕竟忍几天就过去了嘛。但是这名伟大的程序员显然也不是一般人，他面对害他流离失所的电梯拿起了屠龙宝刀 - Rust。

自此，劈开一个全新的编程世界。

深入了解Rust

为什么要创建Rust这门语言？

在 Rust 出现之前，系统级编程领域主要由 C 和 C++ 统治。虽然这两种语言在性能方面表现出色，但它们也存在一些固有的缺陷，促使了 Rust 的诞生。

什么是系统级编程语言？

简单来说，系统级编程语言用于开发操作系统、驱动程序、嵌入式系统、游戏引擎、数据库等对性能和硬件控制要求极高的软件。

有以下特性：

• 硬件访问： 系统级语言需要能够直接访问硬件资源，直接操作硬件
• 高性能： 系统级程序通常需要直接操作硬件，对性能要求非常高。因此，系统级语言通常具有高效的内存管理机制和优化的编译器，以生成高效的机器码。
• 较强的类型系统和编译时检查：为了尽早发现潜在的错误，系统级语言通常具有较强的类型系统和编译时检查机制，以提高代码的可靠性和安全性。
• 并发和并行： 现代计算机系统通常具有多核处理器，系统级程序需要能够有效地利用多核资源，实现并发和并行执行，以提高性能。
• 内存控制： 系统级编程需要对内存进行精细的控制，包括内存分配、释放、布局等。一些系统级语言允许开发者直接操作内存地址，以实现更高的灵活性和效率

有哪些系统级编程语言？

• C/C++

  无GC，性能高，内存不安全

• Rust

  无GC，性能高，内存安全

• Go

  有GC，性能不如Rust，安全性不如Rust。

• Assembly Language（汇编语言）

  性能高，开发效率低

• zig

  无GC，性能高，安全性不如Rust，发展初期

C/C++ 的缺陷

• 内存安全问题： C/C++ 允许开发者手动管理内存，这虽然提供了灵活性，但也容易导致各种内存安全问题，如：
  • 空指针（Null Pointers）： 访问未初始化的指针或空指针会导致程序崩溃。
  • 野指针（Wild Pointers）： 指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。。
  • 悬垂指针（Dangling Pointers）： 指针指向曾经存在的对象，但该对象已经被释放，再次访问该指针会导致未定义行为，悬垂指针是野指针的一种。
  • 双重释放（Double Free）： 释放同一块内存两次，导致崩溃或不可预测的行为。
  • 内存泄漏（Memory Leaks）： 分配的内存没有被及时释放，导致内存占用不断增加，最终可能导致系统崩溃。
  • 缓冲区溢出（Buffer Overflows）： 向缓冲区写入超出其容量的数据，可能覆盖相邻的内存区域，导致程序崩溃或安全漏洞。
• 并发安全问题： C/C++ 的并发编程容易引入数据竞争（Data Races）等问题，导致程序行为不确定，难以调试和维护。
• 缺乏现代化的语言特性： C/C++ 的语法相对陈旧，缺乏一些现代化的语言特性，如模式匹配、类型推断等，使得代码编写和维护相对繁琐。

Rust 的创建正是为了解决 C/C++ 等语言的这些不足，同时保留其高性能的优点。具体来说，Rust 的设计目标是：

• 解决内存安全问题： Rust 通过所有权系统、借用检查器等机制，在编译时就杜绝了空指针、野指针、数据竞争等内存安全问题。
• 提供安全的并发编程： Rust 的所有权系统和类型系统也对并发安全提供了保障，使得开发者可以更容易地编写安全的并发程序。
• 提供现代化的语言特性： Rust 引入了模式匹配、类型推断、trait 等现代化的语言特性，提高了代码的简洁性、可读性和可维护性。
• 保持高性能： Rust 的设计理念是“零成本抽象”，即提供高级的抽象能力，但不会带来额外的运行时开销，且无需垃圾回收器等运行时机制，从而避免了额外的性能开销，媲美 C/C++。

简而言之，因为还缺一门无 GC 且无需手动内存管理、性能高、工程性强、语言级安全性、广泛适用性的语言，而 Rust 就是这样的语言。

为什么选择Rust语言？

• 保证安全、内存占用小的同时能提供和C/C++ 一样的性能
• 广泛的适用性，系统编程、网络服务、命令行工具、WebAssembly等场景都能应用
• 生态渐渐完善，有大量的库和框架，完整的工程化开发工具链，强大的包管理
• 社区非常活跃和友好，文档全面

Rust不是闭门造车的语言，能看出来设计者是做过大量不同语言的项目的人，Rust从解决实际问题出发，借鉴和融合其他语言的优点，又能够创新地提出所有权和生命周期，这个强大的能力带来了0开销的内存安全和线程安全。

凡事有利必有弊，Rust是站在前人的肩膀上，它集百家之长，借鉴了其他语言的许多优秀特性，如npm的包管理、go的channel来进行并发通信、Haskell的trait（类似java的接口），还有元组、泛型、枚举，闭包、智能指针这些特性并非rust原创，但Rust确实把这些优点全部吸收了进来，而没有做过度的设计和发散，让有一些其他语言基础的人还能够减轻一些上手成本。

即使这样，Rust依然是在一众语言里学习曲线最陡峭的语言之一，此外，Rust为了提高运行时性能必然是会牺牲一些编译时的效率的。

但是，这丝毫不会影响Rust成为一门伟大的语言，如果有一门语言可以改变你的编程思维方式，倒逼你进行更好的代码设计，让你在初学过程中连连发出“原来是这样啊”的感叹，那么它一定是Rust。

Rust 核心设计理念对前端有哪些启示

Rust的很多设计理念都可以在前端领域中或多或少地找到影子，让你明白前端某些技术为什么要这么设计，以及为什么不那么设计。

安全性设计

1. 类型安全

• 静态类型检查：

  Rust 提供了一个非常强大的类型系统，确保了类型安全。在编译时，Rust 会强制要求所有变量和函数都有明确的类型声明。这使得很多潜在的错误能够在编译时被捕获，避免了运行时出现类型错误。

  反观JavaScript，作为js开发者，那是太有发言权了，由于js是动态类型语言，所以很多错误只能在运行时被发现，跑着跑着可能就出一个线上bug，这是多少前端开发者的痛啊。

  当在写了一段时间Rust后，我们就会明白TypeScript为什么会火了，以及TS为什么是必要的，TS不能解决所有问题，但能解决大部分低级问题。

  如果你不用TS，提高代码健壮性也是有方法的，只不过心智负担更重。参照文章接口一异常你的页面就直接崩溃了？

• 不可变性和可变性：

  在 Rust 中，变量默认是不可变的，只有显式声明为可变 (mut) 才能修改。这种设计减少了错误发生的概率，因为不可变数据是线程安全的，不会在多个地方被修改。

  在JS中也有类似的设计，联想到ES6的const和let，const 只能保证变量引用不可变，但如果引用的是对象或数组，内容依然可以改变。可谓是相当鸡肋。

2. 内存安全

Rust 提供了一种独特的所有权系统来自动管理内存，避免了许多传统语言中常见的内存错误，如内存泄漏、悬垂指针和双重释放。

Rust 的内存安全设计包括以下几个方面：

• 所有权系统：Rust 中的所有权系统确保每个资源只有一个所有者，而所有权可以转移。一旦所有权转移，原所有者无法再访问或修改该资源，资源离开作用域时会自动释放，这就避免了双重释放和内存泄漏的问题。
• 借用检查器：Rust 的借用检查器确保在同一时间只能存在不可变借用或一个可变借用。这避免了并发情况下的内存冲突。
• 生命周期：Rust 的生命周期系统确保引用的有效性，在编译时检查引用的生命周期与持有它的资源的生命周期是否匹配，从而防止悬空引用和野指针。

反观JavaScript 中的内存问题：

• 内存泄漏（Memory Leak）： 内存泄漏是指程序无法释放不再使用的内存，导致内存资源被浪费。在 JavaScript 中，由于垃圾回收机制，内存泄漏通常发生在以下几种情况：
  • 全局变量：

    全局变量是在全局作用域中声明的，它们在程序执行期间存在，直到程序结束时才会被销毁。因此，无论这些全局变量是否仍在使用，它们都将保持存在，无法被垃圾回收器回收。

      // 全局变量
    
    var globalVar = { name: 'example' };
    
    
    
    // 该对象即使没有被引用，仍然会存在，直到页面关闭
    
    

    在浏览器中，全局变量被视为 window 对象的属性，在 Node.js 中，则是 global 对象。

    垃圾回收器一般不会回收全局变量，原因之一是全局变量的清理通常意味着整个应用程序的关闭或重载。如果要强制回收全局变量，会导致额外的复杂性和性能开销。因此，大多数 JavaScript 引擎（如 V8）选择让全局变量一直存活。

    全局变量不仅会导致内存泄漏还有容易被意外覆盖的风险，尽量使用模块化、闭包等方式来避免将变量暴露到全局作用域中。

    同理，全局变量也会导致无法准确的进行treeshaking优化，因为全局变量是有副作用的。

  • 闭包（Closures）：

    闭包可能会保持对外部函数作用域变量的引用，从而防止这些变量被回收。

    function createClosure() {
    
      let largeObject = new Array(1000000).fill('Memory leak');
    
    
    
      // 返回一个函数，访问 largeObject
    
      return function() {
    
        console.log(largeObject[0]);
    
      };
    
    }
    
    
    
    const closure = createClosure();
    
    
    
    // 使用完闭包后，显式清除引用
    
    closure = null;  // 删除对闭包的引用，垃圾回收器可以回收 largeObject
    
    

    largeObject 是一个占用大量内存的对象。当我们调用 createClosure 时，它返回一个内部函数 closure，这个内部函数会引用 largeObject。尽管 largeObject 的生命周期在 createClosure 执行完之后结束，但由于 closure 仍然持有对 largeObject 的引用，这个对象就无法被垃圾回收器回收，从而导致内存泄漏。

    闭包本身不会引起内存泄漏，但如果闭包捕获了外部函数的引用，且这些引用长时间未清除，就可能导致内存泄漏。

• 事件监听器：

  如果没有正确移除事件监听器，可能导致无法释放关联的内存。

  如果我们为 DOM 元素注册了事件监听器，但没有在适当的时候移除它们，尤其是在元素被删除或不再需要时，事件监听器会一直保持对 DOM 元素的引用，从而防止垃圾回收。

  "my-element">Click me!
  
  
  
  
  <script>
  
    let element = document.getElementById('my-element');
  
  
  
    // 给 DOM 元素添加事件监听器
  
    function handleClick() {
  
      console.log('Element clicked');
  
    }
  
  
  
    element.addEventListener('click', handleClick);
  
  
  
    // 假设我们从 DOM 中移除了该元素
  
    document.body.removeChild(element);
  
  
  
    // 但是我们没有移除事件监听器，事件监听器仍然持有对该元素的引用
  
    // 因此该元素无法被垃圾回收
  
  script>
  
  

  需要手动清除事件监听器

  element.removeEventListener('click', handleClick);  // 移除事件监听器
  
  element = null;  // 清除对 DOM 元素的引用
  
  

• DOM 元素引用：

  如果 DOM 元素的引用在不再需要时没有清除，垃圾回收机制也无法回收它们。

  当我们通过 DOM 操作获取并引用一个 DOM 元素时，如果该元素的引用没有及时清除，即使该元素已经被移除或不再需要，它也不会被垃圾回收，从而导致内存泄漏。

  "my-element">Hello, World!
  
  
  
  
  <script>
  
    // 获取 DOM 元素并保存引用
  
    let element = document.getElementById('my-element');
  
  
  
    // 动态移除该元素
  
    document.body.removeChild(element);
  
  
  
    // 但是我们没有清除 element 引用
  
    // 这个引用仍然指向已经从 DOM 树中移除的元素
  
    // 此时垃圾回收器无法回收这个元素，因为引用仍然存在
  
  script>
  
  

  可以使用 element = null 来清除引用，但这个操作需要手动执行，容易忘记。

v8的垃圾回收器

V8 中的GC采用标记清除法进行垃圾回收。主要流程如下：

• 标记：从根对象开始，遍历所有的对象引用，被引用的对象标记为活动对象，没有被引用的对象（待清理）标记为垃圾数据。
• 垃圾清理：将所有垃圾数据清理掉

在我们的开发过程中，如果我们想要让垃圾回收器回收某一对象，就将对象的引用直接设置为 null

let a = {}; // {} 可访问，a 是其引用



a = null; // 引用设置为 null

// {} 将会被从内存里清理出去

但如果一个对象被多次引用时，例如作为另一对象的键、值或子元素时，将该对象引用设置为 null 时，该对象是不会被回收的

let a = {};

let arr = [a];



a = null;

console.log(arr)

// [{}]

因为a被arr引用，即使a不被使用了，也不会被释放，除非arr也被设置为null。

JS也考虑到了这一点，在ES6中推出了： WeakMap和WeakSet 。它对于值的引用都是不计入垃圾回收机制的，所以名字里面才会有一个"Weak"，表示这是弱引用（对对象的弱引用是指当该对象应该被GC回收时不会阻止GC的回收行为）。

let a = {};

let arr = new WeakSet();

arr.add(a);



a = null;

console.log(arr.has(a))

// false

即 arr 对a的引用是弱引用，如果a不用了，不会阻止垃圾回收。

以上代码可以在控制台自行尝试一下

即便JS给出了可以避免特定场景的内存泄漏的方案，但依然无法避免所有场景的内存泄漏，而且就算你熟谙内存泄漏的各种场景以及对应解决方案，百密也终有一疏，更何况实际开发中代码能跑起来我们就几乎不会考虑啥内存问题，而Rust则强制你一定要考虑内存安全，否则编译都不过。

3. 并发安全

Rust 的并发模型通过其所有权和借用规则确保了并发编程中的安全性。Rust 中的并发安全设计包括：

• 数据竞争防止：Rust 中，数据竞争在编译时就能被发现。Rust 通过所有权规则确保要么有多个不可变借用，要么有一个可变借用，从而避免了并发时对共享数据的非法访问。
• 线程安全：Rust 使用 Send 和 Sync 特性来标识哪些类型可以在线程之间传递或共享。Send 允许数据在不同线程之间传递，Sync 允许多个线程共享数据。
• 锁机制：Rust 提供了 Mutex 和 RwLock 等机制来确保在多线程环境下对共享资源的安全访问。

JS是单线程，但是JS的单线程是基于事件循环的非阻塞的，所以可以通过异步来实现伪并发，竞态条件、数据竞争、数据共享等问题在JS中是很难发现的，甚至别人的代码修改了你的数据你都不知道，没有一定的开发经验积累，去排查由此产生地莫名其妙的bug是相当折磨人的。

当学习了Rust之后，你就会下意识地去考虑你所定义的数据的安全性，有没有不确定的执行顺序引发的问题？有没有可能被非预期的共享和修改？我改了这个对象会不会影响到其他部分的功能表现等等？从而去想办法将可能会发生的问题扼杀在摇篮里。例如在处理组件状态时，采用不可变数据结构和函数式编程模式可以减少出错的机会。实际上对于前端开发者来说，这类bug是相当常见的。

JS其实也是在不断努力解决其本身存在的各种问题的，例如不断升级的ES新特性，使用 use stric 开启严格模式，还有函数式编程范式的流行，以及各类框架都支持的状态管理等等，这些措施都是为了让JS代码能够更加健壮，弥补JS本身的一些不足。

不可变数据结构： 在React中，使用useState和useReducer来管理状态，避免直接修改状态对象。以及redux等状态管理库，还有像Immer这样的库来简化不可变数据的操作。 函数式编程： 在JavaScript中，封装有明确输入和输出的函数，或使用高阶函数（如map、filter、reduce）来处理数据，避免修改原始数据，从而保持代码的清晰性和可测试性。

无论是函数式编程，还是状态管理，都是为了减少每个动作的副作用，有明确的数据流，让代码更安全更加可维护，低耦合高内聚不是一句空话，是业界大佬们真正在不断去实践的。只是我们自己没有感知，而实际上JS这门语言自身的缺陷真的很多，用JS去开发很容易，但是用JS去开发出健壮又高性能的代码是很难的，这可能也是为什么前端框架和库百花齐放而又前仆后继的原因。

4. 错误处理

Rust没有传统意义上的异常机制。在许多编程语言中，错误通常会通过运行时抛出异常来传递，而Rust采用了一种完全不同的方式来处理错误。

Rust通过Result类型和Option类型来明确地处理错误和空值，Rust的错误处理是编译时检查的，必须显式处理Result或Option，如果忽略了错误处理，编译器会报错，确保错误处理不被遗漏。这种做法可以避免程序出现未处理的异常，增强程序的健壮性。

Result 类型：Rust使用Result类型来显式表示一个函数可能返回的两种状态：成功(Ok(T))或失败(Err(E))。这种方式要求函数调用者在编译时就明确考虑到错误的处理，而不是依赖于运行时的异常机制。

Result是一个枚举类型，定义如下：

enum Result {

    Ok(T),

    Err(E),

}

Option 类型：在处理可能的空值时，Rust使用Option类型，它表示一个值可能存在（Some(T)）或不存在（），避免了空指针异常的问题。

enum Option {

    Some(T),

    ,

}

在前端开发中，JavaScript和TypeScript也可以借鉴Rust的错误处理机制，明确地处理每一种错误情况，尤其是空值问题，没有一个前端开发能躲过 undefined 的摧残。

高性能设计

1. 零成本抽象

零成本抽象是指使用高级编程语言的抽象（如函数式编程的高阶函数、泛型、闭包等）时，不会引入额外的性能开销或运行时成本。换句话说，编写高抽象层的代码并不会影响程序的性能，编译器能够将抽象代码转化为与低级代码相同的高效机器码。

在 Rust 中，“零成本抽象”特别重要，因为 Rust 旨在提供与 C 和 C++ 等低级语言相似的性能，同时保持高层次的代码抽象和安全性。通过静态分析和优化，Rust 能够在编译时消除大多数抽象层的开销。

零成本抽象的三个原则：

• 没有全局成本（No global cost）： 一个零成本抽象不应该对不使用该功能的程序的性能产生负面影响。

  换句话说，零成本抽象应该只在使用时产生影响，在未使用时不会引入任何额外的开销。

• 最佳性能（Optimal performance）： 一个零成本的抽象应该编译成相当于底层指令编写的最佳实现。意味着它在使用时会以尽可能接近底层代码的方式运行，即它的性能应当与手写的低级实现相当。

  可以理解为，如果你想要用rust抽象某个高级能力，那么抽象完成的性能不能比用更原始写法实现的性能差，如果你想要抽象前端框架，那么就不能比直接操作DOM的JS原生写法性能差。

• 改善开发者体验（Improves developer experience）： 抽象的意义在于提供新的工具，由底层组件组装而成，让开发者更容易写出他们想要的代码，提高开发效率和代码可读性。

举几个例子

1. Rust 的所有权系统（ownership system）和生命周期（lifetimes）。

当你写一个简单的程序，没有使用所有权系统的特性时，编译器会对这些特性进行优化，使得它们对程序的性能没有任何影响。只有当你使用这些特性时，编译器才会引入相关的检查和优化。

2. 迭代器（Iterators） Rust 的迭代器是一种高效的抽象

fn main() {

    let numbers = vec![1, 2, 3, 4, 5];

    let sum: i32 = numbers.iter().map(|x| x * 2).sum();

    println!("Sum: {}", sum);

}

在这个例子中，iter 返回一个迭代器，map 是一个高阶函数，它将一个闭包应用到每个元素。尽管你使用了高阶函数和迭代器，Rust 会在编译时优化这段代码，确保它与手写的 for 循环代码在性能上等效。

Rust 的迭代器通过惰性求值来避免不必要的中间计算。当你调用 .map() 和 .sum() 时，Rust 会合并这些操作为一个高效的迭代过程，不会在内存中创建不必要的临时集合，最终生成与手动实现同样高效的机器码。

而在JS中，几种高阶函数的使用则是有成本的，如map、foreach 等，在进行一些极端的数据量测试时，性能差异相比 for 循环就比较明显了，但是js引擎实际上也是做了很多的优化的，这点不用太过于担心，放心用就好了。

3. 泛型（Generics） Rust 中的泛型是一个典型的零成本抽象。

使用泛型时，Rust 在编译时会根据类型替换（monomorphization单态化）生成具体的代码，在运行时没有任何额外的开销。

fn add(a: T, b: T) -> T

where

    T: std::ops::Add
,

{

    a + b

}

在这个例子中，add 函数是一个泛型函数。Rust 编译器在编译时会为每种特定类型（例如 i32、f64 等）生成专门的机器码。

如果你调用 add(1, 2)，Rust 会为 i32 类型生成专门的代码。同样，如果你调用 add(1.5, 2.5)，Rust 会为 f64 类型生成专门的代码。泛型不会引入运行时的性能损失。编译后的代码与手写的具体类型版本在性能上是等价的。

4. 错误处理

包括Rust的错误处理，由于Rust不使用异常机制，程序的控制流更加清晰，避免了异常捕获时的运行时性能开销。

对前端的启示

• 抽象高级能力提升开发效率和体验： 前端框架（如 React 和 Vue）、TypeScript等都是属于抽象的高级能力。例如，React 的优化算法通过虚拟 DOM 的比对、最小化 DOM 更新，已实现类似的零成本抽象。除此之外还有很多事可以做。
• 优化代码：减少抽象代码中不必要的计算，必要时惰性引入（前端叫懒加载）或计算，减少对不相关部分的隐形影响（前端叫副作用），利用好模块化开发和treeshaking等。
• WebAssembly (Wasm)： Rust 本身可以编译为 WebAssembly，这为前端性能优化开辟了新天地。借鉴 Rust 的这一特点，前端可以通过将性能瓶颈部分的代码（如图像处理、数据加密等）使用 Rust 编写并编译为 WebAssembly 运行，从而提升性能。

总结

社区很多人并不看好Rust甚至很激进地开喷，人确实是会有自己的舒适区的，当用熟了一样语言后，便不那么容易接受某一个自己不熟悉的语言更好，但是，尝试走出舒适区，真正地去接触Rust，一定会也能够感受到Rust的设计光辉。

要学习Rust，你需要先深入理解内存、堆栈、引用、变量作用域等这些其它高级语言往往不会深入接触的内容，Rust 会通过语法、编译器和 clippy 这些静态检查工具半帮助半强迫的让你成为更优秀的程序员，写出更好的代码。

Rust 程序只要能跑起来，那代码质量其实就是相当不错的，甚至不需要调试，能编译基本就没bug（当然是避免不了逻辑bug的）。正因为较高的质量下限，我们维护别人的代码时心智负担也比较小，能编译通过基本能保证不新增bug，把精力完全放在业务逻辑上就可以了。

而如果用javascript写程序，我们必须一边写一边调试，虽然写出能跑的程序极为简单，但要想没有bug，心智负担极高，js的程序员上限不封顶，但下限极低。而且review代码成本也很高，1000个人有1000种写法，review完改一改可能又不小心改出bug了。

JS对开发者要求较低，也是时代变了，条件好了，搁以前几百兆内存、单核cpu的时候，那时候的JS开发该有多痛苦啊。

社区流传着一个很奇怪的论调，“通过学习Rust，你能写出更好的xx语言的代码”。

学习Rust后，会潜移默化地影响你写其他语言代码时的思维方式，最直观的变化就是，对javascript中各类容易造成不安全不稳定的情况会更加敏感，所以，某种程度来看，Rust的价值可能并不在于用它写出多么优秀的代码，更重要的是它带给你的全面的方法论层面的提升。

我使用Rust做了比较丰富的尝试，包括用Rust写命令行工具、用Rust写 postcss 插件、用Rust写vite 插件、用Rust写WebAssembly在前端页面中使用，整体体验和效果还是非常棒的，WebAssembly的尝试可以查看文章Rust + wasm-pack + WebAssembly 实现Gitlab 代码统计，比JS快太多了，其他实践后面会陆续和大家分享，感兴趣的小伙伴可以关注收藏插个眼~

附：

Rust在前端领域的应用

• SWC: 基于 Rust 的前端构建工具，可以理解为 Rust 版本的 Babel，但是性能有 10 倍提升。目前被 Next.js、Deno , Rspack等使用。
• Tauri：Tauri 是目前最流行的 Electron 替代方案，通过使用 Rust 和 Webview2 成功解决了 Electron 的包体积大和内存占用高的问题。Atom 团队也是看到了 Tauri 的成功，才决定基于 Rust 去做 Zed 编辑器。
• Parcel2：零配置构建工具，特点是快速编译和不需要配置，和 Vite、Webpack等打包比起来更加简单，而且是基于 Rust 开发
• Biome: 旨在取代许多现有的 JavaScript 工具，集代码检测、打包、编译、测试等功能于一身。
• Rspack: 基于 Rust 的高性能 Web 构建工具, 对标 Webpack, 兼容大部分Webpack api
• Rocket: 可以帮助开发人员轻松编写安全的Web应用程序, 对标 Expressjs，性能卓越，具体参考 Web Frameworks Benchmark
• Yew : 使用 Rust 开发 h5 页面，支持类 jsx 的语法，和 React 类似开发前端网页，打包产物是 wasm，挺有趣。
• Napi-rs: 用 Rust 和 N-API 开发高性能 Node.js 扩展，可以替代之前用 C++ 开发的 Node.js 扩展，许多基于 Rust 语言开发的前端应用都结合这个库进行使用。
• Rolldown: 基于 Rust 的 Rollup 的替代品。
• 美国国防部准备征求一个把所有C代码翻译成Rust的软件。

作者：Pursue_LLL
来源：juejin.cn/post/7450021642377199643

一点都不夸张，就是这么惊悚！这么刺激！

裁员，退市

公司在2023年10月份，来了一次全球大裁员。整个过程从官宣，到结束，也就一周时间，不长。但后续影响的阴影，笼罩了2024年，整整一年。

对于被裁员的人，是残忍的。收拾一下，告别一段经历，一群好友，慢慢开启下一段旅程。当找到下一份工作后，往往很快就告别了这一段低落的情绪。很多人再联系时，问他们，当时的感觉如何，很有一些人给出的答复是：塞翁失马，焉知非福！因为公司给的补偿方案，都还是不错的，N+2, N+3的人，也是有的。

对于我们这些暂时还在的人，反而更加折磨。被阴影笼罩，看不到希望。熟悉的人不在了，组织结构也变了，未来充满了不确定性，焦虑一下子包围了过来，把你的世界塞得满满当当。内心世界一下子就沉寂，阴暗了起来。对于像我这样已经35+的人来说，实在是有些窒息。

不出所料，2024年又来了一波。不过和之前不一样的是，大家似乎淡定了许多。也许是柔软的心也长出了厚厚的茧，同样的打击，反而来得更轻松了些。

裁员的压力，其实来自于上市公司的财报要求。全球经济下行，市场不景气，作为上市公司，需要对全球投资人负责。而裁员是短期见效最快的方案。因为科技公司，最贵的其实就是人力成本。但很明显，这并不是长期最有效的方法。最终，公司做出了退市的决定。其实，综合来看，并不算坏。

协和

医院是离生死最近的地方，再次面对时，本觉得可以洒脱些，然而，不然！真的真的是再也不想去医院了！

35。是一个普通的数字。上有老，下有小。是对幸福的一种描述。

可把它们放在一起：35+，上有老，下有小。就变成了巨大的压力，还是喘不过气的那种。

这无形的压力，很容易让你自我怀疑，焦虑万分：

• 我真是一点用都没有，找工作都怕找不到。


• 我真是一点用都没有，不能给家人最好的医疗环境。在生命面前，尊严是那么的奢侈，活着就已经不错了。


• …

不想再列举更多，也不想制造焦虑。因为这玩意儿，现在到处都是，廉价的很。

副业

因为一直喜欢读源码，并且喜欢写一些源码阅读笔记 - 大家感兴趣也可以翻翻我之前的文章，多少和源码有一些关联。

前些年读到Hugo源码的时候，就有一个想法：反正源码也读了，笔记也记了，索性整理成一本书，名字我都想好了，就叫《深入理解Hugo之源码精读》。

读着读着，就有了一些困惑和想法，就跑去Hugo官方论坛上，寻求帮助，和验证想法。在2023年9月份的一天，发了一篇Hugo Headless CMS的贴子，问官方有没有计划，开发这样一个版本，就能把Hugo的服务，通过API暴露出来，那应用的场景一下子就能开阔起来。我也就可以用Hugo来帮我生成我书的站点，还能帮我生成书的电子版，我就可以发布到各大在线书商平台了。当然最后得到的答复是，并没有这样的计划。就都还好，坏就坏在，我一时抽抽，夸下海口。说我也是软件工程师，不行我来写一个吧...

后面找了半天，怎么删帖... 没找着...

想着咱也不能丢咱们中国程序员的脸啊，这要是丢起来，可丢到国外了。别人丢我不管，咱可不能够丢这个脸！一咬牙，一跺脚，还有什么好说的，那就撸一个吧。就这样，在阴暗的2024里，有一出，没一出的，慢慢的，还真给我实现了这么个PoC（验证了可行性）。

也是因为这个项目，后来演变成了我现在的SaaS服务 - Friday。一个可以将Markdown笔记，转换成Hugo站点的服务。目前还在持续稳步迭代中。自己也给自己立了个Flag，先干个20年再说，要走，就走个完整的商业闭环。

可能，这就是大家说的，当上帝给你关了一扇门的时候，也会给你开一扇窗。正因为每天有坚持去看看，去写写，做一些具体的事情，不让自己有太多时间胡思乱想，反而也就没那么焦虑了！# 剑来

最近，国漫《剑来》特别火，火得理所当然，火得恰逢其时！

特别能理解，大家为什么能对齐先生，敬爱有佳，热泪盈眶。在强大的生活面前，谁还不是陈平安，谁还不想有齐先生这样的引路人！

2025

最后，回过头来看：

还好，我还有工作。
还好，大家都好好的。
还好，能做自己喜欢的事情。

2025，欢迎你，再一起加把劲吧。

最后，把我喜欢的剑来台词送给大家：

愿大家，永远不要对生活失去希望！
岁岁平，岁岁安，岁岁平安！

写在圣诞

2024年12月25号

今年大部分时间都是在编码上和写文章上，但是也不知道自己都学到了啥，那就写篇文章来盘点一下目前的技术栈吧，也作为下一年的参考目标，方便知道每一年都学了些啥。

我的技术栈

首先我先来对整体的技术做一个简单的介绍吧，然后后面再对当前的一些技术进行细分吧。

React、Typescript、React Native、mysql、prisma、NestJs、Redis、前端工程化。

React

React 这个框架我花的时间应该是比较多的了，在校期间已经读了一遍源码了，对这些原理已经基本了解了。在随着技术的继续深入，今年毕业后又重新开始阅读了一遍源码，对之前的认知有了更深一步的了解。

也写了比较多跟 React 相关的文章，包括设计模式，原理，配套生态的使用等等都有一些涉及。

在状态管理方面，redux，zustand 我都用过，尤其在 Zustand 的使用上，我特别喜欢 Zustand，它使得我能够快速实现全局状态管理，同时避免了传统 Redux 中繁琐的样板代码，且性能更优。也对 Zustand 有比较深入的了解，也对其源码有过研究。

NextJs

Next.js 是一个基于 React 的现代 Web 开发框架，它为开发者提供了一系列强大的功能和工具，旨在优化应用的性能、提高开发效率，并简化部署流程。Next.js 支持多种渲染模式，包括服务器端渲染（SSR）、静态生成（SSG）和增量静态生成（ISR），使得开发者可以根据不同的需求选择合适的渲染方式，从而在提升页面加载速度的同时优化 SEO。

在路由管理方面，Next.js 采用了基于文件系统的路由机制，这意味着开发者只需通过创建文件和文件夹来自动生成页面路由，无需手动配置。这种约定优于配置的方式让路由管理变得直观且高效。此外，Next.js 提供了动态路由支持，使得开发者可以轻松实现复杂的 URL 结构和参数化路径。

Next.js 还内置了 API 路由，允许开发者在同一个项目中编写后端 API，而无需独立配置服务器。通过这种方式，前后端开发可以在同一个代码库中协作，大大简化了全栈开发流程。同时，Next.js 对 TypeScript 提供了原生支持，帮助开发者提高代码的可维护性和可靠性。

Typescript

今年所有的项目都是在用 ts 写了，真的要频繁修改的项目就知道用 ts 好处了，有时候用 js 写的函数修改了都不知道怎么回事，而用了 ts 之后，哪里引用到的都报红了，修改真的非常方便。

今年花了一点时间深入学习了一下 Ts 类型，对一些高级类型以及其实现原理也基本知道了，明年还是多花点时间在类型体操上，除了算法之外，感觉类型体操也可以算得上是前端程序员的内功心法了。

React Native

不得不说，React Native 不愧是接活神器啊，刚学完之后就来了个安卓和 ios 的私活，虽然没有谈成。

React Native 和 Expo 是构建跨平台移动应用的两大热门工具，它们都基于 React，但在功能、开发体验和配置方式上存在一些差异。React Native 是一个开放源代码的框架，允许开发者使用 JavaScript 和 React 来构建 iOS 和 Android 原生应用。Expo 则是一个构建在 React Native 之上的开发平台，它提供了一套工具和服务，旨在简化 React Native 开发过程。

React Native 的核心优势在于其高效的跨平台开发能力。通过使用 React 语法和组件，开发者能够一次编写应用的 UI 和逻辑，然后部署到 iOS 和 Android 平台。React Native 提供了对原生模块的访问，使开发者能够使用原生 API 来扩展应用的功能，确保性能和用户体验能够接近原生应用。

Expo 在此基础上进一步简化了开发流程。作为一个开发工具，Expo 提供了许多内置的 API 和组件，使得开发者无需在项目中进行繁琐的原生模块配置，就能够快速实现设备的硬件访问功能（如摄像头、位置、推送通知等）。Expo 还内置了一个开发客户端，使得开发者可以实时预览应用，无需每次都进行完整的构建和部署。

另外，Expo 提供了一个完全托管的构建服务，开发者只需将应用推送到 Expo 服务器，Expo 就会自动处理 iOS 和 Android 应用的构建和发布。这大大简化了应用的构建和发布流程，尤其适合不想处理复杂原生配置的开发者。

然而，React Native 和 Expo 也有各自的局限性。React Native 提供更大的灵活性和自由度，开发者可以更自由地集成原生代码或使用第三方原生库，但这也意味着需要更多的配置和维护。Expo 则封装了很多功能，简化了开发，但在需要使用某些特定原生功能时，开发者可能需要“弹出”Expo 的托管环境，进行额外的原生开发。

样式方案的话我使用的是 twrnc，大部分组件都是手撸，因为有 cursor 和 chatgpt 的加持，开发效果还是杠杠的。

rn 原理也争取明年能多花点时间去研究研究，不然对着盲盒开发还是不好玩。

Nestjs

NestJs 的话没啥好说的，之前也都写过很多篇文章了，感兴趣的可以直接观看：

• 面试官：为什么选择学习 Nestjs，而不是 Express？🧐🧐🧐


• NestJS 的生命周期钩子以及它们在不同阶段的都适合做什么？

对 Nodejs 的底层也有了比较深的理解了：

• 探究 CPU 密集型与 IO 密集型任务：提升对 Node.js 中 libuv 库的理解

Prisma & mysql

Prisma 是一个现代化的 ORM（对象关系映射）工具，旨在简化数据库操作并提高开发效率。它支持 MySQL 等关系型数据库，并为 Node.js 提供了类型安全的数据库客户端。在 NestJS 中使用 Prisma，可以让开发者轻松定义数据库模型，并通过自动生成的 Prisma Client 执行类型安全的查询操作。与 MySQL 配合时，Prisma 提供了一种简单、直观的方式来操作数据库，而无需手动编写复杂的 SQL 查询。

Prisma 的核心优势在于其强大的类型安全功能，所有的数据库操作都能通过 Prisma Client 提供的自动生成的类型来进行，这大大减少了代码中的错误，提升了开发的效率。它还包含数据库迁移工具 Prisma Migrate，能够帮助开发者方便地管理数据库结构的变化。此外，Prisma Client 的查询 API 具有很好的性能，能够高效地执行复杂的数据库查询，支持包括关系查询、聚合查询等高级功能。

与传统的 ORM 相比，Prisma 使得数据库交互更加简洁且高效，减少了配置和手动操作的复杂性，特别适合在 NestJS 项目中使用，能够与 NestJS 提供的依赖注入和模块化架构很好地结合，提升整体开发体验。

Redis

Redis 和 mysql 都仅仅是会用的阶段，目前都是直接在 NestJs 项目中使用，都是已经封装好了的，直接传参调用就好了：

import { Injectable, Inject, OnModuleDestroy, Logger } from "@nestjs/common";

import Redis, { ClientContext, Result } from "ioredis";



import { ObjectType } from "../types";



import { isObject } from "@/utils";



@Injectable()

export class RedisService implements OnModuleDestroy {

  private readonly logger = new Logger(RedisService.name);



  constructor(@Inject("REDIS_CLIENT") private readonly redisClient: Redis) {}



  onModuleDestroy(): void {

    this.redisClient.disconnect();

  }



  /**

   * @Description: 设置值到redis中

   * @param {string} key

   * @param {any} value

   * @return {*}

   */

  public async set(

    key: string,

    value: unknown,

    second?: number

  ): Promise<Result<"OK", ClientContext> | null> {

    try {

      const formattedValue = isObject(value)

        ? JSON.stringify(value)

        : String(value);



      if (!second) {

        return await this.redisClient.set(key, formattedValue);

      } else {

        return await this.redisClient.set(key, formattedValue, "EX", second);

      }

    } catch (error) {

      this.logger.error(`Error setting key ${key} in Redis`, error);



      return null;

    }

  }



  /**

   * @Description: 获取redis缓存中的值

   * @param key {String}

   */

  public async get(key: string): Promise<string | null> {

    try {

      const data = await this.redisClient.get(key);



      return data ? data : null;

    } catch (error) {

      this.logger.error(`Error getting key ${key} from Redis`, error);



      return null;

    }

  }



  /**

   * @Description: 设置自动 +1

   * @param {string} key

   * @return {*}

   */

  public async incr(

    key: string

  ): Promise<Result<number, ClientContext> | null> {

    try {

      return await this.redisClient.incr(key);

    } catch (error) {

      this.logger.error(`Error incrementing key ${key} in Redis`, error);



      return null;

    }

  }



  /**

   * @Description: 删除redis缓存数据

   * @param {string} key

   * @return {*}

   */

  public async del(key: string): Promise<Result<number, ClientContext> | null> {

    try {

      return await this.redisClient.del(key);

    } catch (error) {

      this.logger.error(`Error deleting key ${key} from Redis`, error);



      return null;

    }

  }



  /**

   * @Description: 设置hash结构

   * @param {string} key

   * @param {ObjectType} field

   * @return {*}

   */

  public async hset(

    key: string,

    field: ObjectType

  ): Promise<Result<number, ClientContext> | null> {

    try {

      return await this.redisClient.hset(key, field);

    } catch (error) {

      this.logger.error(`Error setting hash for key ${key} in Redis`, error);



      return null;

    }

  }



  /**

   * @Description: 获取单个hash值

   * @param {string} key

   * @param {string} field

   * @return {*}

   */

  public async hget(key: string, field: string): Promise<string | null> {

    try {

      return await this.redisClient.hget(key, field);

    } catch (error) {

      this.logger.error(

        `Error getting hash field ${field} from key ${key} in Redis`,

        error

      );



      return null;

    }

  }



  /**

   * @Description: 获取所有hash值

   * @param {string} key

   * @return {*}

   */

  public async hgetall(key: string): Promise<Record<string, string> | null> {

    try {

      return await this.redisClient.hgetall(key);

    } catch (error) {

      this.logger.error(

        `Error getting all hash fields from key ${key} in Redis`,

        error

      );



      return null;

    }

  }



  /**

   * @Description: 清空redis缓存

   * @return {*}

   */

  public async flushall(): Promise<Result<"OK", ClientContext> | null> {

    try {

      return await this.redisClient.flushall();

    } catch (error) {

      this.logger.error("Error flushing all Redis data", error);



      return null;

    }

  }



  /**

   * @Description: 保存离线通知

   * @param {string} userId

   * @param {any} notification

   */

  public async saveOfflineNotification(

    userId: string,

    notification: any

  ): Promise<void> {

    try {

      await this.redisClient.lpush(

        `offline_notifications:${userId}`,

        JSON.stringify(notification)

      );

    } catch (error) {

      this.logger.error(

        `Error saving offline notification for user ${userId}`,

        error

      );

    }

  }



  /**

   * @Description: 获取离线通知

   * @param {string} userId

   * @return {*}

   */

  public async getOfflineNotifications(userId: string): Promise<any[]> {

    try {

      const notifications = await this.redisClient.lrange(

        `offline_notifications:${userId}`,

        0,

        -1

      );

      await this.redisClient.del(`offline_notifications:${userId}`);



      return notifications.map((notification) => JSON.parse(notification));

    } catch (error) {

      this.logger.error(

        `Error getting offline notifications for user ${userId}`,

        error

      );



      return [];

    }

  }



  /**

   * 获取指定 key 的剩余生存时间

   * @param key Redis key

   * @returns 剩余生存时间（秒）

   */

  public async getTTL(key: string): Promise<number> {

    return await this.redisClient.ttl(key);

  }

}

前端工程化

前端工程化这块花了很多信息在 eslint、prettier、husky、commitlint、github action 上，现在很多项目都是直接复制之前写好的过来就直接用。

后续应该是投入更多的时间在性能优化、埋点、自动化部署上了，如果有机会的也去研究一下 k8s 了。

全栈性价比最高的一套技术

最近刷到一个帖子，讲到了

我目前也算是一个小全栈了吧，我也来分享一下我的技术吧：

剩下的描述也是和他下面那句话一样了（毕业后对技术态度的转变就是什么能让我投入最小，让我最快赚到钱的就是好技术）

总结

学无止境，任重道远。

英伟达

据风险投资人 Ruben D 透露：芯片巨头英伟达 78% 的员工已成为百万美元富翁，有一半人的净资产甚至达到 2500 万美元（约合人民币 1.83 亿元）。

英伟达的薪资很高，但光靠现金薪资不足让一半人资产过亿，这里面的主要原因，是英伟达 🚀 一般的涨幅，在过去五年翻了 20 倍。

英伟达作为"卖铲子"的人，总能精准踩中每个风口。

工业设计软件、3A游戏、虚拟货币、AI，带来了海量订单的同时，也把"濒死"的英伟达一度拉到「全球市值第一」的位置。

要知道，如今让全球科技公司都"高攀不起"的英伟达 CEO 黄仁勋，十年前还只能蹭刚起步的小米发布会来推销芯片。

当年，雷军还不是现在的"雷神"，小米手机也才出到第三代。但即使是这般初创品牌的客户，也足以让黄仁勋毕恭毕敬。

十年河东十年河西，如今英伟达的市值，接近 50 个小米，不少有着股权激励的员工，身家也得以水涨船高。

这几年行情不景气，网上晒工资的人少了许多（或被限流），但仍然找到了一份 2021 年英伟达员工收入的资料：

该员工在 2021 年底共有 3 笔收入：股权激励 900W+、全年一次性奖金 16W+，月工资 17W+。

知道英伟达员工收入高，但却是我想象不到的高 🤣🤣🤣

而且，这还是 2021 年的英伟达，当时一股英伟达 30 不到，如今 130+（涨幅 433%），这两年的股权激励会去到多少，我不敢想 🤣🤣🤣

但巨额财富背后是高强度的工作，据英伟达员工爆料，他们基本每周工作 7 天，加班到凌晨 2 点也是常态，还要面临密集的会议安排和严格的时间管理要求，大家几乎没有多少时间陪伴家人，甚至开始考虑"半退休"状态，以缓解工作带来的负面影响。

对此，你怎么看？说实话，你是不是也想体验几年加班到 2 点的日子？欢迎评论区交流。

...

回归主题。

来一道「HOT 100」级别算法题。

题目描述

平台：LeetCode

题号：450

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

• 首先找到需要删除的节点；


• 如果找到了，删除它。

示例 1:

输入：root = [5,3,6,2,4,null,7], key = 3



输出：[5,4,6,2,null,null,7]



解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。

一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。

另一个正确答案是 [5,2,6,null,4,null,7]。

示例 2:

输入: root = [5,3,6,2,4,null,7], key = 0



输出: [5,3,6,2,4,null,7]



解释: 二叉树不包含值为 0 的节点

示例 3:

输入: root = [], key = 0



输出: []

提示:

• 节点数的范围 $[0, 10^4]$


• $-10^5 <= Node.val <= 10^5$


• 节点值唯一


• root 是合法的二叉搜索树


• $-10^5 <= key <= 10^5$

进阶： 要求算法时间复杂度为 $O(h)$，$h$ 为树的高度。

递归

利用题目本身的函数签名的含义，也就是「在以 root 为根的子树中，删除值为 key 的节点，并返回删除节点后的树的根节点」，我们可以用「递归」来做。

起始先对边界情况进行处理，当 root 为空（可能起始传入的 root 为空，也可能是递归过程中没有找到值为 key 的节点时，导致的 root 为空），我们无须进行任何删除，直接返回 null 即可。

根据当前 root.val 与 key 的大小关系，进行分情况讨论：

Java 代码（P1）：

class Solution {

    public TreeNode deleteNode(TreeNode root, int key) {

        if (root == null) return null;

        if (root.val == key) {

            if (root.left == null) return root.right;

            if (root.right == null) return root.left;

            TreeNode t = root.left;

            while (t.right != null) t = t.right;

            t.right = root.right;

            return root.left;

        } else if (root.val < key) root.right = deleteNode(root.right, key);

        else root.left = deleteNode(root.left, key);

        return root;

    }

}

Java 代码（P2）：

class Solution {

    public TreeNode deleteNode(TreeNode root, int key) {

        if (root == null) return null;

        if (root.val == key) {

            if (root.left == null) return root.right;

            if (root.right == null) return root.left;

            TreeNode t = root.right;

            while (t.left != null) t = t.left;

            t.left = root.left;

            return root.right;

        } else if (root.val < key) root.right = deleteNode(root.right, key);

        else root.left = deleteNode(root.left, key);

        return root;

    }

}

C++ 代码（P1）：

class Solution {

public:

    TreeNode* deleteNode(TreeNode* root, int key) {

        if (!root) return nullptr;

        if (root->val == key) {

            if (!root->left) return root->right;

            if (!root->right) return root->left;

            TreeNode* t = root->left;

            while (t->right) t = t->right;

            t->right = root->right;

            return root->left;

        } else if (root->val < key) {

            root->right = deleteNode(root->right, key);

        } else {

            root->left = deleteNode(root->left, key);

        }

        return root;

    }

};

Python 代码（P1）：

class Solution:

    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:

        if not root:

            return 

        if root.val == key:

            if not root.left:

                return root.right

            if not root.right:

                return root.left

            t = root.left

            while t.right:

                t = t.right

            t.right = root.right

            return root.left

        elif root.val < key:

            root.right = self.deleteNode(root.right, key)

        else:

            root.left = self.deleteNode(root.left, key)

        return root

TypeScript 代码（P1）：

function deleteNode(root: TreeNode | null, key: number): TreeNode | null {

    if (!root) return null;

    if (root.val === key) {

        if (!root.left) return root.right;

        if (!root.right) return root.left;

        let t: TreeNode | null = root.left;

        while (t!.right) t = t!.right;

        t!.right = root.right;

        return root.left;

    } else if (root.val < key) {

        root.right = deleteNode(root.right, key);

    } else {

        root.left = deleteNode(root.left, key);

    }

    return root;

};

• 时间复杂度：$O(h)$，其中 $h$ 为树的深度


• 空间复杂度：忽略递归带来的额外空间消耗，复杂度为 $O(1)$

你好呀，我是歪歪。

昨天支付宝那事儿你听说了吧？

网传支付宝 14:40-14:45 所有的支付订单都按国补减免了 20%。

从网上铺天盖地的截图来看，非常多类型的交易都被“减免了 20%”。

说实话，歪师傅纵横互联网多年，什么千奇百怪的事情没见过？

比如这种还带款有政府补贴的，我觉得还说得过去，毕竟有时候确实有政策扶持，你要强行往这个上面圆谎，遇到外行也是能糊弄过去的：

但是个人转账都能有政府补贴的，这个还真没见过：

还真是猪八戒吃人参果，第一遭。

又好比大姑娘坐花轿，头一回。

我第一反应甚至是：我靠，现在的诈骗的套路都玩得这么深吗？我甚至都一眼看不穿它。

针对支付宝这个“真百亿补贴”行为，很多网友纷纷猜测这波又是程序员干的。

有这种可能，但是我觉得还有另外一种可能，在这种可能性中，这个问题和程序员毫无关系。

我个人猜测这可能是一次运营配置事件。

我觉得是这样的。

根据官方信息，过两天，就是 1 月 20 日，国补就要正式开始了：

支付宝的程序员在这之前接到了一个国补相关的需求，需求可能是要求在创建支付订单的时候，根据订单对应的产品来判断该产品是否符合国补条件，从而决定是否进行对应的金额减免。

那么哪些产品符合国补条件，这个逻辑肯定不是写死在代码里面的。

应该是作为一个运营配置项，可做实时配置、灵活调整，而这个配置项又可能相对复杂。

比如同时可以配置支持 A 大类下的 B 小类产品、不支持 C 大类的 D 小类产品，类似这种条件组合吧。

具体的运营人员在做参数配置时，不知道出于什么原因，配置出了一个条件组合之后，这个组合的最终效果按照程序逻辑解析是所有订单都可以参与国补。

这种配置肯定是要一审二审，层层审批的。

但是巧了，审核人员就是没看出来这个配置是有问题的，给通过了。

然后就出现了这个“真百亿补贴”行为。

这种行为，换个场景就更好理解了。

就类似于营销发优惠券。

本来设计的营销活动是给指定客群的用户发一个满减的无门槛优惠券。

结果运营人员在选客群的时候操作失误，给所有的用户都发了优惠券。

你说这个场景，和程序员有什么关系？

本来就存在给所有的用户发优惠券的需求和场景，使用的人用错了，你怪我开发的时候为什么不想着拦截一下？

还有天理吗？

但是这个真实的场景又比优惠券惨烈的多，毕竟优惠券客户不一定真的去用，但是这次“补贴”是真金白银的给出去了呀。

而且还是直接给到了无数个 C 端用户，追都不好追。

哎，惨啊，真的惨。

我再强调一次啊，以上是我个人的猜测，没有任何依据。

我作为一个程序员，屁股当然得歪一下，当然是希望这个问题和程序员无关了。

只有苦一苦运营的兄弟了。（手动狗头

如果真的是因为程序员编码问题导致的，朋友，不管你看不看得到，挺住，没啥大不了的，我入行第一天就查过了，程序员因为非主观 BUG 导致公司重大损失的，不需要承担法律责任。

但是，话又说回来，这里面就没有程序员的事儿了吗？

肯定有呀！

分析数据范围，捞问题数据，做数据修复等等这些后续的事情，肯定还是程序员来做的。

昨天晚上一定有一波相关人员没睡觉，整晚整晚的都在想这个事情到底是什么了。

另外，我昨天还看到了这个短信：

我猜这个短信是假的，因为短信内容太过随意了。

简单来说，“BUG”这个词，就不应该出现在短信里面，不可能是官方用语。

你能确保收到短信的每个人都知道“BUG”是什么意思吗？

注意信息茧房的存在，你认为的常识不一定是每个人的常识。

我就在现实生活中遇到过不知道“BUG”是什么意思的，我还要解释一番。

另外，都说到短信了，顺便给大家分享一个小技巧。

这个截图暴露了短信发送方的前 8 位数字。

这 8 位数字就是短信号段，这里面是大有文章。

简单来说，106 短信码号码是由工信部或通信管理局颁发，接入移动、联通、电信三大基础运营商并进行统一管理，共分为1062、1063、1065、1066、1068 和 1069，用于不同的服务目的。

其中，1066、1068/1069 号段的短信需要企业在工信部进行申请，1062、1063 号段则是向各省通信管理局进行申请。

国家也有一个号段查询网站，前八位一输就知道这个短信是哪一家公司发的了。

比如上面截图中的 10680503：

nac.miit.gov.cn/#/notice/gx…

这个公司看起来和支付宝没有任何关系，这个也正常。你用真的支付宝发送的短信去查，查到的也不是支付宝，因为这只是对接的众多短信通道中的一个而已。

但是如果以后收到骚扰短信，可以按照这个去投诉，最终这个投诉会附带着一点点惩罚，到最初的短信发送方的。

一个小技巧，送给大家，祝大家春节前的倒数第二个周末愉快。

最后，不管和程序是否相关，保命箴言再背一次总是没错的：可监控、可灰度、可回滚。

---- 2025.01.17 01:22 更新 ----

上面的内容 16 号晚上就写好了，想着早上起来就发。 17 号凌晨被起来上厕所的时候看到官方声明了：

看起来确实是运营活动配置问题，看来歪师傅的猜测还是比较靠谱的。

看起来没有一个程序员在本次事件中受伤。

但是看起来又像是一个边界值的问题，可能存在程序校验不到位的情况。

然而这些都不重要了，重要的是我怎么开始起夜了？？？

一定是白天水喝多了，嗯，一定是这样的。

最后，欢迎关注公众号：why技术。好玩儿，来玩儿。

从到公司上班之后因为距离变远了，也不能像之前一样小毛驴上下班了。

所以通勤方案就变成了：

上班：



小毛驴 15min ----- 地铁 40min ----- 公交OR共享单车 12min + 步行 5min



下班：



公交 12min ----- 地铁 40min ----- 小毛驴 15min

通勤费用： 小毛驴一块钱充电可以开两天。地铁 + 公交 来回 12块。

这半年下来地铁已经坐够够了。🤦‍♂️ 有的时候实在是不想坐了。就动了开小毛驴的心思。

但是百度地图看从家到公司的距离是 34km。之前公司到家的百度距离是 18km，其实等于翻翻了。

而且之前的路况很好么有什么红绿灯而且路上的人也很少。所以基本没有什么时间浪费18km大概半个小时左右就到了。

本来是想直接买一个新电瓶车来通勤用的，但是碰到那个什么新国标要去考摩托车驾-照就耽搁了。

然后正好这两天天气还行不冷不热。我就想要买今天就开小毛驴去公司得了。正好熟悉下路况。

早上还是按照正常出门的时间 7.25 出门。然后按照百度导航直接走。因为第一次开，路况不熟悉。按照百度走的路线全是走的人多的地方。早上正好又是上班高峰期。非机动车道上全部都是人。而且路上的红绿灯贼多。基本遇到一个红绿灯就要停下来。

前半程车的电量充足速度可以很快，但是路况太差了。路上人太多，而且有占着超车道一直慢悠悠的。开的血压飙升。所以就导致速度起不来。然后到了后半程的时候全是大路。而且没有什么红绿灯也没啥人，但是电量下去了，速度又上不来。脑壳痛!

最后到公司楼下的时候是 8.42。百度地图显示 34km 需要 2 小时零五分。实际电瓶车里程显示 40km ，耗时一小时 20 分。

其实 1 小时开车的时间是感知不到的。前半程因为都是人所以精神高度集中。

另外路上的风景也是不错的。可以走之前没有走到的地方。可以愉快的画图。

下面早上的时候拍的，因为第一次。怕时间不够。就随便瞎拍了两张记录了一下。

等会晚上回去的时候看看能不能走另外一条路会不会快点。

最近，和往常一样在刷 GitHub Trending 热榜时，突然看到又一个开源项目冲上了 Trending 榜单。

一天之内就狂揽数千 star，仅仅用两三天时间，star 数就迅速破万，增长曲线都快干垂直了！

出于好奇，点进去看了看。

好家伙，这居然还是小米开源的项目，相信不少小伙伴也刷到了。

这个项目名为：ha_xiaomi_home。

全称：Xiaomi Home Integration for Home Assistant。

原来这就是小米开源的 Home Assistant 米家集成，一个由小米官方提供支持的 Home Assistant 集成组件，它可以让用户在 Home Assistant 平台中使用和管理小米 IoT 智能设备。

Home Assistant 大家知道，这是一款开源的家庭自动化智能家居平台，以其开放性和兼容性著称，其允许用户将家中的智能设备集成到一个统一的系统中进行管理和控制，同时支持多种协议和平台。

通过 Home Assistant，用户可以轻松地实现智能家居的自动化控制，如智能灯光、智能安防、智能温控等，所以是不少智能家居爱好者的选择。

另外通过安装集成（Integration），用户可以在 Home Assistant 上实现家居设备的自动化场景创建，并且还提供了丰富的自定义功能，所以一直比较受 DIY 爱好者们的喜爱。

大家知道，小米在智能家居领域的战略布局一直还挺大的，IoT 平台的连接设备更是数以亿记，大到各种家电、电器，小到各种摄像头、灯光、开关、传感器，产品面铺得非常广。

那这次小米开源的这个所谓的米家集成组件，讲白了就是给 Home Assistant 提供官方角度的支持。

而这对于很多喜欢折腾智能家居或者 IoT 物联网设备的小伙伴来说，无疑也算是一个不错的消息。

ha_xiaomi_home 的安装方法有好几种，包括直接 clone 安装，借助 HACS 安装，或者通过 Samba 或 FTPS 来手动安装等。

但是官方是推荐直接使用 git clone 命令来下载并安装。

cd config

git clone https://github.com/XiaoMi/ha_xiaomi_home.git

cd ha_xiaomi_home

./install.sh /config

原因是，这样一来当用户想要更新至特定版本时，只需要切换相应 Tag 即可，这样会比较方便。

比如，想要更新米家集成版本至 v1.0.0，只需要如下操作即可。

cd config/ha_xiaomi_home

git checkout v1.0.0

./install.sh /config

安装完成之后就可以去 Home Assistant 的设置里面去添加集成了，然后使用小米账号登录即可。

其实在这次小米官方推出 Home Assistant 米家集成之前，市面上也有一些第三方的米家设备集成，但是多多少少会有一些不完美的地方，典型的比如设备状态响应延时，所以导致体验并不是最佳。

与这些第三方集成相比，小米这次新推出的官方米家集成无论是性能还是安全性都可以更期待一下。

如官方所言，Home Assistant 米家集成提供了官方的 OAuth 2.0 登录方式，并不会在 Home Assistant 中保存用户的账号密码，同时账号密码也不再需提供给第三方，因此也就避免了账号密码泄露的风险。

但是这里面仍然有一个问题需要注意，项目官方也说得很明确：虽说 Home Assistant 米家集成提供了 OAuth 的登录方式，但由于 Home Assistant 平台的限制，登录成功后，用户的小米用户信息（包括设备信息、证书、 token 等）会明文保存在 Home Assistant 的配置文件中。因此用户需要保管好自己的 Home Assistant 配置文件，确保不要泄露。

这个项目开源之后，在网上还是相当受欢迎的，当然讨论的声音也有很多。
小米作为一家商业公司，既然专门搞了这样一个开源项目来做 HA 米家集成，这对于他们来说不管是商业还是产品，肯定都是有利的。

不过话说回来，有了这样一个由官方推出的开源集成组件，不论是用户体验还是可玩性都会有所提升，这对于用户来说也未尝不是一件好事。

那关于这次小米官方开源的 Home Assistant 米家集成项目，大家怎么看呢？

前言

2024年陆陆续续听到老东家几个同事被裁的消息，倒有些后悔2023年自己主动提出离职，结束北漂回老家。算了下，损失个小几十万。

2024年6月份来了一场彻彻底底的自我反思，找不到明确目标，于是稀里糊涂定了两个计划：

• 每天读书，围绕技术、文学、创业类。


• 粉丝数涨到150。

工作方面，实话说呆的有些憋屈，但也算尽职尽责，年底拿了个优秀员工，满足了个人虚荣心。

创业必定是成功率低、过程艰巨的事，有这方面想法的小伙伴可+V微信进群相互取暖：wxiaomimap。

2024年总结

掘金涨粉情况

说到定涨粉目标，有些低估自己的实力。当时只有30个粉丝，对标了下掘金的优秀创作者，感觉自己和他们差距挺大，于是定了个保守的目标：达到150个粉。

中间调整了两次目标，分别是300、500，最终赶在12月前把年度目标给完成了。写作过程中也得到官方、掘友、编辑社、三方的认可。

官方的：

掘友的：

三方的：

关于读书

为什么读书，看文学类书主要和老板吹牛用，看技术、创业类书算是个人储备。

截止目前已连续阅读209天，读完33本，做了3432条笔记。读书时间集中在上下班路上以及周末。

如果像读小说一样把书读完，作用真心不大，所以读完的书强迫自己写读后感，到目前已为27本书写过读后感。

2025年：两娃的爸，创业筹备

2024年12月初完成了年度目标，但也没闲着，开始着手考虑2025年我能干什么。为什么是创业筹备？基于两个原因。

按目前的大环境，工作的尽头就是被裁。前两天看到"前端欧阳"也面临失业(就他的实力，值得一个好工作)，当公司遇到困难，技术牛人也仅是牛马。

卷孩子不如卷自己！现在的小孩压力太大，1月11日刚放寒假，1月11日-1月17日早上8:30-12:00，下午13:30-15：30已经排好了兴趣班、补习。有人说小孩的压力还不是大人给的，我只能说懂得都懂。所以，为了孩子轻松些，还是卷自己吧。

基于以上两个原因，经过12月份的深思熟虑，决定2025年开始个人产品筹备，把职业生涯紧紧把握在自己手里。目前有哪些进展？

产品定位、市场调研

作为技术人员，一定要分清开源项目和商业产品的区别。开源项目大多是自我价值体现，一个优秀的开源项目能在同圈提升个人影响力。一个商业产品的目的是盈利，当没考虑清楚产品最终能落地的受益群体，不能盲目启动。十个创业九个跨，有人会说即使失败，也会从失败中学习，但你付出的时间成本、金钱成本远大于你从失败中收获的经验。

目前，一边读创业类书籍学习前人经验，一边调研竞品市场。

已读完的创业类书籍：《财富自由从0到1》、《幕后产品》、《新手开公司》、《精益创业》。

之前有考虑做一款地图产品，当了解了市场同类产品exping，无法商业变现，2024年11月刚停止服务，我也就放弃做同类产品。

当前是个人IP的互联网时代，强如企业家雷军、周鸿祎、余承东、何小鹏等都得亲自下场运营各大视频号。甚至部分个人IP都能耗动一个公司的存亡。 微信公众号、微信视频号、抖音、小红书、快手、B站都是最小成本的产品运营渠道。

个人产品进展

目前已确认产品面向的差异化市场还存在比较大的空间。产品前期主要 to C，后期可根据影响力扩展to B。

团队组建过程也是检验产品能否落地的手段之一，如果没人愿意和你一起实施，那你得思考产品是否还值得继续做下去！差不多每个人都聊了2小时起步， 目前已有了可实施产品的初期团队，共5个人，包含前端、后端、UI、产品。

申请个人商标，当产品名称确认清楚了就得尽早申请商标。这不前段时间小米的Yu 7商标闹了乌龙，被别人占用。商标申请得有个人营业执照或企业执照。

创建了运营产品的公众号、视频号，虽然还没发什么内容，但得先想到运营手段。全网同名：绘个球。

一个人走的快，一群人走的更远

2025年还得靠公司养活，在公司工作得干好。余下的时间并不多，产品、运营、技术、计划一个不落地都得考虑，一个产品能面向市场并开花结果，得有一群志同道合的伙伴一起使劲，2025在路上。。。。。。

产品开发在技术方面也会面临很多挑战，2025年文章输出集中在产品实现的技术挑战方面。

创业必定是成功率低、过程艰巨的事，有这方面想法的小伙伴可加我微信进群聊：wxiaomimap。

我是前端下饭菜，原创不易，各位看官动动手，帮忙关注、点赞、收藏、评论！

7 年前，我被培训机构 8k 高薪的幌子，骗着带款了 2w 块钱，签完合同的后，我才觉察到自己被骗了。

但是 Java 好像挺有意思的，我学得不错，班里有 40 多个人，最后只有 3 个人找到了工作，我就是其中之一。

于是我入行了 Java，我的第一份工作在去哪儿，很感谢当年的领导给我面试机会，要知道当时我只有高中文凭，HR 反复确认要我来面试吗？我的领导说来试试吧。

为了那次面试，我推掉了所有其他面试，我对自己说一定要拿下这个 offer，在去面试的地铁上，我还在准备，我甚至准备了万一别人不要我，我可以做些什么来挽回。

后来面试通过了。

我珍惜这来之不易的机会，努力奋斗，晚上 10 点多下班是常态，有次冬天加到 12 点，我走在路上看着满大街的雪，反射出白光照向天空，亮亮的一点也不像晚上，我也一点都不冷。

那真是段美好的回忆，但是一年半后，压力太大，我主动提出了离职。

我跳槽到一家私企，工资翻了一倍，而且工作内容相比较之前，轻松的要死。除了基础代码开发，我顺手把服务器、Jenkins 部署、发布脚本、gitlab、redis、测试和线上环境全搭了。

但公司业务没做起来，部门解散了。

我接着找工作，年底通过了 thoughworks 的面试，和 HR 约定好了开年就发 offer 去上班，接到电话的时候我在图书馆，真是开心死了，现在回忆起来也不经咧开了嘴，爷也是能去外企的人了哈哈。

但是造化弄人，过年期间疫情来了，我的 offer 没了。

后来找到了一家创业公司，我和 boss 聊的很合拍，入职后工作了一年多，他和福禄建立了深度合作，把我带了过去。

截止至今，我在福禄工作了四年多，现在我面临着和 6 年前一样的问题，我对工作有了不一样的看法。

人们把工作当成一个赚钱的方式，出卖自己的时间换取经济价值。当然这没有问题，但我相信我的 boss，我感谢他知遇之恩，这些年我一直尽力多做一些事情。

只不过我的能力和认知，没有到那个境界，做的是很多，但也做错了很多，方法不对，成长也不够。

直到最近一次线上事故，我被击垮了。这是我五年来，第一次滋生离职的念头。

放下了对 boss “报恩” 的想法，我开始再次思考，工作的意义、生活的意义、人生的意义。

这不是我第一次思考，虽然我到现在也没找到答案。

曾经我的生活一眼望得到头，事业上，35 岁前努力工作存钱，35 后有了一定风险，但应该还能再工作几年，只要任劳任怨，万一真没公司要，再想别的出路，什么出路，我也不知道，生命总会找到出路。

生活中，20 多岁结婚，过几年生个娃，然后赚钱养家，天天为孩子奔波，把孩子养大，尽量给他好的环境。

身边的同事、朋友都是这样的，他们也劝我这样，不要想那些有的没的。

但是我忍不住会想，那我呢？我把时间给了工作、家庭、孩子，我在哪里？

有多少人真的了解自己？我不了解，我不知道自己喜欢什么，擅长什么，未来想做什么，想成为什么样的人。

我只是随大流，别人做什么，我也跟着做。买房、买车、结婚、生娃，这些人生重要节点，我做的那么随意。

痛苦让我成长，让我反思。如果回到 10 年前，我会对那时的自己这么说。

人生的重大决策，一定要仔细思考

买房

不要买房，不要背 30 年带款。这会把人压死，让人不敢尝试，不敢探索，失去勇气。

有个房贷压在头顶，那种窒息感和压力，无时无刻不在消耗自己。

做任何经济上有关的决策，都会忍不住想到我还有房贷呢。

会错失很多机会，也会让操作变形。

买车

车也是个消耗品，买车要钱，养车也要钱。停车费、过路费、油费、保养、车险，每年怎么也要大几千上万。

如果车带来的价值不如车的支出，我建议直接把房子租在公司附近，走路上下班，平时有事打车。

结婚

我之前从未思考过结婚意味着什么，也是随大流的和一个女孩子谈恋爱，谈了几年差不多了，就结婚了。

结婚意味着，和一个人共度余生。

这种影响未来几十年的决定，我甚至没认真思考过一天。

所以请一定要认真思考，可能即使我怎么说也不能理解，第一次结婚都没什么经验。

具体点说就是不要因为父母催婚去结婚；想清楚两个人之间的大方向上能不能统一；想清楚自己想从婚姻中获得什么，能提供什么价值；花点钱去找专业的人咨询，别找自己身边的案例，和自身一个 level 的人不会有很深的思考；不要因为牛牛充血一时冲动。

好在我运气不错，老婆挺好的，我们没什么摩擦，除了她不是很理解我的一些想法，剩下就是我跟个唐僧一样喜欢逼逼叨。

生娃

生娃那简直是比结婚更要命的存在。

以我现在的认知，我真的不理解为什么要生娃。

知乎上各种各样的答案，没一个能说服我，什么觉得生活没意思造个娃；夫妻生活不和谐靠娃调节等。

如果觉得生活没意思，夫妻没感情，那是自己的问题，生娃只是转移了问题，而不是解决问题。

所以我的态度是在没有想清楚为什么生娃之前，不生娃。

买车、买房、生娃，就算决定要做，我也建议晚点做，趁年轻先把事业打顺。

事业

刚进社会，懵懵懂懂啥都不知道，哪家公司给的钱多就去哪家。这是对的。

然后努力工作，不要躺平，多赚点钱，多存点钱。

工作了几年以后，兜里有点积蓄了，能覆盖两三年的支出，就要开始思考了。

这份工作有前途吗？我喜欢吗？对我个人有什么帮助？能学到什么知识？可不可以试试别的工作？

选择什么工作，入什么行业。这也是影响未来几十年的决策。

我觉得不要把工作看成出卖时间换取收入，那样会觉得自己在给别人打工，在给别人做事，心很累，做的事也不咋地。

应该把工作看成能力训练场、大型实验基地、资源交换中心；通过工作提升自己能力，让自己更值钱，通过公司验证个人的方法，学习经验，整理方法论。

把技能和经验学到一定程度，就可以结合手头积累的资源，自己创业了。

以学会赚钱为目的，为自己打工。

现在新能源和 AI 是公认的有前景的行业，往这两个方向靠。

现在我处在有点积蓄，准备尝试新的方向，去和钱比较近的岗位，学习赚钱能力，为以后创业赚钱打打基础。

寻找人生意义

我想有钱了再思考这个问题，被生活压的喘不过气的人，天天为生活奔波，哪有时间想这些呢？

在没有找到答案前，认真生活，对自己负责。

空闲时间刷抖音，打游戏，到处玩，偶尔放松可以理解，一直这样不行，这不叫认真生活。

当然这不怪当事人，我之前也是那样的，下班和周末看直播，刷短视频，搞学习什么，不存在的。

直到近期的变故，我深入思考这些问题，到处找课找人学习，认知有了提升，做这些事变得理所当然。

这种转变就像之前是强迫自己每天必须写篇文章，做复盘写总结，用意志力坚持，很痛苦，坚持不了多久。

现在是就是想写了，有感悟，想找个地方记录，主动的写，认真的写。

希望我的经历可以给各位参考，尽快提升认知，趁年轻，还有机会。

不要等有了车贷房贷，还有娃，但被裁了，或还没被裁但被当牛做马使劲压榨，而自身却没了任何反抗资本，才幡然醒悟，那样太残忍了些。

加油，共勉。

xhs

这两天，一篇爆料《xhs 最高 50 个月年终奖》的帖子火了。

从帖子的内容来看：绩效 3.75 可以拿到 8 个月年终奖；绩效 4 可以拿到 20 个月的年终奖；绩效 5 可以拿到 20 个月年终奖，外加 30 个月的期权。

综合下来，今年 xhs 最高有 50 个月的年终奖，就这帖子，还是带有「xhs 职业认证」（至少通过了企业邮箱认证）的网友发的 🤣🤣🤣

看完后，我直接沉默了。

前几天才讲了 蔚来最高 1 个月年终奖，还划分出多个等级，今天就有「xhs 年终奖 8 个月起步，最高 50 个月」的新故事。

现在简中网的黑话越来越多，要不是资深冲浪选手，有时候都真分不清楚网友发的内容，是在描述事实，还是在反串黑。

一般对于这些"惊天"好消息，如果是真，那么各大 App 早就预定热搜，但事实上并没有。

再进一步，深入到「仅 xhs 员工可见的同事圈」里，发现并不是"普天同庆，一片热烈"的内部氛围，反而更像是维权集中地。

有真诚反问，上半年的高绩效奖励到底还有没有，什么时候通知：

还有距离期权归属（真正到手）还剩两个月，就被"关账号"走人的吐槽贴：

一圈看下来，离职的在吐槽、低绩效的在吐槽、高绩效的也在吐槽 🤣🤣🤣

然后再回想刚开始的「50 个月年终奖」，我释怀的笑了，感觉还是太保守了，毕竟通知了也不一定什么时候发放，发放了也不一定能熬到期权归属，应该直接喊它 100 个月。

对此，你怎么看？你司的年终奖多少个月起步？

...

回归主题。

来一道和「校招」相关的算法题。

题目描述

平台：LeetCode

题号：926

如果一个二进制字符串，是以一些 $0$（可能没有 $0$）后面跟着一些 $1$（也可能没有 $1$）的形式组成的，那么该字符串是单调递增的。

给你一个二进制字符串 s，你可以将任何 $0$ 翻转为 $1$ 或者将 $1$ 翻转为 $0$ 。

返回使 s 单调递增的最小翻转次数。

示例 1：

输入：s = "00110"



输出：1



解释：翻转最后一位得到 00111.

示例 2：

输入：s = "010110"



输出：2



解释：翻转得到 011111，或者是 000111。

示例 3：

输入：s = "00011000"



输出：2



解释：翻转得到 00000000。

提示：

• $1 <= s.length <= 10^5$


• s[i] 为 '0' 或 '1'

LIS 问题贪心解

根据题意，不难想到将原题进行等价转换：令 s 长度为 $n$，原问题等价于在 s 中找到最长不下降子序列，设其长度为 $ans$，那么对应的 $n - ans$ 即是答案。

由于数据范围为 $1e5$，因此我们需要使用 LIS 问题的贪心求解方式：使用 g 数组记录每个长度的最小结尾元素，即 g[len] = x 含义为长度为 $len$ 的最长不下降子序列的结尾元素为 $x$，然后在从前往后处理每个 $t = s[i]$ 时，由于是求解「最长不下降子序列」，等价于找「满足大于 $t$ 的最小下标」，这可以运用「二分」进行求解。

不了解 LIS 问题或者不清楚 LIS 问题贪心解法的同学可以看前置 🧀 : LCS 问题与 LIS 问题的相互关系，以及 LIS 问题的最优解证明，里面详细讲解了 LIS 贪心解的正确性证明，以及 LCS 和 LIS 在特定条件下存在的内在联系。

Java 代码：

class Solution {

    public int minFlipsMonoIncr(String s) {

        char[] cs = s.toCharArray();

        int n = cs.length, ans = 0;

        int[] g = new int[n + 10];

        Arrays.fill(g, n + 10);

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

            int t = s.charAt(i) - '0';

            int l = 1, r = i + 1;

            while (l < r) {

                int mid = l + r >> 1;

                if (g[mid] > t) r = mid;

                else l = mid + 1;

            }

            g[r] = t;

            ans = Math.max(ans, r);

        }

        return n - ans;

    }

}

C++ 代码：

class Solution {

public:

    int minFlipsMonoIncr(string s) {

        int n = s.length(), ans = 0;

        vector<int> g(n + 10, n + 10);

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

            int t = s[i] - '0';

            int l = 1, r = i + 1;

            while (l < r) {

                int mid = l + r >> 1;

                if (g[mid] > t) r = mid;

                else l = mid + 1;

            }

            g[r] = t;

            ans = max(ans, r);

        }

        return n - ans;

    }

};

Python 代码：

class Solution:

    def minFlipsMonoIncr(self, s: str) -> int:

        n, ans = len(s), 0

        g = [n + 10] * (n + 10)

        for i in range(n):

            t = int(s[i])

            l, r = 1, i + 1

            while l < r:

                mid = l + r >> 1

                if g[mid] > t:

                    r = mid

                else:

                    l = mid + 1

            g[r] = t

            ans = max(ans, r)

        return n - ans

TypeScript 代码：

function minFlipsMonoIncr(s: string): number {

    let n = s.length, ans = 0;

    const g = new Array(n + 10).fill(n + 10);

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

        const t = parseInt(s[i]);

        let l = 1, r = i + 1;

        while (l < r) {

            const mid = l + r >> 1;

            if (g[mid] > t) r = mid;

            else l = mid + 1;

        }

        g[r] = t;

        ans = Math.max(ans, r);

    }

    return n - ans;

};

• 时间复杂度：$O(n\log{n})$


• 空间复杂度：$O(n)$

前缀和 + 枚举

更进一步，利用 s 只存在 $0$ 和 $1$ 两种数值，我们知道最后的目标序列形如 000...000、000...111 或 111...111 的形式。

因此我们可以枚举目标序列的 $0$ 和 $1$ 分割点位置 $idx$（分割点是 $0$ 是 $1$ 都可以，不消耗改变次数）。

于是问题转换为：分割点 $idx$ 左边有多少个 $1$（目标序列中分割点左边均为 $0$，因此 $1$ 的个数为左边的改变次数），分割点 $idx$ 的右边有多少个 $0$（目标序列中分割点右边均为 $1$，因此 $0$ 的个数为右边的改变次数），两者之和即是分割点为 $idx$ 时的总变化次数，所有 $idx$ 的总变化次数最小值即是答案。

而求解某个点左边或者右边有多少 $1$ 和 $0$ 可通过「前缀和」进行优化。

Java 代码：

class Solution {

    public int minFlipsMonoIncr(String s) {

        char[] cs = s.toCharArray();

        int n = cs.length, ans = n;

        int[] sum = new int[n + 10];

        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (cs[i - 1] - '0');

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

            int l = sum[i - 1], r = (n - i) - (sum[n] - sum[i]);

            ans = Math.min(ans, l + r);

        }

        return ans;

    }

}

C++ 代码：

class Solution {

public:

    int minFlipsMonoIncr(string s) {

        int n = s.length(), ans = n;

        vector<int> sumv(n + 10, 0);

        for (int i = 1; i <= n; i++) sumv[i] = sumv[i - 1] + (s[i - 1] - '0');

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

            int l = sumv[i - 1], r = (n - i) - (sumv[n] - sumv[i]);

            ans = min(ans, l + r);

        }

        return ans;

    }

};

Python 代码：

class Solution:

    def minFlipsMonoIncr(self, s: str) -> int:

        n, ans = len(s), len(s)

        sumv = [0] * (n + 10)

        for i in range(1, n + 1):

            sumv[i] = sumv[i - 1] + int(s[i - 1])

        for i in range(1, n + 1):

            l, r = sumv[i - 1], (n - i) - (sumv[n] - sumv[i])

            ans = min(ans, l + r)

        return ans

TypeScript 代码：

function minFlipsMonoIncr(s: string): number {

    let n = s.length, ans = n;

    const sumv = new Array(n + 10).fill(0);

    for (let i = 1; i <= n; i++) sumv[i] = sumv[i - 1] + parseInt(s[i - 1]);

    for (let i = 1; i <= n; i++) {

        const l = sumv[i - 1], r = (n - i) - (sumv[n] - sumv[i]);

        ans = Math.min(ans, l + r);

    }

    return ans;

};

• 时间复杂度：$O(n)$


• 空间复杂度：$O(n)$

2024马上就要过去了，本命年呀，这一年真的太快太快了，发生了很多事情，记录一下，多年以后或许能够看到有一点点记录就足够了。

还记得2023年跨年的时候来北京跨年的，2024就真的到了北京工作，这一年算是集中发生了很多事情，比23年22年都精彩一些。

有一些错误的决定，也有一些正确的决定。总得来说差强人意，但是依旧悲观。

裸辞

上家公司是在上海，从本科毕业后就在这家公司工作，工作了两年吧，在这家公司认识了很多玩的很好很好的朋友，现在也时不时的会聚一下，群里总是会有各种话题
大家一起抱怨生活，一起玩乐，能在工作后认识这么要好的朋友实属幸运。

我们在上海的时候经常去唱歌，钓鱼，公园，晚上睡不着了在群里吆喝一声 喝点？ 下一分钟就到了酒桌上，大家很合得来，都是性情中人，有时候会喝的多一点，然后第二天都请假了哈哈哈。

大家经常约出去玩，我们去过宁波、苏州、乌镇、无锡、扬州等上海周边的城市玩了个遍，现在想想那时候确实挺开心的，大家单身的居多，都是没有什么羁绊，玩得很高兴，压力大了偶尔打打麻将，去酒吧喝喝酒，然后接着周一上班，妥妥打工人生活实录，就靠周末过日子呐

但是公司效益不好，开始陆续裁员，除了我之外都回去了老家所在地工作，之后在上海就不好玩了，没有朋友，也没有钱，在这家公司两年了没有涨过工资,工作也是没有什么乐趣，那时候离职的心到达了顶峰，得知公司今年也不会涨薪后，我选择了裸辞不要裸辞！辞职后压力很大

离开

提了离职后，和项目上的同事们一起吃了一个散伙饭，然后在上海最后3个玩的比较好的朋友吃了顿饭，差不多我就留了一周时间在上海再待一周，看看上海，以后估计来的就比较少了。

那一周是真的舒服，没有工作压力，那时候也不想找工作，一周就是放松，不想任何事情，辞职的事情没有告诉父母，所以没有任何羁绊，天天吃了玩，玩了睡，差不多持续了一周后

我收拾行李开始北漂了，收拾行李的时候回想到刚毕业到上海漂泊，孤身一人，谁也不认识，搬家3次，发烧生病不及其次，其实就是加班太多了，压力太大导致的

当时和我非常要好的哥们苏总，我俩都阳了好几次，发烧好几次，什么病流行，我俩就得什么病，你看我们多时髦，在上海的两年还是收获了很多很多，但是已经不适合现阶段的我了，那就走！下一站北京！

进京

还好有一个非常要好的好哥们在北京实习，租的房子有一个月的空窗期，没有人住，所以我就可以白嫖一个月的住宿了，这一个月的白嫖住宿对我来讲还是很重要的，给我提供了一个月的找工作面试学习的时间。

非常感谢我这位朋友的照顾，才使得我在偌大的北京有一个可以休息的地方。感谢飞哥

从上海坐高铁到北京，自己拖着行李，正好那天晚上还在下雨，我见到了飞哥，飞哥请我吃了一顿饭后，我到了他的出租屋，那天晚上迟迟睡不着觉，想了很多事情，也担心找不到工作之后怎么办，回老家？回老家干什么工作呐？这或许是当代年轻人的痛吧

第二天睡醒后，我就开始找工作之旅了，没有接着休息了

现在的工作是真的不好找，主要还是自己核心竞争力不够导致的，经济形势不容乐观。到北京后也没有怎么玩，直接开始复习找工作，疯狂面试投简历，那段时间还是很规律的每天都在面试学习。

经过小一个月的备战，拿到了几个offer，最终选择了现在的这家公司

入职

拿到offer后很快就入职了，准备入职体检，体检tmd尿酸高点，我一般体检指标都是正常的，这次是第一次有指标不正常，不禁感慨，工作两年后确实伤身体

约好入职时间后，就休息了一两天，然后入职了现在这家公司，挺喜欢现在这家公司的，氛围很好，是一个创业公司，也不加班

在这家公司学习了很多，未来打算学习一下外语 这家公司有美国员工，正好练习一下口语

恋爱

啊哈哈哈，来北京一段时间后，就谈恋爱了，这里就简单说一下，留一点个人隐私

买房

在北京半个月稳定了后，我告诉了父母，我换工作到了北京，父母很开心，老家是邯郸的，距离北京不算远，基本上可以每周末都回家，经过考虑后，决定在邯郸买一个房子

在北京是不太可能了，未来大概率是要离开北京的，或早或晚吧，具体时间随缘吧

我拿了30%的首付钱，爸妈拿了70%的首付钱，我在邯郸买了一个三居室，在大学对面，我很喜欢这个地段，以后没事了大学里面看看腿也挺好的

这里也不细讲了，留点隐私

你呐？

你们呐，过的好吗？过的开心吗？

祝大家2025，天天开心

2024-12-12 于北京出租屋

前言

前几天和前同事闲时聚餐，约了两个月的小聚终于达成了，程序员行业聚少离多，所幸大家的发量还坚挺着。

期间不可避免地聊到了自己的公司、行业状况以及对未来的看法，几杯老酒之后，大家畅所欲言，其中一位老哥侃起了他的职业生涯，既坎坷又无奈，饭后想起来挺有代表性的，征得他同意故记录在此。

以下是老哥的历程。

程序员的前半生

我今年35岁，有房有贷有妻女有老父母。

出生在90年代的农村，从小中规中矩，不惹事不喧哗不突出，三好学生没有我，德智体美没有全面发展。学习也算努力，不算小题做题家，因为只考了个本科。

大学学费全靠助学带款，勤工俭学补贴日用，埋头苦干成绩也只在年级中等偏下水平。有些同学早早就定下了大学的目标，比如考研、比如出国、比如考公，到了大三的时候大家基本都有了自己的目标。而我的目标就是尽早工作，争取早日还完带款，因此早早就开始准备找工作。

也许是上天眷顾，不知道怎么就被华为看重了（那会华为还没现在的如日中天，彼时是BAT的天下），稀里糊涂的接受了offer，没想到却是改变了后面十年的决定。

2013年，深圳的夏天阳光明媚，热气扑鼻，提着一个简单的箱子进入了坂田基地。

刚开始，工作上的一切都很新鲜，每个人都在忙碌，虽然不知道他们在忙什么，但感觉很高级的样子。同期入职的同事都比较厉害，很快就适应了工作，而自己还是没完全应对工作内容，于是下班之后继续留在公司学习，顺便蹭饭。

就这样，很快就一年过去了，自己也慢慢熟悉了工作节奏，但是加班也越来越多了。对于自己来说，为了过节点，6点是晚饭时间，9点是下班时间，12点正式下班。

平凡的日子没什么值得留恋，过一天、一个月、一年、四年都没什么两样，四年里学习到了不少的知识，也数了很多次深圳凌晨的路灯数。

作为深漂，没有遇到深圳爱情故事，也对高昂的房价绝望，于是决定回到二线城市，成为一名蓉漂。
2017年，还是和四年前一样的行李箱，出现在了老家的省会城市，只是那时的我没有了助学打款，怀里也攒下了一些血汗钱。

那时互联网行业发展还是如火如荼，前端的需求量也很大，也得益于华为公司发展越来越好，自己的华为经历很快就拿到了几个offer，选了一家初创公司，幻想着能有一番成就。

2018年底，眼看着房价越长越高，某链中介不断地灌输再不买明天就是另一个价了，错过这个村就没这个店了，也许是想有个家，也许是想着父母能到省会里一起住，拿出自己做牛马几年的积蓄加上父母一辈子辛苦攒的小十万的养老钱购买了城区里的新房，那会儿的价格已经比前两年涨了一倍多，妥妥的高位站岗，不过想着自己是刚需也不会卖，因此咬咬牙掏出了全部的积蓄怒而背上了三十年的房贷。

房子的事暂时落定了，全身心的投入到工作中，没想到老板只想骗投资人的钱，产品没弄好投资人不愿跟进了，坚持了三年，期间各种断臂求生，最终还是落了个司破人走的境地。

2020年，30岁的我第一次被动失业了，幸运的是也找到了另一半。为了尽可能节省支出，房子装修的事我们都是亲力亲为，最后花了十多万终于将房子装好了，虽然很简单但毕竟是自己在大城市里的第一套房子，那一刻，感觉十年的付出都是值得的。

背着沉重的房贷，期望能找到一份薪资稍微过得去的工作，于是在简历上优势那行写了：“可加班”。依稀记得有些HR对我进行了灵魂拷问：结婚了吗？有小孩了吗？你都30岁了还能加班吗？。我斩钉截铁地说：只要公司有需要，我定会全力以赴！

2022年，我们的孩子出世了，队友辞去了工作全心全意带小孩，而我更加努力了，毕竟有了四脚吞金兽，不得不肝。

虽然工作很努力，但成果一般，不是公司的技术担当，也不会是技术洼地。

2023年的某一天，和之前的364天一样的平淡，在座位上解Bug的我突然感觉到一阵心悸，呼吸不畅，实在不行了呼唤同事叫了120，去医院一套检查下来没发现什么大问题。医生询问是不是工作压力太大，平时加班很多？我说还好，平时也就加班到9点。医生笑了笑说你这种年轻人我见多了，都是压力大的毛病，平时工作不要久坐盯着屏幕多站起来走走。他让我回家多休息，回去后观察了几天还是偶尔会有心悸，再去了另一个医院进行检查，也是没有明确的诊断结果，只是说可能是这个问题，又可能是另一个问题。

过了1个月后，身体上的问题不见好转，我辞去了工作。

2023年末，找了一家小公司，也就是我现在的公司，工资没有涨，仔细算起来还变相下降了。

还是做的业务需求，也没有领导什么人，管好自己就行，直属上级还是个工作几年的小伙。这家公司主要的特点是不加班，技术难度不高，能做多少就是多少，前提是要报风险，领导也不会强迫加班。

就这样到了2024，神奇的是我已经很久没有心悸的感觉了，不知道是不加班还是心态转变的原因。
家里的小朋友也长大了，会说话了。我现在每天下班最温馨的的是她开着门期待我回家的那一刻，她的期盼的眼神就是我回家的动力。

公司在2024年也裁了不少人，领导也找我谈过问问我的想法，我说：我还是能胜任这份工作的。领导说：公司觉得你年级大了一些，工资虽然不是最高，但不太符合行情，你懂的。我说：我懂，可以接受适当的降薪。
就这样，我挺过了2024，然而过了一周领导走了。

2025年，我35周岁了。
现在的我已经彻底接受自己的平庸的事实了。在学生时代，从来都不出色，也不会垫底，就是那类最容易被忽略的人。在工作时代，不是技术大牛，也不是完全的水货，就是普普通通的程序员。

如果说上半生吃到了什么红利，只能说入坑了计算机这行业，技术给我带了收入，有了糊口的基础。没进股市，却被房价狠狠割了一道。

35岁的我，没有彻底躺平摆烂，也没有足够奋发进取。

35岁的我，有着24年的房贷，还好61岁的时候我还在工作，应该还能还房贷。

35岁的我，不吃海鲜不喝酒，尿酸500+。

35岁的我，人体工学椅也挽救不了腰椎间盘突出。

35岁的我，头发依然浓密，只是白发越来越多。

35岁的我，已经不打游戏，只是会看这各种小说聊以慰藉。

35岁的我，两点一线，每天挤着地铁，看众生百态。

35岁的我，早睡早起，放空自己。

35岁的我，暂时还没有领取毕业大礼包，希望今年还能苟过。

35岁的我，希望经济能够好起来，让如我一般平凡的人能够有活下去的勇气。

诸君，下一年再会~祝你平安喜乐，万事顺遂！