你好呀，我是歪歪。

最近遇到一个生产问题，我负责的一个服务触发了内存使用率预警，收到预警的时候我去看了内存使用率已经到了 80%，看了一眼 GC 又发现还没有触发 FullGC，一次都没有。

基于这个现象，当时推测有两种可能，一种是内存溢出，一种是内存泄漏。

好，假设现在是面试，面试官目前就给了这点信息，他问你到底是溢出还是泄漏，你怎么回答？

在回答之前，我们得现明确啥是溢出，啥情况又是泄漏。

• 内存溢出（OutOfMemoryError）：内存溢出指的是程序请求的内存超出了 JVM 当前允许的最大内存容量。当 JVM 试图为一个对象分配内存时，如果当前可用的堆内存不足以满足需求，就会抛出 java.lang.OutOfMemoryError 异常。这通常是因为堆空间太小或者由于某些原因导致堆空间被占满。


• 内存泄漏 (Memory Leak)：内存泄漏是指不再使用的内存空间没有被释放，导致这部分内存无法再次被使用。虽然内存泄漏不会立即导致程序崩溃，但它会逐渐消耗可用内存，最终可能导致内存溢出。

虽然都与内存相关，但它们发生的时机和影响有所不同。内存溢出通常发生在程序运行时，当数据结构的大小超过预设限制时，常见的情况是你要分配一个大对象，比如一次从数据中查到了过多的数据。

而内存泄漏和“过多”关系不大，是一个细水长流的过程，一次内存泄漏的影响可能微乎其微，但随着时间推移，多次内存泄漏累积起来，最终可能导致内存溢出。

概念就是这个概念，这两个玩意经常被大家搞混，所以多嘴提一下。

概念明确了，回到最开始这个问题，你怎么回答？

你回答不了。

因为这些信息太不完整了，所以你回答不了。

面试的时候面试官就喜欢出这种全是错误选项的题目来迷惑你，摸摸你的底子到底怎么样。

首先，为什么不能判断，是因为前面说了：一次 FullGC 都没有。

虽然现在内存使用率已经到 80% 了，万一一次 FullGC 之后，内存使用率又下去了呢，说明程序没有任何问题。

如果没有下去，说明大概率是内存溢出了，需要去代码里面找哪里分配了大对象了。

那如果下去了，能说明一定没有内存泄漏吗？

也不能，因为前面又说了：内存泄漏是一个细水长流的过程。

关于内存溢出，如果监控手段齐全到位的话，你就记住左边这个走势图：

一个缓慢的持续上升的内存趋势图， 最后疯狂触发 GC，但是并没有内存被回收，最后程序直接崩掉。

内存泄漏，一眼定真假。

这个图来自我去年写的这篇文章：《虽然是我遇到的一个棘手的生产问题，但是我写出来之后，就是你的了。》

里面就是描述了一个内存泄漏的问题，通过分析 Dump 文件的方式，最终成功定位到泄漏点，修复代码。

一个不论多么复杂的内存泄漏问题，处理起来都是有方法论的。

不过就是 Dump 文件分析、工具的使用以及足够的耐心和些许的运气罢了。

所以我不打算赘述这些东西了，我想要分享的是我这次是怎么对应文章开始说的内存预警的。

我的处理方式就是：重启服务。

是的，常规来说都是会保留现场，然后重启服务。但是我的处理方式是：直接执行重启服务的预案。没有后续动作了。

我当时脑子里面的考虑大概是这样的。

首先，这个服务是一个边缘服务，它所承载的数据量不多，其业务已经超过一年多没有新增，存量数据正在慢慢的消亡。代码近一两年没啥改动，只有一些升级 jar 包，日志埋点这类的横向改造。

其次，我看了一下这个服务已经有超过四个月没有重启过了，这期间没有任何突发流量，每天处理的数据呈递减趋势，内存走势确实是一个缓慢上升的过程，我初步怀疑是有内存泄漏。

然后，这个服务是我从别的团队那边接手的一个服务，基于前一点，业务正在消亡这个因素，我也只是知道大概的功能，并不知道内部的细节，所以由于对系统的熟悉度不够，如果要定位问题，会较为困难。

最后，基于公司制度，虽然我知道应该怎么去排查问题，命令和工具我都会使用，但是我作为开发人员是没有权限使用运维人员的各类排查工具和排查命令的，所以如果要定位问题，我必须请求协调一个运维同事帮忙。

于是，在心里默默的盘算了一下投入产出比，我决定直接重启服务，不去定位问题。

按照目前的频率，程序正常运行四五个月后可能会触发内存预警，那么大不了就每隔三个月重启一次服务嘛，重启一次只需要 30s。一年按照重启 4 次算，也就是才 2 分钟。

这个业务我们就算它要五年后才彻底消亡，那么也就才 10 分钟而已。

如果我要去定位到底是不是内存泄露，到底在哪儿泄露的，结合我对于系统的熟悉程度和公司必须有的流程，这一波时间消耗，少说点，加起来得三五个工作日吧。

10 分钟和三五个工作日，这投入产出比，该选哪个，一目了然了吧？

我分享这个事情的目的，其实就是想说明我在这个事情上领悟到的一个点：在工作中，你遇到的问题，不是每一个都必须被解决的，也可以选择绕过问题，只要最终结果是好的就行。

如果我们抛开其他因素，只是从程序员的本职工作来看，那么遇到诸如内存泄漏的问题的时候，就是应该去定位问题、解决问题。

但是在职场中，其实还需要结合实际情况，进行分析。

什么是实际情况呢？

我前面列出来的那个“首先，其次，然后，最后”，就是我这个问题在技术之外的实际情况。

这些实际情况，让我决定不用去定位这个问题。

这也不是逃避问题，这是权衡利弊之后的最佳选择。

同样是一天的时间，我可以去定位这个“重启就能解决”的问题，也可以去做其他的更有价值事情，敲一些业务价值更大的代码。

这个是需要去权衡的，一个重要的衡量标准就是前面说的：投入产出比。

关于“不是所有的问题都必须被解决的，也可以选择绕过问题”这个事情，我再给你举一个我遇到的真实的例子。

几年前，我们团队遇到一个问题，我们使用的 RPC 框架是 Dubbo，有几个核心服务在投产期间滚动发布的时候，流量老是弄不干净，导致服务已经下线了，上游系统还在调用。

当时安排我去调研一下解决方案。

其实这就是一个优雅下线的问题，但是当时资历尚浅，我认真研究了一段时间，确实没研究出问题的根本解决方案。

后来我们给出的解决方案就是做一个容错机制，如果投产期间有因为流量不干净的问题导致请求处理失败的，我们把这些数据记录下来，然后等到投产完成后再进行重发。

没有解决根本问题，选择绕过了问题，但是从最终结果上看，问题是被解决了。

再后来，我们搭建了双中心。投产之前，A，B 中心都有流量，每次投产的时候，先把所有流量从 A 中心切到 B 中心去，在 A 中心没有任何流量的情况下，进行服务投产。B 中心反之。

这样，从投产流程上就规避了“流量老是弄不干净”的问题，因为投产的时候对应的服务已经没有在途流量了，不需要考虑优雅的问题了，从而规避了优雅下线的问题。

问题还是没有被解决，但是问题被彻底绕过。

最后，再举一个我在知乎上看到的一个回答，和我想要表达的观点，有异曲同工之妙：

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

这个回答下面的评论也很有意思，有兴趣的可以去翻一下，我截取两个我觉得有意思的：

在职场上，甚至在生活中，一个虽然没有解决方案但是可以被绕过的问题，我认为不是问题。

但是这个也得分情况，不是所有问题都能绕开的，假如是一个关键服务，那肯定不能置之不理，硬着头皮也得上。

关键是，我在职场上和生活中遇到过好多人，遇到问题的时候，似乎只会硬着头皮往上冲。

只会硬着头皮往上冲和知道什么时候应该硬着头皮往上冲，是两种截然不同的职场阶段。

所以有时候，遇到问题的时候，不要硬上，也让头皮休息一下，看看能不能绕过去。

前言

本文主要介绍 Electron 客户端应用的自动更新，包括全量和增量这两种方式。

全量更新： 运行新的安装包，安装目录所有资源覆盖式更新。

增量更新： 只更新修改的部分，通常是渲染进程和主进程文件。

本文并没有拿真实项目来举例子，而是起一个 新的项目 从 0 到 1 来实现自动更新。

如果已有的项目需要支持该功能，借鉴本文的主要步骤即可。

前置说明：

准备工作

脚手架搭建项目

我们通过 electron-vite 快速搭建一个基于 Vite + React + TS 的 Electron 项目。

该模板已经包括了我们需要的核心第三方库：electron-builder，electron-updater。

前者是用来打包客户端程序的，后者是用来实现自动更新的。

在项目根目录下，已经自动生成了两份配置文件：electron-builder.yml 和 dev-app-update.yml。

electron-builder.yml

该文件描述了一些 打包配置，更多信息可参考 官网。

在这些配置项中，publish 字段比较重要，因为它关系到更新源。

publish:

  provider: generic // 使用一个通用的 HTTP 服务器作为更新源。

  url: https://example.com/auto-updates // 存放安装包和描述文件的地址

provider 字段还有其他可选项，但是本文只介绍 generic 这种方式，即把安装包放在 HTTP 服务器里。

dev-app-update.yml

provider: generic

url: https://example.com/auto-updates

updaterCacheDirName: electron-update-demo-updater

其中，updaterCacheDirName 定义下载目录，也就是安装包存放的位置。全路径是C:\Users\用户名\AppData\Local\electron-update-demo-updater，不配置则在C:\Users\用户名\AppData\Local下自动创建文件夹，开发环境下为项目名，生产环境下为项目名-updater。

模拟服务器

我们直接运行 npm run build:win，在默认 dist 文件夹下就出现了打包后的一些资源。

其实更新的基本思路就是对比版本号，即对比本地版本和 线上服务器 版本是否一致，若不一致则需要更新。

因此我们在开发调试的时候，需要起一个本地服务器，来模拟真实的情况。

新建一个文件夹 mockServer，把打包后的 setup.exe 安装包和 latest.yml 文件粘贴进去，然后通过 serve 命令默认起了一个 http://localhose:3000 的本地服务器。

既然有了存放资源的本地地址，在开发调试的时候，我们更新下 dev-app-update.yml 文件的 url 字段，也就是修改为 http://localhose:3000。

注：如果需要测试打包后的更新功能，需要同步修改打包配置文件。

全量更新

与主进程文件同级，创建 update.ts 文件，之后我们的更新逻辑将在这里展开。

import { autoUpdater } from 'electron-updater' //核心库

需要注意的是，在我们开发过程中，通过 npm run dev 起来的 Electron 程序其实不能算是打包后的状态。

你会发现在调用 autoUpdater 的一些方法会提示下面的错误：

Skip checkForUpdates because application is not packed and dev update config is not forced

因此我们需要在开发环境去做一些动作，并且手动指定 updateConfigPath：

// update.ts

if (isDev) {

  Object.defineProperty(app, 'isPackaged', {

    get: () => true

  })

  autoUpdater.updateConfigPath = path.join(__dirname, '../../dev-app-update.yml')

}

核心对象 autoUpdater 有很多可以主动调用的方法，也有一些监听事件，同时还有一些属性可以设置。

这里只展示了本人项目场景所需的一些配置。

autoUpdater.autoDownload = false // 不允许自动下载更新

autoUpdater.allowDowngrade = true // 允许降级更新（应付回滚的情况）



autoUpdater.checkForUpdates()

autoUpdater.downloadUpdate()

autoUpdater.quitAndInstall()



autoUpdater.on('checking-for-update', () => {

  console.log('开始检查更新')

})

autoUpdater.on('update-available', info => {

  console.log('发现更新版本')

})

autoUpdater.on('update-not-available', info => {

  console.log('不需要全量更新', info.version)

})

autoUpdater.on('download-progress', progressInfo => {

  console.log('更新进度信息', progressInfo)

})

autoUpdater.on('update-downloaded', () => {

  console.log('更新下载完成')

})

autoUpdater.on('error', errorMessage => {

  console.log('更新时出错了', errorMessage)

})

在监听事件里，我们可以拿到下载新版本 整个生命周期 需要的一些信息。

// 新版本的版本信息（已筛选）

interface UpdateInfo {

    readonly version: string;

    releaseName?: string | null;

    releaseNotes?: string | Array<ReleaseNoteInfo> | null;

    releaseDate: string;

}



// 下载安装包的进度信息

interface ProgressInfo {

    total: number;

    delta: number;

    transferred: number;

    percent: number;

    bytesPerSecond: number;

}

在写完这些基本的方法之后，我们需要决定 检验更新 的时机，一般是在应用程序真正启动之后，即 mainWindow 创建之后。

运行项目，预期会提示 不需要全量更新，因为刚才复制到本地服务器的 latest.yml 文件里的版本信息与本地相同。修改 version 字段，重启项目，主进程就会提示有新版本需要更新了。

频繁启动应用太麻烦，除了应用初次启动时主进程主动帮我们检验更新外，还需要用户 手动触发 版本更新检测，此外，由于产品场景需要，当发现有新版本的时候，需要在 渲染进程 通知用户，包括版本更新时间和更新内容。因此我们需要加上主进程与渲染进程的 IPC通信 来实现这个功能。

其实需要的数据主进程都能够提供了，渲染进程具体的展示及交互方式就自由发挥了，这里简单展示下我做的效果。

1. 发现新版本

2. 无需更新

增量更新

为什么要这么做

其实全量更新是一种比较简单粗暴的更新方式，我没有花费太大的篇幅去介绍，基本上就是使用 autoUpdater 封装的一些方法，开发过程中更多的注意力则是放在了渲染进程的交互上。

此外，我们的更新交互用的是一种 用户感知 的方式，即更不更新是由用户自己决定的。而 静默更新 则是用户无感知，在监测到更新后不用去通知用户，而是自行在后台下载，在某个时刻执行安装的逻辑，这种方式往往是一键安装，不会弹出让用户去选择安装路径的窗口。接下去要介绍的增量更新其实是这种 用户无感知 的形式，只不过我们更新的不是整个应用程序。

由于产品迭代比较频繁，我们的业务方经常收到更新提示，意味着他们要经常手动更新应用，以便使用到最新的功能特性。众所周知，Electron 给前端开发提供了一个比较容易上手的客户端开发解决方案，但在享受 跨平台 等特性的同时，还得忍受 臃肿的安装包 。

带宽、流量在当前不是什么大问题，下载和安装的速度也挺快，但这频繁的下载覆盖一模一样的资源文件还是挺糟心的，代码改动量小时，全量更新完全没有必要。我们希望的是，开发更新了什么代码，应用程序就替换掉这部分代码就好了，这很优雅。在 我们的场景 中，这部分代码指的是 —— main、preload、renderer，并不包括 dll、第三方SDK等资源。

网上有挺多种增量更新的 解决方案，例如：

本文我们采用较普遍的 替换asar 来实现。

优化 app.asar 体积

asar是 Electron提供的一种将多个文件合并成一个文件的类 tar 风格的归档格式，不仅可以缓解Windows下路径名过长的问题， 还能够略微加快一下 require的速度, 并且可以隐藏你的源代码。（并非完全隐藏，有方法可以找出来）

Electron 应用程序启动的时候，会读取 app.asar.unpacked 目录中的内容合并到 app.asar 的目录中进行加载。在此之前我们已经打包了一份 Demo 项目，安装到本地后，我们可以根据安装路径找到 app.asar 这个文件。

例如：D:\你的安装路径\electron-update-demo\resources

在这个 Demo 项目中，脚手架生成的模板将图标剥离出来，因此出现了一个 app.asar.unpacked 文件夹。我们不难发现，app.asar 这个文件竟然有 66 MB，再回过头看我们真正的代码文件，甚至才 1 MB ！那么到底是什么原因导致的这个文件这么大呢，刚才提到了，asar 其实是一种压缩格式，因此我们只要解压看看就知道了。

npm i -g asar // 全局安装



asar e app.asar folder // 解压到folder文件夹

解压后我们不难发现，out 文件夹里的才是我们打包出来的资源，罪魁祸首竟然是 node_modules，足足有 62.3 MB。

查阅资料得知，Electron 在打包的时候，会把 dependencies 字段里的依赖也一起打包进去。而我们的渲染进程是用 React开发的，这些第三方依赖早就通过 Vite 等打包工具打到资源文件里了，根本不需要再打包一次，不然我们重新下载的 app.asar 文件还是很大的，因此需要尽可能减少体积。

优化应用程序体积 == 减少 node_modules 文件夹的大小 == 减少需要打包的依赖数量 == 减少 dependencies 中的依赖。

1. 移除 dependencies

最开始我想的是把 package.json 中的 dependencies 全都移到 devDependencies，打包后的体积果然减小了，但是在测试过程中会发现某些功能依赖包会缺失，比如 @electron/remote。因此在修改这部分代码的时候，需要特别留意，哪些依赖是需要保留下来的。

由于不想影响 package.json 的版本结构，我只是在写了一个脚本，在 npm i 之后，执行打包命令前修改 devDependencies 就好了。

2. 双 package.json 结构

这是 electron-builder 官网上看到的一种技巧，传送门， 创建 app 文件夹，再创建第二个 package.json，在该文件中配置我们应用的名称、版本、主进程入口文件等信息。这样一来，electron-builder 在打包时会以该文件夹作为打包的根文件夹，即只会打包这个文件夹下的文件。

但是我原项目的主进程和预加载脚本也放在这，尝试修改后出现打包错误的情况，感兴趣的可以试试。

这是我们优化之后的结果，1.32 MB，后面只需要替换这个文件就实现了版本的更新。

校验增量更新

全量更新的校验逻辑是第三方库已经封装好了的，那么对于增量更新，就得由我们自己来实现了。

首先明确一下 校验的时机，package.json 的 version 字段表示应用程序的版本，用于全量更新的判断，那也就意味着，当这个字段保持不变的时候，会触发上文提到的 update-not-available 事件。所以我们可以在这个事件的回调函数里来进行校验。

autoUpdater.on('update-not-available', info => { console.log('不需要全量更新', info.version) })

然后就是 如何校验，我们回过头来看 electron-builder 的打包配置，在 releaseInfo 字段里描述了发行版本的一些信息，目前我们用到了 releaseNotes 来存储更新日志，查阅官网得知还有个 releaseName 好像对于我们而言是没什么用的，那么我们就可以把它作为增量更新的 热版本号。（但其实 官网 配置项还有个 vendor 字段，可是我在用的时候打包会报错，可能是版本的问题，感兴趣的可以试试。）

每次发布新版本的时候，只要不是 Electron自身版本变化 等重大更新，我们都可以通过修改 releaseInfo 的 releaseName 来发布我们的热版本号。现在我们已经有了线上的版本，那 本地热版本号 该如何获取呢。这里我们在每次热更新完成之后，就会把最新的版本号存储在本地的一个配置文件中，通常是 userData 文件夹，用于存储我们应用程序的用户信息，即使程序卸载 了也不会影响里面的资源。在 Windows 下，路径如下：
C:\Users\用户名\AppData\Roaming\electron-update-demo。

因此，整个 校验流程 就是，在打开程序的时候，autoUpdater 触发 update-not-available 事件，拿到线上 latest.yml 描述的 releaseName 作为热版本号，与本地配置文件（我们命名为 config.json）里存储的热版本号（我们命名为 hotVersion）进行对比，若不同就去下载最新的 app.asar 文件。

我们使用 electron-log 来记录日志，代码如下所示。

// 本地配置文件

const localConfigFile = path.join(app.getPath('userData'), 'config.json')



const checkHotVersion = (latestHotVersion: string): boolean => {

  let needDownload = false

  if (!fs.existsSync(localConfigFile)) {

    fs.writeFileSync(localConfigFile, '{}', 'utf8')

    log.info('配置文件不存在，已自动创建')

  } else {

    log.info('监测到配置文件')

  }



  try {

    const configStr = fs.readFileSync(localConfigFile, 'utf8')

    const configData = JSON.parse(configStr || '{}')

    // 对比版本号

    if (latestHotVersion !== configData.hotVersion) {

      log.info('当前版本不是最新热更版本')

      needDownload = true

    } else {

      log.info('当前为最新版本')

    }

  } catch (error) {

    log.error('读取配置文件时出错', error)

  }



  return needDownload

}

下载增量更新包

通过刚才的校验，我们已经知道了什么时候该去下载增量更新包。

在开发调试的时候，我们可以把新版本的 app.asar 也放到起了本地服务器的 mockServer 文件夹里来模拟真实的情况。有很多方式可以去下载文件，这里我用了 nodejs 的 http 模块去实现，如果是 https 的需要引用 https 模块。

下载到本地的时候，我是放在了与 app.asar 同级目录的 resources 文件夹，我们不能直接覆盖原文件。一是因为进程权限占用的问题，二是为了容错，所以我们需要以另一个名字来命名下载后的文件（这里我们用的是 app.asar-temp），也就不需要去备份原文件了，代码如下。

const resourcePath = isDev

    ? path.join('D:\\测试\\electron-update-demo\\resources')

    : process.resourcesPath



const localAsarTemp = path.join(resourcePath, 'app.asar-temp')



const asarUrl = 'http://localhost:3000/app.asar'



downloadAsar() {

  const fileStream = fs.createWriteStream(localAsarTemp)

  http.get(asarUrl, res => {

    res.pipe(fileStream)

    fileStream

      .on('finish', () => {

        log.info('asar下载完成')

      })

      .on('error', error => {

        // 删除文件

        fs.unlink(localAsarTemp, () => {

          log.error('下载出现异常，已中断', error)

        })

      })

  })

}

因此，我们的流程更新为：发现新版本后，下载最新的 app.asar 到 resources 目录，并重命名为 app.asar-temp。这个时候我们启动项目进行调试，找到记录在本地的日志—— C:\Users\用户名\AppData\Roaming\electron-update-demo\logs，会有以下的记录：

[2024-09-20 13:49:22.456] [info]  监测到配置文件

[2024-09-20 13:49:22.462] [info]  当前版本不是最新热更版本

[2024-09-20 13:49:23.206] [info]  asar下载完成

在看看项目 resources 文件夹，多了一个 app.asar-temp文件。

至此，下载这一步已经完成了，但这样还会有一个问题，因为文件名没有加上版本号，也没有重复性校验，倘若一直没有更新，那么每次启动应用需要增量更新的时候都需要再次下载。

替换 app.asar 文件

好了，新文件也有了，接下来就是直接替换掉老文件就可以了，但是 替换的时机 很重要。

在 Windows 操作系统下，直接替换 app.asar 会提示程序被占用而导致失败，所以我们应该在程序关闭的时候实现替换。

我们有上面两种方案，最终采用了 方案2。

在主进程监听 app.on('quit') 事件，在应用退出的时候，判断 app.asar 和 app.asar-temp 是否同时存在，若同时存在，就去替换。这里替换不能直接用 nodejs 在主进程里去写，因为主进程执行的时候，资源还是被占用的。因此我们需要额外起一个 子进程 去做。

nodejs 可以通过 spawn、exec 等方法创建一个子进程。子进程可以执行一些自定义的命令，我们并没有使用子进程去执行 nodejs，因为业务方的机器上不一定有这个环境，而是采用了启动 exe 可执行文件的方式。可能有人问为什么不直接运行 .bat 批处理文件，因为我调试关闭应用的时候，会有一个 命令框闪烁 的现象，这不太优雅，尽管已经设置 spawn 的 windowsHide: true。

那么如何获得这个 exe 可执行文件呢，其实是通过 bat 文件去编译的，命令如下：

@echo off

timeout /T 1 /NOBREAK

del /f /q /a %1\app.asar

ren %1\app.asar-temp app.asar

我们加了延时，等待父进程完全关闭后，再去执行后续命令。其中 %1 为运行脚本传入的参数，在我们的场景里就是 resources 文件夹的地址，因为每个人的安装地址应该是不一样的，所以需要作为参数传进去。

转换文件的工具一开始用的是 Bat To Exe Converter 下载地址，但是在实际使用的过程中，我的电脑竟然把转换后的 exe 文件 识别为病毒，但在其他同事电脑上没有这种表现，这肯定就不行了，最后还是同事使用 python 帮我转换生成了一份可用的文件（replace.exe）。

这里我们可以选择不同的方式把 replace.exe 存放到 用户目录 上，要么是从线上服务器下载，要么是安装的时候就已经存放在本地了。我们选择了后者，这需要修改 electron-builder 打包配置，指定 asarUnpack, 这样就会存放在 app.asar.unpacked 文件夹中，不经常修改的文件都可以放在这里，不会随着增量更新而替换掉。

有了这个替换脚本之后，开始编写子进程相关的代码。

import { spawn } from 'child_process'



cosnt localExePath = path.join(resourcePath, 'app.asar.unpacked/resources/replace.exe')



replaceAsar() {

  if (fs.existsSync(localAsar) && fs.existsSync(localAsarTemp)) {

    const command = `${localExePath} ${resourcePath}`

    log.info(command)

    const logPath = app.getPath('logs')

    const childOut = fs.openSync(path.join(logPath, './out.log'), 'a')

    const childErr = fs.openSync(path.join(logPath, './err.log'), 'a')

    const child = spawn(`"${localExePath}"`, [`"${resourcePath}"`], {

      detached: true, // 允许子进程独立

      shell: true,

      stdio: ['ignore', childOut, childErr]

    })

    child.on('spawn', () => log.info('子进程触发'))

    child.on('error', err => log.error('child error', err))

    child.on('close', code => log.error('child close', code))

    child.on('exit', code => log.error('child exit', code))

    child.stdout?.on('data', data => log.info('stdout', data))

    child.stderr?.on('data', data => log.info('stderr', data))

    child.unref()

  }

}



app.on('quit', () => {

  replaceAsar()

})

在这块代码中，创建子进程的配置项比较重要，尤其是路径相关的。因为用户安装路径是不同的，可能会存在 文件夹名含有空格 的情况，比如 Program Files，这会导致在执行的时候将空格识别为分隔符，导致命令执行失败，因此需要加上 双引号。此外，detached: true 可以让子进程独立出来，也就是父进程退出后可以执行，而shell: true 可以将路径名作为参数传过去。

const child = spawn(`"${localExePath}"`, [`"${resourcePath}"`], {

  detached: true,

  shell: true,

  stdio: ['ignore', childOut, childErr]

})

但这块有个 疑惑，为什么我的 close、exit 以及 stdout 都没有触发，以至于不能拿到命令是否执行成功的最终结果，了解的同学可以评论区交流一下。

至此，在关闭应用之后，app.asar 就已经被替换为最新版本了，还差最后一步，更新本地配置文件里的 hotVersion，防止下次又去下载更新包了。

child.on('spawn', () => {

  log.info('子进程触发')

  updateHotVersion()

})



updateHotVersion() {

  fs.writeFileSync(localConfigFile, JSON.stringify({ hotVersion }, null, 2))

}

增量更新日志提示

既然之前提到的全量更新有日志说明，那增量更新可以不用，也应该需要具备这个能力，不然我们神不知鬼不觉帮用户更新了，用户都不知道 新在哪里。

至于更新内容，我们可以复用 releaseInfo 的 releaseNotes 字段，把更新日志写在这里，增量更新完成后展现给用户就好了。

但是总不能每次打开都展示，这里需要用户有个交互，比如点击 知道了 按钮，或者关闭 Modal 后，把当前的热更新版本号保存在本地配置文件，记录为 logVersion。在下次打开程序或者校验更新的时候，我们判断一下 logVersion === hotVersion，若不同，再去提示更新日志。

日志版本 校验和修改的代码如下所示：

checkLogVersion() {

  let needShowLog = false

  try {

    const configStr = fs.readFileSync(localConfigFile, 'utf8')

    const configData = JSON.parse(configStr || '{}')

    const { hotVersion, logVersion } = configData

    if (hotVersion !== logVersion) {

      log.info('日志版本与当前热更新版本不同，需要提示更新日志')

      needShowLog = true

    } else {

      log.info('日志已是最新版本，无需提示更新日志')

    }

  } catch (error) {

    log.error('读取配置文件失败', error)

  }

  return needShowLog

}



updateLogVersion() {

  try {

    const configStr = fs.readFileSync(localConfigFile, 'utf8')

    const configData = JSON.parse(configStr || '{}')

    const { hotVersion } = configData

    fs.writeFileSync(localConfigFile, JSON.stringify({ hotVersion, logVersion: hotVersion }, null, 2))

    log.info('日志版本已更新')

  } catch (error) {

    log.error('读取配置文件失败', error)

  }

}

读取 config.json 文件的方法自行封装一下，我这里就重复使用了。主进程 ipcMain.on 监听一下用户传递过来的事件，再去调用 updateLogVersion 即可，渲染进程效果如下：

提示增量更新日志

点击 知道了 后，再次打开应用后就不会提示日志了，因为本地配置文件已经被修改了。

当然可能也有这么个场景，开发就改了一点点无关功能的代码，无需向用户展示日志，我们只需要加一个判断 releaseNotes 是否为空的逻辑就好了，也做到了 静默更新。

小结

不足之处

本文提出的增量更新方案应该算是比较简单的，可能并不适用于所有的场景，考虑也不够全面，例如：

流程图

针对本文的解决方案，我简单画了一个 流程图。

参考文章

网上其实有不少关于 Electron 自动更新的文章，在做这个需求之前也是浏览了好多，但也有些没仔细看完，所以就躺在我的标签页没有关闭，在这罗列出来，也当作收藏了。

写这篇文章的目的也是为了记录和复盘，如果能为你提供一些思路那就再好不过了。

鸣谢：

在这个技术日新月异的时代，编程语言的更新换代似乎已经成为了家常便饭。但国产语言却一直不温不火，对于程序员来说，拥有一款属于我们自己的语言，一直是大家梦寐以求的事情。

如果我说有一种国产编程语言，它的运行速度比Rust快9倍，比GO快35倍，你会相信吗？

这不是天方夜谭，最近，被称为“国产编程语引领者”的MoonBit（月兔），宣布正式进入Beta预览版本阶段啦！

一听月兔这名字起得挺中式的。

一、初识MoonBit

MoonBit是由粤港澳大湾区数字经济研究院（福田）研发的全新编程语言。

① 官网

http://www.moonbitlang.cn/

② 目前状态

MoonBit是2022年推出的国产编程语言，并在2023年8月18日海外发布后，立即获得国际技术社区的广泛关注。

经过一年多的高速迭代，MoonBit推出了beta预览版。

MoonBit 目前处于 Beta-Preview 阶段。官方希望能在 2024/11/22 达到 Beta 阶段，2025年内达到 1.0 阶段。

③ 由来

诞生于AI浪潮，没有历史包袱：MoonBit 诞生于 ChatGPT 出世之后，使得 MoonBit 团队有更好的机会去重新构想整个程序语言工具链该如何与 AI 友好的协作，不用承担太多的历史包袱

二、MoonBit 语言优势

① 编译与运行速度快

MoonBit在编译速度和运行时性能上表现出色，其编译626个包仅需1.06秒，比Rust快了近9倍；运行速度比GO快35倍！

② 代码体积小

MoonBit 在输出 Wasm 代码体积上相较于传统语言有显著优势。

一个简单的HTTP 服务器时，MoonBit 的输出文件大小仅为 27KB，而 WasmCloud提供的http-hello-world 模板中 Rust 的输出为 100KB，TypeScript 为 8.7MB，Python 更是高达 17MB。

③ 多重安全保障

MoonBit 采用了强大的类型系统，并内置静态检测工具，在编译期检查类型错误，

MoonBit自身的静态控制流分析能在编译器捕获异常的类型，从而提高代码的正确性和可靠性。

④ 高效迭代器

MoonBit创新地使用了零开销的迭代器设计，使得用户能够写出既优雅又高效的代码。

⑤ 创新的泛型系统设计

MoonBit语言在它的测试版里就已经搞定了泛型和特殊的多态性，而且在编译速度特别快的同时，还能做到用泛型时不增加额外负担。

你要知道，这种本事在很多流行的编程语言里，都是正式发布很久之后才慢慢有的，但MoonBit一开始就做到了。这种设计在现在编程语言越来越复杂的大背景下特别关键，因为一个好的类型系统对于整个编程语言生态的健康成长是特别重要的。

三、应用场景

① 云计算

② 边缘计算

③ AI 以及教学领域的发展

四、开发样例

我们在官网 http://www.moonbitlang.cn/gallery/ 可以看到用使用MoonBit 开发的游戏样例

• 罗斯方块游戏


• 马里奥游戏


• 数独求解器


• 贪吃蛇游戏

五、语言学习

5.1 语法文档

如果你也对MoonBit感兴趣，想学习它，访问官方文档docs.moonbitlang.cn/。文档算是比较详细的了

5.2 在线编译器

无需本地安装编译器即可使用，官方提供了在线编译器

① 在线编辑器地址

try.moonbitlang.cn/

② 点击这儿运行代码

5.3 VS Code 中安装插件编写代码、

① 安装插件

② 下载程序

按下shift+cmd+p快捷键（mac快捷键，windows和linux快捷键是ctrl+shift+p），输入 MoonBit:install latest moonbit toolchain，随后会出现提示框，点击“yes”，等待程序下载完成。

③ 创建并打开新项目

下载完成后，点击terminal，输入moon new hello && code hello以创建并打开新项目。

④ 始执行代码

项目启动后，再次打开terminal，输入moon run main命令，即可开始执行代码。

六、小结

下面是晓凡的一些个人看法

MoonBit 作为一款新兴的国产编程语言，其在性能和安全性方面的表现令人印象深刻。

特别是它在编译速度和运行效率上的优化，对于需要处理大量数据和高并发请求的现代应用来说，是一个很大的优势。

同时，它的设计理念符合当前软件开发的趋势，比如对云计算和边缘计算的支持，以及对 AI 应用的适配。

此外，MoonBit 团队在语言设计上的前瞻性思考，比如泛型系统的实现，显示出了其对未来编程语言发展趋势的深刻理解。

而且，提供的游戏开发样例不仅展示了 MoonBit 的实用性，也降低了初学者的学习门槛。

大家好，我是晓凡。

写在前面

不知道大家有没有做财务的朋友，我就有这么一位朋友就经常跟我抱怨。一到月底简直就是噩梦，总有加不完的班，熬不完的夜，做不完的报表。

一听到这儿，这不就一活生生的一个“大表哥”么，这加班跟我们程序员有得一拼了，忍不住邪恶一笑，心里平衡了很多。

身为牛马，大家都不容易啊。我不羡慕你数钱数到手抽筋，你也别羡慕我整天写CRUD 写到手起老茧🤣

吐槽归吐槽，饭还得吃，工作还得继续干。于是乎，真好赶上周末，花了一天的时间，帮朋友写了个小工具

一、功能需求

跟朋友吹了半天牛，终于把需求确定下来了。就一个很简单的功能，通过名字，将表一和表二中相同名字的金额合计。

具体数据整合如下图所示

虽然一个非常简单的功能，但如果不借助工具，数据太多，人工来核对，整合数据，还是需要非常消耗时间和体力的。

怪不得，这朋友到月底就消失了，原来时间都耗在这上面了。

二、技术选型

由于需求比较简单，只有excel导入导出，数据整合功能。不涉及数据库相关操作。

综合考虑之后选择了

• PowerBuilder


• Pbidea.dll

使用PowerBuilder开发桌面应用，虽然界面丑一点，但是开发效率挺高，简单拖拖拽拽就能完成界面（对于前端技术不熟的小伙伴很友好）

其次，由于不需要数据库，放弃web开发应用，又省去了云服务器费用。最终只需要打包成exe文件即可跑起来

Pbidea.dll 算是Powerbuilder最强辅助开发，没有之一。算是PBer们的福音吧

三、简单界面布局

四、核心代码

① 导入excel

​

string ls_pathName,ls_FileName //路径+文件名，文件名

long ll_Net

long rows

dw_1.reset()

uo_datawindowex dw

dw = create uo_datawindowex

dw_1.setredraw(false)

ll_Net = GetFileSaveName("请选择文件",ls_pathName,ls_FileName,"xlsx","Excel文(*.xlsx),*.xlsx")

​

rows = dw.ImportExcelSheet(dw_1,ls_pathName,1,0,0)

destroy dw

dw_1.setredraw(true)

MessageBox("提示信息","导入成功 " + string(rows) + "行数据")

​

② 数据整合

long ll_row,ll_sum1,ll_sum2

long ll_i,ll_j

long ll_yes

​

string ls_err

​

//重置表三数据

​

dw_3.reset()

​

//处理表一数据

ll_sum1 = dw_1.rowcount( )

​

if ll_sum1<=0 then

    ls_err = "表1 未导入数据，请先导入数据"

    goto err

end if

​

for ll_i=1 to ll_sum1

    ll_row = dw_3.insertrow(0)

    dw_3.object.num[ll_row] =ll_row                                                          //序号

    dw_3.object.name[ll_row]=dw_1.object.name[ll_i]                                 //姓名

    dw_3.object.salary[ll_row]=dw_1.object.salary[ll_i]                                //工资

    dw_3.object.endowment[ll_row]=dw_1.object.endowment[ll_i]               //养老

    dw_3.object.medical[ll_row]=dw_1.object.medical[ll_i]                          //医疗

    dw_3.object.injury[ll_row]=dw_1.object.injury[ll_i]                                        //工伤

    dw_3.object.unemployment[ll_row]=dw_1.object.unemployment[ll_i]      //失业

    dw_3.object.publicacc[ll_row]=dw_1.object.publicacc[ll_i]                      //公积金

    dw_3.object.annuity[ll_row]=dw_1.object.annuity[ll_i]                           //年金

    

next

​

//处理表二数据

​

ll_sum2 = dw_2.rowcount( )

​

if ll_sum2<=0 then

    ls_err = "表2未导入数据，请先导入数据"

    goto err

end if

​

for ll_j =1 to ll_sum2

    string ls_name 

    ls_name = dw_2.object.name[ll_j]

    

    ll_yes = dw_3.Find("name = '"+ ls_name +"'  ",1,dw_3.rowcount())

    

    if ll_yes<0 then

        ls_err = "查找失败!"+SQLCA.SQLErrText

        goto err

    end if

            

    if ll_yes = 0 then  //没有找到

            ll_row = dw_3.InsertRow (0)

            dw_3.ScrollToRow(ll_row)

            dw_3.object.num[ll_row]                   = ll_row                                                          //序号

            dw_3.object.name[ll_row]                 = dw_1.object.name[ll_j]                                 //姓名

            dw_3.object.salary[ll_row]                 = dw_1.object.salary[ll_j]                                //工资

            dw_3.object.endowment[ll_row]         = dw_1.object.endowment[ll_j]               //养老

            dw_3.object.medical[ll_row]              = dw_1.object.medical[ll_j]                          //医疗

            dw_3.object.injury[ll_row]                 = dw_1.object.injury[ll_j]                                        //工伤

            dw_3.object.unemployment[ll_row]    = dw_1.object.unemployment[ll_j]      //失业

            dw_3.object.publicacc[ll_row]            = dw_1.object.publicacc[ll_j]                      //公积金

            dw_3.object.annuity[ll_row]               = dw_1.object.annuity[ll_j]                           //年金

    end if

    

    if ll_yes >0 then  //找到        

            dec{2} ld_salary,ld_endowment,ld_medical,ld_injury,ld_unemployment,ld_publicacc,ld_annuity

            ld_salary = dw_3.object.salary[ll_yes] + dw_2.object.salary[ll_j]

            ld_endowment =  dw_3.object.endowment[ll_yes] + dw_2.object.endowment[ll_j]

            ld_medical = dw_3.object.medical[ll_yes] + dw_2.object.medical[ll_j]

            ld_injury = dw_3.object.injury[ll_yes] + dw_2.object.injury[ll_j]

            ld_unemployment = dw_3.object.unemployment[ll_yes] + dw_2.object.unemployment[ll_j]

            ld_publicacc = dw_3.object.publicacc[ll_yes] + dw_2.object.publicacc[ll_j]

            ld_annuity = dw_3.object.annuity[ll_yes] + dw_2.object.annuity[ll_j]

            

            dw_3.object.salary[ll_yes]=  ld_salary                             //工资

            dw_3.object.endowment[ll_yes]=ld_endowment               //养老

            dw_3.object.medical[ll_yes]=ld_medical                          //医疗

            dw_3.object.injury[ll_yes]=ld_injury                                     //工伤

            dw_3.object.unemployment[ll_yes]=ld_unemployment   //失业

            dw_3.object.publicacc[ll_yes]=ld_publicacc                    //公积金

            dw_3.object.annuity[ll_yes]=ld_publicacc                      //年金

        

    end if

    

next

​

return 0

​

err:

messagebox('错误信息',ls_err)

③ excel导出

string ls_err

string ls_pathName,ls_FileName //路径+文件名，文件名

long ll_Net

​

if dw_3.rowcount() = 0 then 

    ls_err = "整合数据为空，不能导出"

    goto err

end if

​

uo_wait_box luo_waitbox

luo_waitbox = create uo_wait_box

luo_waitBox.OpenWait(64,RGB(220,220,220),RGB(20,20,20),TRUE,"正在导出 ", 8,rand(6) - 1)

​

long rows

CreateDirectory("tmp")

uo_datawindowex dw

dw = create uo_datawindowex

​

ll_Net = GetFileSaveName("选择路径",ls_pathName,ls_FileName,"xlsx","Excel文(*.xlsx),*.xlsx")

​

rows = dw.ExportExcelSheet(dw_3,ls_pathName,true,true)

destroy dw

destroy luo_waitbox

MessageBox("提示信息","成功导出 " + string(rows) + " 行数据")

​

return 0

​

err:

messagebox('错误信息',ls_err)

五、最终效果

这次分享就到这吧，★,°:.☆(￣▽￣)/$: .°★ 。希望对您有所帮助，也希望多来几个这样的朋友，不多说了， 蹭饭去了

我们下期再见ヾ(•ω•`)o (●'◡'●)

top

在 Linux 服务器上，或类 Unix 的机器上，一般我们想查看每个进程的 CPU 使用率、内存使用情况以及其他相关信息时会使用 top 命令。

top 是一个标准的 Linux/Unix 工具，实际上我从一开始接触 Linux 就一直使用 top , 一般是两种场景：

• Linux 服务器上用


• 自己的 Mac 电脑上用

top 有一些常用的功能，比如可以动态的显示进程的情况，按照 CPU 、内存使用率排序等。说实话，这么多年了，使用最多的还就是 top ，一来是因为习惯了，工具用惯了很多操作都是肌肉记忆。二来是 top 一般系统自带不用安装，省事儿。

htop

top 挺好的，但 top 对于初学者和小白用户不太友好，尤其是它的用户界面和操作。于是后来有了 htop

htop 是 top 的一个增强替代品，提供了更加友好的用户界面和更多的功能。与 top 相比，htop 默认以颜色区分不同的信息，并且支持水平滚动查看更多的进程信息。htop 还允许用户使用方向键来选择进程，并可以直接发送信号给进程（如 SIGKILL）。htop 支持多种视图和配置选项，使得用户可以根据自己的喜好定制显示的内容。

htop 我也用了几年，确实舒服一些，但由于需要安装和我对 top 的肌肉记忆 ，htop 在我的使用中并未完全替代 top。 直到 btop 的出现

btop

现在，我本机使用的是 btop，有了 btop，top 和 htop 一点儿都不想用了，哈哈。

在服务器上有时候因为懒不想安装，一部分时间还是 top，一部分用 btop。

第一印象是真漂亮啊，然而它不止好看，功能也是很实用，操作还很简单，你说能不喜欢它吗？

说是 btop ，实际上人家真正的名字是 btop++ , 用 C++ 开发的

安装

btop 支持各种类 Unix 系统，你可以在它的文档中找到对应系统的安装方法 github.com/aristocrato…

本文演示，我是用我自己的 Mac 笔记本电脑，用 Mac 安装很简单，用 brew 一行搞定

brew install btop

我的系统情况是这样的：

安装完成后，直接运行 btop 就可以看到如上图的界面了。

功能界面

打开 btop 后不要被它的界面唬住了，其实非常的简单，我们来介绍一下。

打开 btop 后，其实显示的是它给你的 “预置” 界面。 默认有 4 个预置界面，你可以按 p 键进行切换。命令行界面上会分别显示：

• preset 0


• preset 1


• preset 2


• preset 3

你可能注意到了，这 4 个预置界面中有很多内容是重复的，没错，其实 btop 一共就 4 个模块，预置界面只是把不同的模块拼在一起显示罢了。这 4 个模块分别是：

• CPU 模块


• 存储 模块


• 网络 模块


• 进程 模块

这 4 个模块对应的快捷键分别就是 1，2，3，4 你按一下模块显示，再按一下模块隐藏。

所以如果你对预置界面的内容想立刻调整，就可以按快捷键来显示/隐藏 你想要的模块，当然预置界面也是可以通过配置文件调整的，这个我们后面说。

CPU 模块

CPU 模块可以显示 CPU 型号、各内核的使用率、温度，CPU 整体的负载，以及一个直观的图象，所有数据都是实时显示的。

存储 模块

存储模块包括两部分，一个是内存使用情况，一个是磁盘使用情况：

因为比较直观，具体内容我就不解释了。

网络模块

网络模块可以看下网络的整体负载和吞吐情况，主要包括上行和下行数据汇总，你可以通过按快捷键 b和n 来切换看不同的网卡。

进程模块

初始的进程模块可以看到：

• pid


• Program: 进程名称


• Command: 执行命令的路径


• Threads: 进程包含的线程数


• User: 启动进程的用户


• MemB: 进程所占用内存


• Cpu%: 进程所占用 CPU 百分比

你可以按快捷键 e 显示树状视图：

可以按快捷键 r 对进行排序，按一下是倒序，再按一下是正序。具体排序列可以按左右箭头，根据界面显示进行选择，比如我要按照内存使用排序，那么右上角就是这样的：

按 f 键输入你想过滤的内容然后回车，可以过滤一下界面显示的内容，比如我只想看 chrome 的进程情况：

还可以通过 上下箭头选中某一个进程按回车查看进程详情，再次按回车可以隐藏详情：

显示进程详情后可以对进程进行操作，比如 Kill 只需要按快捷键 k 就可以了，然后会弹出提示：

主题

怎么样，是不是很方便，操作简单，上手容易，还好看。关于 btop 的主要操作就这些了，剩下的可以参考 help 和 menu 中显示的内容自行操作和设置都很简单。

btop 的配置文件默认在这里：$HOME/.config/btop ，你可以直接修改配置文件中的详细参数，如我们前文提到的 “预置” 界面以及预置界面内容都可以在配置文件中设置 ：

此外 btop 还有很多好看的主题配色，但默认安装的情况下只带了一个 Default 的，如果你想切换用其他的主题，需要先下载这些主题，主题文件在这里：github.com/aristocrato…

下载好以后放到本地对应的文件夹中 ~/.config/btop/themes

然后你就可以要界面上进行主题的切换了，具体流程是先按快捷键 m ，然后选 OPTIONS

接着在 Color theme 中就能看到你当前拥有的 theme 数据，按方向键就可以切换主题配色了：

主题有很多，我这里给大家一个完整的预览：

我目前使用的就是 Default 我觉得最符合我的审美。

最后

用了 btop 后你就再也回不去了，一般情况下再也不会想用 htop 和 top 了，大家没有换的可以直接换了

插件系统被广泛应用在各个系统中，比如浏览器、各个前端库如vue、webpack、babel，它们都可以让用户自行添加插件。插件系统的好处是允许开发人员在保证内部核心逻辑不变的情况下，以安全、可扩展的方式添加功能。

本文参考了webpack的插件，不引入任何库，写一个简单的插件系统，帮助大家理解插件化思维。

下面我们先看看插件有哪些概念和设计插件的流程。

准备

三个概念

• 核心系统（Core）：有着系统的基本功能，这些功能不依赖于任何插件。


• 核心和插件之间的联系（Core <--> plugin）：即插件和核心系统之间的交互协议，比如插件注册方式、插件对核心系统提供的api的使用方式。


• 插件（plugin）：相互独立的模块，提供了单一的功能。

插件系统的设计和执行流程

那么对着上面三个概念，设计插件的流程：

• 首先要有一个核心系统。


• 然后确定核心系统的生命周期和暴露的 API。


• 最后设计插件的结构。
  
  
  
  • 插件的注册 -- 安装加载插件到核心系统中。
  
  
  • 插件的实现 -- 利用核心系统的生命周期钩子和暴露的 API。
  
  
  
  

最后代码执行的流程是：

• 注册插件 -- 绑定插件内的处理函数到生命周期


• 调用插件 -- 触发钩子，执行对应的处理函数

直接看代码或许更容易理解⬇️

代码实现

准备一个核心系统

一个简单的 JavaScript 计算器，可以做加、减操作。

class Calculator {

  constructor(options = {}) {

      const { initialValue = 0 } = options

      this.currentValue = initialValue;

  }

  getCurrentValue() {

      return this.currentValue;

  }

  setValue(value) {

      this.currentValue = value;

  }

  plus(addend) {

      this.setValue(this.currentValue + addend);

  }

  minus(subtrahend) {

      this.setValue(this.currentValue - subtrahend);

  }

}



// test

const calculator = new Calculator()

calculator.plus(10);

calculator.getCurrentValue() // 10

calculator.minus(5);

calculator.getCurrentValue() // 5

确定核心系统的生命周期

实现Hooks

核心系统想要对外提供生命周期钩子，就需要一个事件机制。不妨叫Hooks。（日常开发可以考虑使用webpack的核心库 Tapable ）

class Hooks {

    constructor() {

        this.listeners = {};

    }

    on(eventName, handler) {

        let listeners = this.listeners[eventName];

        if (!listeners) {

            this.listeners[eventName] = listeners = [];

        }

        listeners.push(handler);

    }

    off(eventName, handler) {

        const listeners = this.listeners[eventName];

        if (listeners) {

            this.listeners[eventName] = listeners.filter((l) => l !== handler);

        }

    }

    trigger(eventName, ...args) {

        const listeners = this.listeners[eventName];

        const results = [];

        if (listeners) {

            for (const listener of listeners) {

                const result = listener.call(null, ...args);

                results.push(result);

            }

        }

        return results;

    }

    destroy() {

        this.listeners = {};

    }

}

暴露生命周期（通过Hooks）

然后将hooks运用在核心系统中 -- JavaScript 计算器

每个钩子对应的事件：

• pressedPlus 做加法操作


• pressedMinus 做减法操作


• valueWillChanged 即将赋值currentValue，如果执行此钩子后返回值为false，则中断赋值。


• valueChanged 已经赋值currentValue

class Calculator {

  constructor(options = {}) {

      this.hooks = new Hooks();

      const { initialValue = 0 } = options

      this.currentValue = initialValue;

  }

  getCurrentValue() {

      return this.currentValue;

  }

  setValue(value) {

    const result = this.hooks.trigger('valueWillChanged', value);

    if (result.length !== 0 && result.some( _ => ! _ )) {

    } else {

      this.currentValue = value;

    }

    this.hooks.trigger('valueChanged', this.currentValue);

  }

  plus(addend) {

      this.hooks.trigger('pressedPlus', this.currentValue, addend);

      this.setValue(this.currentValue + addend);

  }

  minus(subtrahend) {

      this.hooks.trigger('pressedMinus', this.currentValue, subtrahend);

      this.setValue(this.currentValue - subtrahend);

  }

}

设计插件的结构

插件注册

class Calculator {

  constructor(options = {}) {

      this.hooks = new Hooks();

      const { initialValue = 0, plugins = [] } = options

      this.currentValue = initialValue;

      // 在options中取出plugins

      // 通过plugin执行apply来注册插件 -- apply执行后会绑定（插件内的）处理函数到生命周期

      plugins.forEach(plugin => plugin.apply(this.hooks));

  }

  ...

}

插件实现

插件一定要实现apply方法。在Calculator的constructor调用时，才能确保插件“apply执行后会绑定（插件内的）处理函数到生命周期”。

apply的入参是this.hooks，通过this.hooks来监听生命周期并添加处理器。

下面实现一个日志插件和限制最大值插件:

// 日志插件：用console.log模拟下日志

class LogPlugins {

  apply(hooks) {

    hooks.on('pressedPlus', 

        (currentVal, addend) => console.log(`${currentVal} + ${addend}`));

    hooks.on('pressedMinus',

        (currentVal, subtrahend) => console.log(`${currentVal} - ${subtrahend}`));

    hooks.on('valueChanged', 

        (currentVal) => console.log(`结果： ${currentVal}`));

  }

}



// 限制最大值的插件：当计算结果大于100时，禁止赋值

class LimitPlugins {

  apply(hooks) {

    hooks.on('valueWillChanged', (newVal) => {

      if (100 < newVal) {

        console.log('result is too large')

        return false;

      }

      return true

    });

  }

}

全部代码

class Hooks {

  constructor() {

    this.listener = {};

  }



  on(eventName, handler) {

    if (!this.listener[eventName]) {

      this.listener[eventName] = [];

    }

    this.listener[eventName].push(handler);

  }



  trigger(eventName, ...args) {

    const handlers = this.listener[eventName];

    const results = [];

    if (handlers) {

      for (const handler of handlers) {

        const result = handler(...args);

        results.push(result);

      }

    }

    return results;

  }



  off(eventName, handler) {

    const handlers = this.listener[eventName];

    if (handlers) {

      this.listener[eventName] = handlers.filter((cb) => cb !== handler);

    }

  }



  destroy() {

    this.listener = {};

  }

}



class Calculator {

  constructor(options = {}) {

    this.hooks = new Hooks();

    const { initialValue = 0, plugins = [] } = options;

    this.currentValue = initialValue;

    plugins.forEach((plugin) => plugin.apply(this.hooks));

  }

  getCurrentValue() {

    return this.currentValue;

  }

  setValue(value) {

    const result = this.hooks.trigger("valueWillChanged", value);

    if (result.length !== 0 && result.some((_) => !_)) {

    } else {

      this.currentValue = value;

    }

    this.hooks.trigger("valueChanged", this.currentValue);

  }

  plus(addend) {

    this.hooks.trigger("pressedPlus", this.currentValue, addend);

    this.setValue(this.currentValue + addend);

  }

  minus(subtrahend) {

    this.hooks.trigger("pressedMinus", this.currentValue, subtrahend);

    this.setValue(this.currentValue - subtrahend);

  }

}



class LogPlugins {

  apply(hooks) {

    hooks.on("pressedPlus", (currentVal, addend) =>

      console.log(`${currentVal} + ${addend}`)

    );

    hooks.on("pressedMinus", (currentVal, subtrahend) =>

      console.log(`${currentVal} - ${subtrahend}`)

    );

    hooks.on("valueChanged", (currentVal) =>

      console.log(`结果： ${currentVal}`)

    );

  }

}



class LimitPlugins {

  apply(hooks) {

    hooks.on("valueWillChanged", (newVal) => {

      if (100 < newVal) {

        console.log("result is too large");

        return false;

      }

      return true;

    });

  }

}



// run test

const calculator = new Calculator({

  plugins: [new LogPlugins(), new LimitPlugins()],

});

calculator.plus(10);

calculator.minus(5);

calculator.plus(1000);

脚本的执行结果如下，大家也可以自行验证一下

看完代码可以回顾一下“插件系统的设计和执行流程”哈。

更多实现

假如要给Calculator设计一个扩展运算方式的插件，支持求平方、乘法、除法等操作，这时候怎么写？

实际上目前核心系统Calculator是不支持的，因为它并没有支持的钩子。那这下只能改造Calculator。

可以自行尝试一下怎么改造。也可以直接看答案：github.com/coder-xuwen…

最后

插件化的好处

在上文代码实现的过程中，可以感受到插件让Calculator变得更具扩展性。

• 核心系统（Core）只包含系统运行的最小功能，大大降低了核心代码的包体积。


• 插件（plugin）则是互相独立的模块，提供单一的功能，提高了内聚性，降低了系统内部耦合度。


• 每个插件可以单独开发，也支持了团队的并行开发。


• 另外，每个插件的功能不一样，也给用户提供了选择功能的能力。

本文的局限性

另外，本文的代码实现很简单，仅供大家理解，大家还可以继续完善：

• 增加ts类型，比如给把所有钩子的类型用emun记录起来


• 支持动态加载插件


• 提供异常拦截机制 -- 处理注册插件插件的情况


• 暴露接口、处理钩子返回的结构时要注意代码安全

参考

Designing a JavaScript Plugin System | CSS-Tricks

当我们说插件系统的时候，我们在说什么 - 掘金

干货!撸一个webpack插件(内含tapable详解+webpack流程) - 掘金

精读《插件化思维》

【干货】React 组件插件化的简洁实现

@[toc]
小伙伴们知道，松哥平时录了蛮多视频课程，视频录完以后，就想整理一个视频文档出来，在整理视频文档的时候，就会遇到一个问题，就是怎么统计视频时长？

特别是有时候为了方便大家看到每一集视频的时长，我要把视频目录整理成下面这个样子：

这个逐集去查看就很麻烦，一套视频动辄几百集，挨个统计不现实，也不符合咱们程序员做事风格。

那么怎么办呢？

一开始我是使用 Python 去解决的，Python 做这样一个小工具其实特别方便，简简单单 30 行代码左右就能搞定了。之前的课程的这些时间统计我基本上都是用 Python 去完成的。

不过最近松哥发现 Java 里边其实也有一个视频处理的库，做这个事情也是非常方便，而且使用 Java 属于主场作战，就能够更加灵活的扩展功能了。

一 jave-all-deps

在 Java 开发中，处理音视频文件经常需要复杂的编解码操作，开发者通常需要依赖于外部库来实现这些功能，其中最著名的是 FFmpeg。然而，直接在 Java 中使用 FFmpeg 并不是一件容易的事，因为它需要处理本地库和复杂的命令行接口。

幸运的是，jave-all-deps 库提供了一个简洁而强大的解决方案，让 Java 开发者能够轻松地进行音视频文件的转码和处理。

jave-all-deps 是 JAVE2（Java Audio Video Encoder）项目的一部分，它是一个基于 ffmpeg 项目的 Java 封装库。JAVE2 通过提供一套简单易用的 API，允许 Java 开发者在不直接处理 ffmpeg 复杂命令的情况下，进行音视频文件的格式转换、转码、剪辑等操作。

jave-all-deps 库特别之处在于它集成了核心 Java 代码和所有支持平台的二进制可执行文件，使得开发者无需手动配置 ffmpeg 环境，即可在多个操作系统上无缝使用。

是不是非常方便？

整体上来说，jave-all-deps 帮我们解决了三大类问题：

简单来说，就是你想在项目中使用 ffmpeg，但是又嫌麻烦，那么就可以使用 jave-all-deps 这个工具封装后的 ffmpeg，简单快捷！

二 具体用法

jave-all-deps 库提供了多种音视频处理功能，松哥这里来和大家演示几个常见的。

2.1 添加依赖

添加依赖有两种方式，一种就是添加所有的依赖库，如下：

<dependency>

 <groupId>ws.schild</groupId>

 <artifactId>jave-all-deps</artifactId>

 <version>3.5.0</version>

</dependency>

这个库中包含了不同平台所依赖的库的内容。

也可以根据自己平台选择不同的依赖库，这种方式需要首先添加 java-core：

<dependency>

    <groupId>ws.schild</groupId>

    <artifactId>jave-core</artifactId>

    <version>3.5.0</version>

</dependency>

然后再根据自己使用的不同平台，继续添加不同依赖库：

Linux 64 位 amd/intel：

<dependency>

    <groupId>ws.schild</groupId>

    <artifactId>jave-nativebin-linux64</artifactId>

    <version>3.5.0</version>

</dependency>

Linux 64 位 arm：

<dependency>

    <groupId>ws.schild</groupId>

    <artifactId>jave-nativebin-linux-arm64</artifactId>

    <version>3.5.0</version>

</dependency>

Linux 32 位 arm：

<dependency>

    <groupId>ws.schild</groupId>

    <artifactId>jave-nativebin-linux-arm32</artifactId>

    <version>3.5.0</version>

</dependency>

Windows 64 位：

<dependency>

    <groupId>ws.schild</groupId>

    <artifactId>jave-nativebin-win64</artifactId>

    <version>3.5.0</version>

</dependency>

MacOS 64 位：

<dependency>

    <groupId>ws.schild</groupId>

    <artifactId>jave-nativebin-osx64</artifactId>

    <version>3.5.0</version>

</dependency>

2.2 视频转音频

将视频文件从一种格式转换为另一种格式，例如将 AVI 文件转换为 MPEG 文件。

File source = new File("D:\\AI智能体\\mp4\\01.大模型有什么缺陷.mp4");

File target = new File("D:\\AI智能体\\mp4\\01.大模型有什么缺陷.mp3");

AudioAttributes audio = new AudioAttributes();

audio.setCodec("libmp3lame");

audio.setBitRate(128000);

audio.setChannels(2);

audio.setSamplingRate(44100);

EncodingAttributes attrs = new EncodingAttributes();

attrs.setOutputFormat("mp3");

attrs.setAudioAttributes(audio);

Encoder encoder = new Encoder();

encoder.encode(new MultimediaObject(source), target, attrs);

2.3 视频格式转换

将一种视频格式转换为另外一种视频格式，例如将 mp4 转为 flv：

File source = new File("D:\\AI智能体\\mp4\\01.大模型有什么缺陷.mp4");

File target = new File("D:\\AI智能体\\mp4\\01.大模型有什么缺陷.flv");

AudioAttributes audio = new AudioAttributes();

audio.setCodec("libmp3lame");

audio.setBitRate(64000);

audio.setChannels(1);

audio.setSamplingRate(22050);

VideoAttributes video = new VideoAttributes();

video.setCodec("flv");

video.setBitRate(160000);

video.setFrameRate(15);

video.setSize(new VideoSize(400, 300));

EncodingAttributes attrs = new EncodingAttributes();

attrs.setOutputFormat("flv");

attrs.setAudioAttributes(audio);

attrs.setVideoAttributes(video);

Encoder encoder = new Encoder();

encoder.encode(new MultimediaObject(source), target, attrs);

2.4 获取视频时长

这个就是松哥的需求了，我这块举个简单例子。

public class App {

    static SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("mm:ss");



    public static void main(String[] args) throws EncoderException {

        System.out.println("输入视频目录：");

        String dir = new Scanner(System.in).next();

        File folder = new File(dir);

        List<String> files = sort(folder);

        outputVideoTime(files);

    }



    private static void outputVideoTime(List<String> files) throws EncoderException {

        for (String file : files) {

            File video = new File(file);

            if (video.isFile() && !video.getName().startsWith(".") && video.getName().endsWith(".mp4")) {

                MultimediaObject multimediaObject = new MultimediaObject(video);

                long duration = multimediaObject.getInfo().getDuration();

                String s = "%s    %s";

                System.out.println(String.format(s, video.getName(), DATE_FORMAT.format(duration)));

            } else if (video.isDirectory()) {

                System.out.println(video.getName());

                outputVideoTime(sort(video));

            }

        }

    }



    public static List<String> sort(File folder) {

        return Arrays.stream(folder.listFiles()).map(f -> f.getAbsolutePath()).sorted(String.CASE_INSENSITIVE_ORDER).collect(Collectors.toList());

    }

}

这段代码基本上都是 Java 基础语法，没啥难的，我也就不多说了。有不明白的地方欢迎加松哥微信讨论。

其实 Java 解决这个似乎也不难，也就是 20 行代码左右，似乎和 Python 不相上下。

三 总结

jave-all-deps 库是 Java 音视频处理领域的一个强大工具，它通过封装 ffmpeg 的复杂功能，为 Java 开发者提供了一个简单易用的音视频处理解决方案。该库解决了跨平台兼容性问题、简化了复杂的命令行操作，并简化了项目中的依赖管理。无论是进行格式转换、音频转码还是其他音视频处理任务，jave-all-deps 库都是一个值得考虑的选择。

通过本文的介绍，希望能够帮助读者更好地理解和使用 jave-all-deps 库。

在实际开发中，我们经常会用到 127.0.0.1 和 localhost，那么，两者到底有什么区分呢？这篇文章，我们来详细了解 127.0.0.1 和 localhost。

127.0.0.1

127.0.0.1 是一个特殊的 IPv4 地址，通常被称为“环回地址”或“回送地址”。它被用于测试和调试网络应用程序。

当你在计算机上向 127.0.0.1 发送数据包时，数据不会离开计算机，而是直接返回到本地。这种机制允许开发者测试网络应用程序而不需要实际的网络连接。

127.0.0.1 是一个专用地址，不能用于实际的网络通信，仅用于本地通信。除了 127.0.0.1，整个 127.0.0.0/8（即 127.0.0.1 到 127.255.255.255）范围内的地址都是保留的环回地址。

在 IPv6 中，类似的环回地址是 ::1。如下图，为 MacOS的 /etc/hosts 文件中的内容：

使用场景

1. 开发和测试

• 开发人员常常使用127.0.0.1来测试网络应用程序，因为它不需要实际的网络连接。


• 可以在本地机器上运行服务器和客户端，进行开发和调试。
  2. 网络配置和诊断:


• 使用 ping 127.0.0.1 可以测试本地网络栈是否正常工作。


• 一些服务会绑定到 127.0.0.1 以限制访问范围，仅允许本地访问。

示例

运行一个简单的 Python HTTP 服务器并访问它：

python -m http.server --bind 127.0.0.1 8000

然后在浏览器中访问 http://127.0.0.1:8000，你会看到服务器响应。通过 127.0.0.1，开发人员和系统管理员可以方便地进行本地网络通信测试和开发工作，而不需要依赖实际的网络连接。

优点

缺点

localhost

localhost 是一个特殊的域名，指向本地计算机的主机名。

• 在 IPv4 中，localhost 通常映射到 IP 地址 127.0.0.1。


• 在 IPv6 中，localhost 通常映射到 IP 地址 ::1。

localhost 被定义在 hosts 文件中（例如，在 Linux 系统中是 /etc/hosts 文件）。如下图，为 MacOS的 /etc/hosts 文件中的内容：

因此，当你在应用程序中使用 localhost 作为目标地址时，系统会将其解析为 127.0.0.1，然后进行相同的环回处理。

使用场景

• 开发和测试：开发人员常使用localhost来测试应用程序，因为它不需要实际的网络连接。


• 本地服务：一些服务（如数据库、Web 服务器等）可以配置为只在localhost上监听，以限制访问范围仅限于本地计算机，增强安全性。


• 网络调试：使用localhost可以帮助诊断网络服务问题，确保服务在本地环境中正常运行。

优点

缺点

两者对比

• 本质：127.0.0.1 是一个 IP 地址，而 localhost 是一个主机名。


• 解析方式：localhost 需要通过 DNS 或 hosts 文件解析为 127.0.0.1，而 127.0.0.1 是直接使用的 IP 地址。


• 易用性：localhost 更容易记忆和输入，但依赖于正确的 DNS/hosts 配置。


• 性能：通常情况下，两者在性能上没有显著差异，因为 localhost 最终也会解析为127.0.0.1。

结论

127.0.0.1 和 localhost都是指向本地计算机的地址，适用于本地网络应用程序的测试和调试。选择使用哪个主要取决于个人偏好和具体需求。在需要明确指定 IP 地址的场景下，127.0.0.1 更为直接；而在需要易记和通用的主机名时，localhost 更为合适。两者在实际使用中通常是等价的，差别微乎其微。

机缘

机缘巧合之下获取到一个桌面端开发的任务。

为了最快的上手速度，最低的开发成本，选择了electron。

介绍

Electron是一个使用 JavaScript、HTML 和 CSS 构建桌面应用程序的框架。 嵌入 Chromium 和 Node.js 到 二进制的 Electron 允许您保持一个 JavaScript 代码代码库并创建 在Windows上运行的跨平台应用 macOS和Linux——不需要本地开发 经验。

主要结构

相关文章1
相关文章2

electron主要有一个主进程和一个或者多个渲染进程组成，方便的脚手架项目有
electron-vite

安装方式

npm i electron-vite -D

electron-vite分为3层结构

main // electron主进程

preload // electron预加载进程 node 

renderer // electron渲染进程 vue

创建项目

npm create @quick-start/electron

项目创建完成启动之后
会在目录中生成一个out目录

out目录中会生成项目文件代码，在electron-vite中使用ESmodel来加载文件，启动的时候会被全部打包到out目录中合并在一起。所以一些使用CommonJs的node代码复制进来需要做些修改。npm安装的依赖依然可以使用CommonJs的方式引入。

node的引入

在前面的推荐的几篇文章中都有详细的讲解，无需多言。electron是以chrom+node，所以node的加入也非常的简单。
nodeIntegration: true,

main主进程中的简单配置

preload目录下引入node代码，留一个口子在min主进程中调用。

配置数据库

以sequelize为例

npm install --save sequelize

npm install --save sqlite3

做本地应用使用推荐sqlite3，使用本地数据库，当然了用其他的数据也没问题，用法和node中一样。需要注意的是C++代码编译的问题，可能会存在兼容性问题，如果一直尝试还是报错就换版本吧。electron-vite新版本问题不大，遇到过老版本一直编译失败的问题

测试能让用版本

• "electron": "^25.6.0",


• "electron-vite": "^1.0.27",


• "sequelize": "^6.33.0",

node-gyp vscode 这些安装环境网上找找也很多就不多说了。

import { Sequelize } from 'sequelize'

import log from '../config/log/log'



const path = require('path')



let documentsPath



if (process.env['ELECTRON_RENDERER_URL']) {

  documentsPath = './out/config/sqlite/sqlite.db'

} else {

  documentsPath = path.join(process.env.USERPROFILE, 'Documents') + '\\sqlite\\sqlite.db'

}



console.log('documentsPath-------------****-----------', documentsPath)



export const seq = new Sequelize({

  dialect: 'sqlite',

  storage: documentsPath

})



seq

  .authenticate()

  .then(() => {

    log.info('数据库连接成功')

  })

  .catch((err) => {

    log.error('数据库连接失败' + err)

  })

终端乱码问题

"dev:win": "chcp 65001 && electron-vite dev",
chcp 65001只在win环境下添加

electron多页签

文章推荐

electron日志

import logger from 'electron-log'



logger.transports.file.level = 'debug'

logger.transports.file.maxSize = 30 * 1024 * 1024 // 最大不超过10M

logger.transports.file.format = '[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}]{scope} {text}' // 设置文件内容格式



var dayjs = require('dayjs')

const date = dayjs().format('YYYY-MM-DD') // 格式化日期为 yyyy-mm-dd



logger.transports.file.fileName = date + '.log' // 创建文件名格式为 '时间.log' (2023-02-01.log)



// 可以将文件放置到指定文件夹中，例如放到安装包文件夹中

const path = require('path')

let logsPath



if (process.env['ELECTRON_RENDERER_URL']) {

  logsPath = './out/config/logs/' + date + '.log'

} else {

  logsPath = path.join(process.env.USERPROFILE, 'Documents') + '\\logs\\' + date + '.log'

}



console.log('logsPath-------------****-----------', logsPath) // 获取到安装目录的文件夹名称



// 指定日志文件夹位置

logger.transports.file.resolvePath = () => logsPath



// 有六个日志级别error, warn, info, verbose, debug, silly。默认是silly

export default {

  info(param) {

    logger.info(param)

  },

  warn(param) {

    logger.warn(param)

  },

  error(param) {

    logger.error(param)

  },

  debug(param) {

    logger.debug(param)

  },

  verbose(param) {

    logger.verbose(param)

  },

  silly(param) {

    logger.silly(param)

  }

}

对应用做好日志维护是一个很重要的事情

主进程中也可以在main文件下监听

    app.on('activate', function () {

      // On macOS it's common to re-create a window in the app when the

      // dock icon is clicked and there are no other windows open.

      if (BrowserWindow.getAllWindows().length === 0) createWindow()

    })



    // 渲染进程崩溃

    app.on('renderer-process-crashed', (event, webContents, killed) => {

      log.error(

        `APP-ERROR:renderer-process-crashed; event: ${JSON.stringify(event)}; webContents:${JSON.stringify(

          webContents

        )}; killed:${JSON.stringify(killed)}`

      )

    })



    // GPU进程崩溃

    app.on('gpu-process-crashed', (event, killed) => {

      log.error(`APP-ERROR:gpu-process-crashed; event: ${JSON.stringify(event)}; killed: ${JSON.stringify(killed)}`)

    })



    // 渲染进程结束

    app.on('render-process-gone', async (event, webContents, details) => {

      log.error(

        `APP-ERROR:render-process-gone; event: ${JSON.stringify(event)}; webContents:${JSON.stringify(

          webContents

        )}; details:${JSON.stringify(details)}`

      )

    })



    // 子进程结束

    app.on('child-process-gone', async (event, details) => {

      log.error(`APP-ERROR:child-process-gone; event: ${JSON.stringify(event)}; details:${JSON.stringify(details)}`)

    })

应用更新

在Electron中实现自动更新，需要使用electron-updater

npm install electron-updater --save

需要知道服务器地址，单版本号有可更新内容的时候可以通过事件监听控制更新功能

provider: generic

url: 'http://localhost:7070/urfiles'

updaterCacheDirName: 111-updater

import { autoUpdater } from 'electron-updater'

import log from '../config/log/log'

export const autoUpdateInit = (mainWindow) => {

  let result = {

    message: '',

    result: {}

  }

  autoUpdater.setFeedURL('http://localhost:50080/latest.yml')



  //设置自动下载

  autoUpdater.autoDownload = false

  autoUpdater.autoInstallOnAppQuit = false



  // 监听error

  autoUpdater.on('error', function (error) {

    log.info('检测更新失败' + error)

    result.message = '检测更新失败'

    result.result = error

    mainWindow.webContents.send('update', JSON.stringify(result))

  })



  // 检测开始

  autoUpdater.on('checking-for-update', function () {

    result.message = '检测更新触发'

    result.result = ''

    // mainWindow.webContents.send('update', JSON.stringify(result))

    log.info(`检测更新触发`)

  })



  // 更新可用

  autoUpdater.on('update-available', (info) => {

    result.message = '有新版本可更新'

    result.result = info

    mainWindow.webContents.send('update', JSON.stringify(result))

    log.info(`有新版本可更新${JSON.stringify(info)}${info}`)

  })



  // 更新不可用

  autoUpdater.on('update-not-available', function (info) {

    result.message = '检测更新不可用'

    result.result = info

    mainWindow.webContents.send('update', JSON.stringify(result))

    log.info(`检测更新不可用${info}`)

  })



  // 更新下载进度事件

  autoUpdater.on('download-progress', function (progress) {

    result.message = '检测更新当前下载进度'

    result.result = progress

    mainWindow.webContents.send('update', JSON.stringify(result))

    log.info(`检测更新当前下载进度${JSON.stringify(progress)}${progress}`)

  })



  // 更新下载完毕

  autoUpdater.on('update-downloaded', function () {

    //下载完毕,通知应用层 UI

    result.message = '检测更新当前下载完毕'

    result.result = {}

    mainWindow.webContents.send('update', result)

    autoUpdater.quitAndInstall()

    log.info('检测更新当前下载完毕,开始安装')

  })

}



export const updateApp = (ctx) => {

  let message

  if (ctx.params == 'inspect') {

    console.log('检测是否有新版本')

    message = '检测是否有新版本'



    autoUpdater.checkForUpdates() // 开始检查是否有更新

  }

  if (ctx.params == 'update') {

    message = '开始更新'

    autoUpdater.downloadUpdate() // 开始下载更新

  }

  return (ctx.body = {

    code: 200,

    message,

    result: {

      currentVersion: 0

    }

  })

}