前言

就在昨天1024程序员节，JetBrains突然宣布WebStorm现在对非商业用途免费啦。以后大家再也不用费尽心思的去找破解方法了，并且公告中的关于非商业用途定义也很有意思。

加入欧阳的高质量vue源码交流群、欧阳平时写文章参考的多本vue源码电子书

为什么免费

在公告中的原话是：

我们希望新的许可模式将进一步降低使用 IDE 的门槛，帮助大家学习、成长并保持创造力。

欧阳个人还是觉得现在大家都在使用vscode或者Cursor。

如果我不想付费，那么我会选择开源的vscode，安装上插件后体验完全不输于WebStorm。

如果我想付费获得更好的体验，那么为什么不使用AI加持的Cursor呢？

前段时间网上有很多吸引人眼球的段子，比如：

我6岁的儿子使用Cursor开发了一个个人网站

又或者：

我是一名UI设计师，使用Cursor轻松的开发了一个APP

欧阳也一直在使用Cursor，虽然没有网上那些段子那样把Cursor吹的那么神。但是对于开发来说Cursor是真的很好用，经常觉得Cursor比我更知道我接下来应该写什么代码。如果我选择付费，为什么不考虑更加好用的Cursor呢？

不管是免费还是付费市场，vscode系的IDE已经占据了很大的比例。欧阳个人觉得WebStorm为了能够重新占据市场，所以选择推出非商业用途免费的WebStorm

非商业和商业有什么区别

非商业和商业的WebStorm区别只有一个，Code With Me 功能。如果是非商业的WebStorm里面的Code With Me 是社区版。

Code With Me是一个协作工具，允许多个开发者实时共享代码和协作编程。通过这项功能，用户可以在WebStorm、Rider等IDE中与他人共同编辑代码、进行调试和解决问题。

这个是Code With Me社区版和非社区版的区别：

如何判断是否是非商业

公告中的原文是：

商业产品是指有偿分发或提供、或者作为您的商业活动的一部分使用的产品。 但某些类别被明确排除在这一定义之外。 常见的非商业用例包括学习和自我教育、任何形式的内容创作、开源代码和业余爱好开发。

这不就是完全靠自觉吗？不需要证明我是用于非商业，欧阳觉得这是故意为之。

小公司使用Webstorm的非商业模式进行业务开发，人家看不上你，所以懒得搭理你。就像是以前在小公司里面使用破解版本的webstorm开发一样。

但是在公告中明确有写：

如果您使用非商业许可证，将无法选择退出匿名使用情况统计信息收集。 我们使用此类信息改进我们的产品。 这一规定与我们的抢先体验计划 (EAP) 类似，并符合我们的隐私政策。

意思是如果你使用了非商业版本，那么JetBrains就能拿到你的数据。

如果在大公司里面使用非商业模式进行业务开发，那么Webstorm在拿到数据的情况下就是一告一个准。就像是大公司里面禁止使用破解版本的webstorm开发业务一样，欧阳个人觉得有点像是钓鱼。

如何使用非商业版

使用方式很简单，首先从官网下载安装包。然后在对话框中选择非商业模式，如下图：

接着勾选协议，点击开始非商业使用，如下图：

此时会在浏览器中新开页面让你登录，登录方式有很多种：比如谷歌、GitHub、微信等。这里欧阳选择的是谷歌登录，如下图：

最后就成功啦，非商业有效期是一年，一年后会自动续订。

总结

WebStorm推出的非商业版免费对于开发者来说肯定是好事，特别是一些使用WebStorm的独立开发，还有小公司里面的开发，但是大公司里面想使用非商业版就需要三思了。

小学生万万没想到，做个加减乘除的口算练习题，都能被大学生、博士生、甚至是程序员大佬们暴打！

最近这款拥有 PK 功能的《小猿口算》App 火了，谁能想到，本来一个很简单的小学生答题 PK，竟然演变为了第四次忍界大战！

刚开始还是小学生友好 PK，后面突然涌入一波大学生来踢馆，被网友称为 “大学生炸鱼”；随着战况愈演愈烈，硕士生和博士生也加入了战场，直接把小学生学习软件玩成了电子竞技游戏，谁说大一就不是一年级了？这很符合当代大学生的精神状态。

然而，突然一股神秘力量出现，是程序员带着科技加入战场！ 自动答题一秒一道 ，让小学生彻底放弃，家长们也无可奈何，只能在 APP 下控诉严查外挂。

此时很多人还没有意识到，小学生口算 PK，已经演变为各大高校和程序员之间的算法学术交流竞赛！

各路大神连夜改进算法，排行榜上的数据也是越发离谱，甚至卷到了 0.1 秒一道题！

算法的演示效果，可以看我发的 B 站视频。

接口也是口，算法也是算，这话没毛病。

这时，官方不得不出手来保护小学生了，战况演变为官方和广大程序员的博弈。短短几天，GitHub 上开源的口算脚本就有好几页，程序员大神们还找到了多种秒速答题的方案。

官方刚搞了加密，程序员网友马上就成功解密，以至于 网传 官方不得不高价招募反爬算法工程师，我建议直接把这些开源大佬招进去算了。

实现方法

事情经过就是这样，我相信朋友们也很好奇秒答题目背后的实现原理吧，这里我以 GitHub 排名最高的几个脚本项目为例，分享 4 种实现方法。当然，为了给小学生更好的学习体验，这里我就不演示具体的操作方法了，反正很快也会被官方打压下去。

方法 1、OCR 识别 + 模拟操作

首先使用模拟器在电脑上运行 App，运用 Python 读取界面上特定位置的题目，然后运用 OCR 识别技术将题目图片识别为文本并输入给算法程序来答题，最后利用 Python 的 pyautogui 库来模拟人工点击和输入答案。

这种方法比较好理解，应用范围也最广，但缺点是识别效果有限，如果题目复杂一些，准确度就不好保证了。

详见开源仓库：github.com/ChaosJulien…

方法 2、抓包获取题目和答案

通过 Python 脚本抓取 App 的网络请求包，从中获取题目和答案，然后通过 ADB（Android Debug Bridge）模拟滑动操作来自动填写答案。然而，随着官方升级接口并加密数据，这种方法已经失效。

详见开源仓库：github.com/cr4n5/XiaoY…

方法 3、抓包 + 修改答案

这个方法非常暴力！首先通过抓包工具拦截口算 App 获取题目数据和答案的网络请求，然后修改请求体中的答案全部为 “1”，这样就可以通过 ADB 模拟操作，每次都输入 1 就能快速完成答题。 根据测试可以达到接近 0 秒的答题时间！

但是这个方法只对练习场有效，估计是练习场的答题逻辑比较简单，且没有像 PK 场那样的复杂校验。

详见开源仓库：github.com/cr4n5/XiaoY…

方法 4、修改 PK 场的 JavaScript 文件

这种方法就更暴力了！在 PK 场模式下，修改 App 内部的 JavaScript 文件来更改答题逻辑。通过分析 JavaScript 响应中的 isRight 函数，找到用于判定答案正确与否的逻辑，然后将其替换为 true，强制所有答案都判定为正确，然后疯狂点点点就行了。

详见开源仓库：github.com/cr4n5/XiaoY…

能这么做是因为 App 在开发时采用了混合 App 架构，一些功能是使用 WebView 来加载网页内容的。而且由于 PK 场答题逻辑是在前端进行验证，而非所有请求都发送到服务器进行校验，才能通过直接修改前端 JS 文件绕过题目验证。

官方反制

官方为了保护小学生学习的体验，也是煞费苦心。

首先加强了用户身份验证和管理，防止大学生炸鱼小学生；并且为了照顾大学生朋友，还开了个 “巅峰对决” 模式，让俺们也可以同实力竞技 PK。

我建议再增加一个程序员模式，也给爱玩算法的程序员一个竞技机会。

其实从技术的角度，要打击上述的答题脚本，并不难。比如检测 App 运行环境，发现是模拟器就限制答题；通过改变题目的显示方式来对抗 OCR 识别；通过随机展示部分 UI， 让脚本无法轻易通过硬编码的坐标点击正确的答案；还可以通过分析用户的答题速度和操作模式来识别脚本，比如答题速度快于 0.1 秒的用户，显然已经超越了人类的极限。

0.0 秒的这位朋友，是不是有点过分（强大）了？

但最关键的一点是，目前 App 的判题逻辑是在前端负责处理的，意味着题目答案的验证可以在本地进行，而不必与服务器通信，这就给了攻击者修改前端文件的机会。虽然官方通过接口加密和行为分析等手段加强了防御，但治标不治本，还是将判题逻辑转移到服务端，会更可靠。

当然，业务流程改起来哪有那么快呢？

不过现在的局面也不错，大学生朋友快乐了，程序员玩爽了，口算 App 流量赢麻了，可谓是皆大欢喜！

等等，好像有哪里不对。。。别再欺负我们的小学生啦！

更多

💻 编程学习交流：编程导航 📃 简历快速制作：老鱼简历 ✏️ 面试刷题神器：面试鸭

0x01

前几天，科技圈又一个爆款新闻相信不少同学都已经看到了。

那就是77岁的计算机科学家，同时也是一位享誉全球的人工智能专家 Geoffrey Hint0n 和 John J. Hopfield 一起，拿到了2024年诺贝尔物理学奖，以表彰他们通过人工神经网络实现机器学习的奠基性发现和发明。

消息一出，在科技届引起了一阵广泛的关注和讨论，以至于不少同学都发出感叹，“AI法力无边”、“人工智能终于不止是技术，而是科学了”。

而提到 Hint0n 这个名字，对于学习和从事AI人工智能和机器学习等领域的同学来说，应该都非常熟悉了。

Hint0n 是一位享誉全球的人工智能专家，被誉为“神经网络之父”、“深度学习的鼻祖”、“人工智能教父”等等，在这个领域一直以来都是最受尊崇的泰斗之一。

而上一次 Hint0n 站在聚光灯下则是5年前，彼时的 Hint0n 刚拿下2018年度图灵奖。

至此，AI教父 Hint0n 也成为了图灵奖和诺贝尔奖的双料得主！

0x02

大多人都是因为近年大火的AI才了解的Hint0n，但是他之前的人生经历也是相当富有戏剧性的。

1947年，Geoffrey Hint0n出生于英国温布尔登的一个知识分子家庭。

他的父亲Howard Everest Hint0n是一个研究甲壳虫的英国昆虫学家，而母亲Margaret Clark则是一名教师。

除此之外，他的高曾祖父George Boole还是著名的逻辑学家，也是现代计算科学的基础布尔代数的发明人，而他的叔叔Colin Clark则是一个著名的经济学家。

可以看到，Hint0n家庭里的很多成员都在学术和研究方面都颇有造诣。

当然，在这样的氛围下长大的Hint0n，其成长压力也是可想而知的。

1970年，23岁的Hint0n获得了实验心理学的学士学位。但是，令谁也没有想到的是，毕业后这位“学二代”由于找不到科研的意义，他竟然先跑去当了一段时间的木匠。

不过这个经历并没有帮助他消除自己的阶段性迷茫，他一直希望真正理解大脑的运作原理，渴望更深入的理论研究，于是经历过一番思想斗争后又下决心重返学术殿堂，投身于人工智能领域。

直到 1978 年，他终于获得了爱丁堡大学人工智能学博士学位，而此时的他也已经 31 岁了。

那个年代做深度学习的研究可以说是妥妥的冷板凳，因为你要知道当时的AI正值理论萌芽阶段，Hint0n所主张和研究的深度学习派更是不太为关注和认可。

那面对这一系列冷漠甚至反对，唯有纯粹的相信与热爱才能将这个领域深耕了数十年，直到后来 AI 时代的来临。

而这一切，Hint0n 都做到了。

0x03

Hint0n主要从事神经网络和机器学习的研究，在AI领域做出过许多重要贡献，其中最著名的当属他在神经网络领域所做的研究工作。

他在20世纪80年代就已经开启了反向传播算法（Back Propagation, BP算法）的研究，并将其应用于神经网络模型的训练中。这一算法被广泛应用于语音识别、图像识别和自然语言处理等领域。

除此之外，Hint0n还在卷积神经网络（Convolutional Neural Networks，CNN）、深度置信网络（Deep Belief Networks，DBN）、递归神经网络（Recursive Neural Networks，RNN）、胶囊网络（Capsule Network）等领域做出了重要贡献。

2013年，Hint0n加入Google，同时把机器学习相关的很多技术带进了谷歌，同时融合到谷歌的多项业务之中。

2019年3月，ACM公布了2018年度的图灵奖得主。

图灵奖大家都知道，是计算机领域的国际最高奖项，也被誉为“计算机界的诺贝尔奖”。

而Hint0n则与蒙特利尔大学计算机科学教授Yoshua Bengio和Meta首席AI科学家Yann LeCun一起因为研究神经网络而获得了该年度的图灵奖，以表彰他们在对应领域所做的杰出贡献。

除此之外，Hint0n在他的学术生涯中发表了数百篇论文，这些论文中提出了许多重要的理论和方法，涵盖了人工智能、机器学习、神经网络、计算机视觉等多个领域。

而且他的论文被引用的次数也是惊人，这对于这些领域的研究和发展都产生了重要的影响。

0x04

除了自身在机器学习方面的造诣很高，Hint0n同时也是一个优秀的老师。

当年为了扩大深度学习的圈子，Hint0n曾在多伦多大学成立过研究中心，专门接收有兴趣从事相关研究的年轻人，以至于现如今AI圈“半壁江山”都是他的“门生”。

Hint0n带过很多大牛学生，其中不少都被像苹果、Google等这类硅谷科技巨头所挖走，在对应的公司里领导着人工智能相关领域的研究。

这其中最典型的就是Ilya Sutskever，他是Hint0n的学生，同时他也是最近大名鼎鼎的OpenAI公司的联合创始人和首席科学家。

聊到这里，不得不感叹大佬们的创造力以及对这个领域所作出的贡献，同时也期待大佬们后续给大家带来更多精彩的故事。

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

打开服务器连接，找到文件夹，删掉，找到打包的目录，ctrl + C, ctrl + v 。。。。
烦的要死。。内网开发，node 的 ssh2 依赖库一时半会还导不进来。

索性，自己写一个！

原生 NodeJS 代码，不需要引用任何第三方库 win10 及以上版本，系统自带ssh 命令行工具，如果没有，需要自行安装

首先,需要生成本地秘钥；

ssh-keygen

执行上述命令后，系统会提示你输入文件保存位置和密码，如果你想使用默认位置和密码，直接按回车接受即可。这将在默认的SSH目录~/.ssh/下生成两个文件：id_rsa（私钥）和id_rsa.pub（公钥）

开启服务端使用秘钥登录

一般文件位置位于 /etc/ssh/sshd_config 中，

找到下面两行 ，取消注释，值改为 yes

RSAAuthentication yes

PubkeyAuthentication yes

将秘钥添加到服务端：

打开服务端文件 /root/.ssh/authorized_keys 将公钥 粘贴到新的一行中

重启服务端 ssh 服务

sudo service ssh restart

编写自动化上传脚本（nodejs 脚本）

// 创建文件 ./build/Autoactic.js



const { exec, spawn } = require('child_process');

const fs= require('fs');



// C:/Users/admin/.ssh/server/ServiceOptions.json

// 此处储存本地连接服务端相关配置数据（目的为不将秘钥暴露给 Git 提交代码）

// {

//     服务端关键字（记录为哪个服务器）

//     "Test90"： {

//         服务器登录用户名

//         "Target": "root@255.255.255.255",

//         本地证书位置（秘钥）

//         "Pubkey": "C:/User/admin/.shh/server/file"

//     }

// }



// 温馨提示 本机储存的秘钥需要调整权限，需要删除除了自己以外其他的全部用户

const ServiceOption = Json.parse(fs.readFileSync("C:/Users/admin/.ssh/server/ServiceOptions.json"), "utf-8");



// 本地项目文件路径（dist 打包后的实际路径）

const LocalPath = "D:/Code/rmgm/jilinres/jprmcrm/dev/admin/dist"；

// 服务端项目路径

const ServerPath = "/home/rmgmuser/web/pmr";



// 运行单行命令 （scp 命令，上传文件使用）

const RunSSHCode = function (code) {

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

        const process = exec(code, (error, sodut, stderr) => {

            if (error) {

                console.error(`执行错误： ${error}`)

                reject();

                return;

            };

            console.log(`sodut:${sodut}`);

            if (stderr) {

                console.error(`stderr:${stderr}`)

            };

            if (process && !process.killed){

                process.kill();

            };

            setTimeout(()=>{

                resolve();

            },10);

        })

    })

}



// 执行服务端命令 （执行 ssh 命令行）

const CommandHandle(command) {

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

        const child = spawn('ssh', ['-i', ServiceOption.Test90.Pubkey, '-o', 'StrictHostKeyChecking=no', ServiceOption.Test90.Target], {

            stdio: ['pipe']

        });

        child.on('close',(err)=>{

            console.log(`--close--:${err}`);

            if (err === 0) {

                setTimeout(()=>{ resolve() },10)

            } else {

                reject();

            }

        })

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

            console.error(`--error--:${err}`)

        });

        console.log(`--command--:${command}`);

        child.stdin.end(command);

        child.stdout.on('data',(data)=>{

            console.log(`Stdout:${data}`);

        })

        child.stderr.on('data',(data)=>{

            console.log(`Stdout:${data}`);

        })

    }

};





// 按照顺序执行代码

!(async function (CommandHandle, RunSSHCode){

    try {

        console.log(`创建文件夹 => ${ServerPath}`);

        await CommandHandle(`mkdir -p ${ServerPath}`);

        console.log(`创建文件夹 => ${ServerPath} => 完成`);

    

        console.log(`删除历史文件 => ${ServerPath}`);

        await CommandHandle(`find ${ServerPath} -type d -exec rm -rf {} +`);

        console.log(`删除历史文件 => ${ServerPath} => 完成`);

    

        console.log(`上传本地文件 => 从 本地 ${LocalPath} 到 服务端 ${ServerPath}`);

        await RunSSHCode(`scp -i ${serviceOption.Test90.pubkey} -r ${LocalPath}/ ${serviceOption.Test90.Target}:${ServerPath}/`);

        console.log(`上传本地文件 => 从 本地 ${LocalPath} 到 服务端 ${ServerPath} => 完成`);

        

        // 吉林环境个性配置 非必须（更改访问权限）

        console.log(`更改访问权限 => ${ServerPath}`);

        await CommandHandle(`chown -R rmgmuser:rmgmuser ${ServerPath}`);

        console.log(`更改访问权限 => ${ServerPath} => 完成`);

    

    } catch (error) {

        console.error(`---END---`, error)

    }

})(CommandHandle, RunSSHCode)

更改打包命令：

// package.json

{

    // ....

    "scripts": {

        // .....



        "uploadFile" : "node ./build/Autoactic.js"

        // 原始的 build 改为 prebuild 命令

        "preBuild" : "vue-cli-service build --mode production"

        // npm 按顺序运行多个命令行

        "build" : "npm run preBuild && npm run uploadFile"

        

         // .....

    }

    //... 

}

效果 打包结束后，直接上传到服务端。

有特殊需求，例如重启服务等，可自行添加。

写在前面

众所周知啊骑行🚲是一项非常健康、锻炼身体素质、拓宽视野的一项运动，在如今的2024年啊，越来越多的小孩年轻人等等各类人群都加入了骑行这项运动，哈哈本人也不例外😲，像今年的在中国举办的环广西更是加深了国内的骑行氛围，那导播的运镜水平相比去年越来越有观赏性。

在骑行过程中，其中一些想记录自己骑行数据的骑友会选择一些子骑行软件啊，比如像行者、Strva、捷安特骑行等等这些子，功能都非常丰富，他们都会有路线规划这个功能，大部分规划的方案我知道的大概分为 起始点规划、起始＋途径点规划、GPX文件导入这三个主要功能前二者都是靠输入明确地点来确定路线，对于没有明确骑行目的地、选择困难症的一些朋友想必是一大考验，于是我就在想可不可以在地图上画一个大概的线路来生成地图？答案是可以的！

技术分析

灵感来自高德app中运动的大栏中有一个跑步线路规划这一功能，其中的绘制路线就是我们想要的功能，非常方便在地图上画一个大概的线路，然后自动帮你匹配道路上，但是高德似乎没有道路匹配得API?

但是！他有线路纠偏这个功能，这个API大概的功能就是把你历史行进过的线路纠偏到线路上，我们可以将画好得线路模拟出一段行驶轨迹，模拟好方向角、时间和速度，就可以了，这就是我们下面要做得手绘线路这个功能，规划线路那肯定不能只有这一种这么单一啦，再加上一个支持添加途径点得线路规划功能岂不美哉？

效果截图和源码地址

UI截图

导出效果截图

仓库地址 ： github.com/zuowenwu/Li…

手绘线路+线路纠偏 代码实现

首先是要明确画线的操作，分三步：按下、画线和抬起的操作：

          

		this.map.on("touchstart", (e) => {});// 准备画线

		this.map.on("touchend", (e) => {});// 结束画线

		this.map.on("touchmove");// 画线中

最重要的代码是画线的操作，此时我们设置为地图不可拖动，然后记录手指在地图上的位置即可：

//路径

this.path = []

// 监听滑动配合节流（这里节流是为了减少采样过快避免造成不必要的开销）

this.map.on("touchmove",_.throttle((e) => {

    // 点

    const position = [e.lnglat.lng, e.lnglat.lat];



    // 数组长度为0则第一个点为起点marker

    if (!this.path.length) {

        this.path.push(position);

        new this.AMap.Marker({ map: this.map, position: position });

        return;

    }

    //满足两点创建线

    if (this.path.length == 1) {

		this.path.push(position);

		this.line = new this.AMap.Polyline({

			map: this.map,

			path: this.path,

			strokeColor: "#FF33FF",

			strokeWeight: 6,

			strokeOpacity: 0.5,

		});

		return;

     }

       //添加path

      if (this.path.length > 1) {

		this.path.push(position);

		this.line.setPath(this.path);

        }

    }, 30)

);

线连接好了，可以导出了！。。吗？那肯定不是，手指在屏幕上画线肯定会和道路有很大的偏差的，我们可以使用高德的线路纠偏功能，因为该功能需要方向角、速度和时间，我们可以把刚刚模拟的线路path设置一下：

let arr = this.path.map((item, index) => {

	// 默认角度

	let angle = 0;

	// 初始时间戳

	let tm = 1478031031;

	// 和下一个点的角度

	if (this.path[index + 1]) {

                // 计算与正北方向的夹角

                const north = turf.bearing(turf.point([item[0], item[1]]), turf.point([item[0], item[1] + 1]));

                // 使用正北方向的点 

                angle = north < 0 ? (360 + north) : north;

	}

	return {

		x: item[0], //经度

		y: item[1],//维度

		sp: 10,//速度

		ag: Number(angle).toFixed(0),//与正北的角度

		tm: !index ? tm : 1 + index,//时间

	};

});

这里的数据格式就是这样的：
要注意一下，第一个tm是初始的时间戳，后面都是在[index-1]+距离上次的时间，角度则是与正北方向的夹角而不是和上一个点的夹角，这里我差点弄混淆了

然后使用线路纠偏：

graspRoad.driving(arr, (error, result) => {

	if (!error) {

		var path2 = [];

		var newPath = result.data.points;

		for (var i = 0; i < newPath.length; i += 1) {

			path2.push([newPath[i].x, newPath[i].y]);

		}

		var newLine = new this.AMap.Polyline({

			path: path2,

			strokeWeight: 8,

			strokeOpacity: 0.8,

			strokeColor: "#00f",

			showDir: true,

		});

		this.map.add(newLine);

	}

});

绿色是手动画的线，蓝色是纠偏到道路上的线，可以看的出来效果还是很不错的

OK!接下来是导出手机或者码表使用的GPX格式文件的代码,这里使用插件geojson-to-gpx，直接npm i geojson-to-gpx即可，然后导入使用，代码如下：

import GeoJsonToGpx from "@dwayneparton/geojson-to-gpx";



// 转为GeoJSON

const geoJSON = turf.lineString(this.path);

const options = {

	metadata: {

		name: "导出为GPX",

		author: {

			name: "XiaoZuoOvO",

		},

	},

};

//转为geoJSON

const gpxLine = GeoJsonToGpx(geoJSON, options);

const gpxString = new XMLSerializer().serializeToString(gpxLine);

		

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

link.download = "高德地图路线绘制.gpx";

const blob = new Blob([gpxString], { type: "text/xml" });

link.href = window.URL.createObjectURL(blob);

link.click();

ElMessage.success("导出PGX成功");

好的，以上就是手绘线路的大概功能！接下来是我们的线路规划功能。

起终点和定义途径点的线路规划 代码实现

虽然说这个功能大多骑行软件都有，但是我们要做就做好用的，支持添加途径点，我们这里使用高德的线路规划2.0,这个API支持添加途径点，再配合上elementplus的el-autocomplete配合搜索，搜索地点使用搜索POI2.0来搜索地点，以下是代码实现，完整代码在github

//html

<el-autocomplete

	:prefix-icon="Location"

	v-model.trim="start"

	:trigger-on-focus="false"

	clearable

	size="large"

	placement="top-start"

	:fetch-suggestions="querySearch"

	@select="handleSelectStart"

	placeholder="起点" />

        

  //js

  

  //搜索地点函数

  const querySearch = async (queryString, cb) => {

            if (!queryString) return;

            const res = await inputtips(queryString);//inputtips是封装好的



            if (res.status == "1") {

                    const arr = res.tips.map((item) => {

                            return {

                                    value: item.name,

                                    name: item.name,

                                    district: item.district,

                                    address: item.address,

                                    location: item.location,

                            };

                    });

                    cb(arr);

                    return;

            }

};



//自行车路径规划函数

const plan = async () => {

	path = [];

	const res = await driving({

		origin: startPositoin.value,//起点

		destination: endPosition.value,//终点

		cartype: 1, //电动车/自行车

		waypoints: means.value.map((item) => item.location).join(";"),//途径点

	});



	if (res.status == "1") {

		

		res.route.paths[0].steps.map((item) => {

			const linestring = item.polyline;

			path = path.concat(

				linestring.split(";").map((item) => {

					const arr = item.split(",");

					return [Number(arr[0]), Number(arr[1])];

				})

			);

		});

	}

};





//......................完整代码见github..............................

搜索和规划效果截图：

以上就是手绘线路和途径点起点终点两个功能，接下来我们干个题外事，我们优化一下高德的 setCenter 和 setFitView,高德的动画太过于线性，我们这里模仿一下cesium和mapbox的效果，使用丝滑贝塞尔曲线来插值过度，配合高德Loca镜头动画

动画效果优化

首先是写一个setCenter，使用的时候传入即可，效果图和代码：

export function panTo(center, map, loca) {

	const curZoom = map.getZoom();

	const curPitch = map.getPitch();

	const curRotation = map.getRotation();

	const curCenter = [map.getCenter().lng, map.getCenter().lat];



	const targZoom = 17;

	const targPitch = 45;

	const targRotation = 0;

	const targCenter = center;



	const route = [

		{

			pitch: {

				value: targPitch,

				duration: 2000,

				control: [

					[0, curPitch],

					[1, targPitch],

				],

				timing: [0.420, 0.145, 0.000, 1],

			},

			zoom: {

				value: targZoom,

				duration: 2500,

				control: [

					[0, curZoom],

					[1, targZoom],

				],

				timing: [0.315, 0.245, 0.405, 1.000],

			},

			rotation: {

				value: targRotation,

				duration: 2000,

				control: [

					[0, curRotation],

					[1, targRotation],

				],

				timing: [1.000, 0.085, 0.460, 1],

			},

			center: {

				value: targCenter,

				duration: 1500,

				control: [curCenter, targCenter],

				timing: [0.0, 0.52, 0.315, 1.0],

			},

		},

	];



	// 如果用户有操作则停止动画

	map.on("mousewheel", () => {

		loca.animate.stop();

	});

	loca.viewControl.addAnimates(route, () => {});

	loca.animate.start();

}

接下来是setFitView:

export function setFitView(center, zoom, map, loca) {

	const curZoom = map.getZoom();

	const curPitch = map.getPitch();

	const curRotation = map.getRotation();

	const curCenter = [map.getCenter().lng, map.getCenter().lat];



	const targZoom = zoom;

	const targPitch = 0;

	const targRotation = 0;

	const targCenter = center;



	const route = [

		{

			pitch: {

				value: targPitch,

				duration: 1000,

				control: [

					[0, curPitch],

					[1, targPitch],

				],

				timing: [0.23, 1.0, 0.32, 1.0],

			},

			zoom: {

				value: targZoom,

				duration: 2500,

				control: [

					[0, curZoom],

					[1, targZoom],

				],

				timing: [0.13, 0.31, 0.105, 1],

			},

			rotation: {

				value: targRotation,

				duration: 1000,

				control: [

					[0, curRotation],

					[1, targRotation],

				],

				timing: [0.13, 0.31, 0.105, 1],

			},

			center: {

				value: targCenter,

				duration: 1000,

				control: [curCenter, targCenter],

				timing: [0.13, 0.31, 0.105, 1],

			},

		},

	];



	// 如果用户有操作则停止动画

	map.on("mousewheel", () => {

		loca.animate.stop();

	});



	loca.viewControl.addAnimates(route, () => {});



	loca.animate.start();

}



export function getFitCenter(points) {

	let features = turf.featureCollection(points.map((point) => turf.point(point)));

	let center = turf.center(features);

	return [center.geometry.coordinates[0], center.geometry.coordinates[1]];

}



export function setFitCenter(points, map) {

	const center = getFitCenter(points);

}





//使用

setFitView(getFitCenter(path), getFitZoom(map, path), map, loca);

结束

先贴上仓库地址：
github.com/zuowenwu/Li…

最后送几张自己拍的照片吧哈哈哈

昨天收拾屋子，翻出一台 lenovo A360e ，其搭载联了发科单核芯片（MT6567）的3G智能（Android 2.3.6）手机，上市于2012年，于2017年停产。其屏幕尺寸为3.5英寸，分辨率是480x320像素。具备重力感应、光线感应和距离传感器。

然而，现在是2024年。几乎没有什么应用可以在Android2.3上面跑了。

所以，打开 AndroidStudio，新建一个项目。

完犊子了，最低只支持Android5.0!

好吧，我立刻坐进时光机，穿越到2013年，拿到当年我的一台旧电脑。上面有Android2.2的开发环境。

新建一个 Android 2.2 的项目。

接下来就是 xml 布局。对于习惯 jetpack components的人来讲，xml布局简直就是一坨屎。但是没办法，为了能在 Android 2.3 上面跑，只好硬着头搞了。

首先画一个简单的布局图：

看起来有点复杂，其实一点也不简单。

但是，可以先做上下结构：

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:background="#000"

    tools:context="org.deviceartist.clock.FullscreenActivity" >

    <LinearLayout

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:orientation="vertical" >

     </LinearLayout>

</FrameLayout>

然后在下面的结构中，再分出一个左右结构：

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:background="#000"

    tools:context="org.deviceartist.clock.FullscreenActivity" >

    <LinearLayout

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:orientation="vertical" >

            <LinearLayout

                android:layout_width="match_parent"

                android:layout_height="wrap_content"

                android:gravity="center_horizontal" >

            </LinearLayout>

            <LinearLayout

                android:layout_width="match_parent"

                android:layout_height="250sp"

                android:gravity="center_vertical" >

            </LinearLayout>

     </LinearLayout>

</FrameLayout>

然后按照布局图写 xml 的 layout 文件：

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:background="#000"

    tools:context="org.deviceartist.clock.FullscreenActivity" >

        <LinearLayout

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:orientation="vertical" >



            <LinearLayout

                android:layout_width="match_parent"

                android:layout_height="wrap_content"

                android:gravity="center_horizontal" >



                <TextView

                    android:id="@+id/tab1"

                    android:layout_width="50sp"

                    android:layout_height="30sp"

                    android:layout_weight="1"

                    android:gravity="left"

                    android:padding="0dp"

                    android:text="STAT"

                    android:textColor="@color/green"

                    android:textSize="22sp" />

                

                <TextView

                    android:id="@+id/tab2"

                    android:layout_width="50sp"

                    android:layout_height="30sp"

                    android:layout_weight="1"

                    android:gravity="center"

                    android:padding="0dp"

                    android:text="INV"

                    android:textColor="@color/green"

                    android:textSize="22sp" />

                

                <TextView

                    android:id="@+id/tab3"

                    android:layout_width="50sp"

                    android:layout_height="30sp"

                    android:layout_weight="2"

                    android:gravity="center"

                    android:padding="0dp"

                    android:text="DATA"

                    android:textColor="@color/green"

                    android:textSize="22sp" />

                

                <TextView

                    android:id="@+id/tab4"

                    android:layout_width="50sp"

                    android:layout_height="30sp"

                    android:layout_weight="1"

                    android:gravity="center"

                    android:padding="0dp"

                    android:text="MAP"

                    android:textColor="@color/green"

                    android:textSize="22sp" />

                

                <TextView

                    android:id="@+id/tab5"

                    android:layout_width="50sp"

                    android:layout_height="30sp"

                    android:layout_weight="1"

                    android:gravity="right"

                    android:padding="0dp"

                    android:text="TERMUX"

                    android:textColor="@color/green"

                    android:textSize="22sp" />



            </LinearLayout>



            <LinearLayout

                android:layout_width="match_parent"

                android:layout_height="250sp"

                android:gravity="center_vertical" >



                <TextView

                    android:id="@+id/textViewTime"

                    android:layout_width="210sp"

                    android:layout_height="200sp"

                    android:textSize="100sp" />

                <TextView

                    android:id="@+id/textViewTimeS"

                    android:gravity="center"

                    android:layout_width="50sp"

                    android:layout_height="150sp"

                    android:textSize="20sp" />



                <org.deviceartist.clock.MyCanvas

                    android:id="@+id/myCanvas"

                    android:layout_width="200sp"

                    android:layout_height="200sp" />

            </LinearLayout>

        </LinearLayout>

</FrameLayout>

相应的 java 代码

package org.deviceartist.clock;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Locale;

import java.util.Timer;

import org.deviceartist.clock.util.SystemUiHider;

import android.annotation.SuppressLint;

import android.annotation.TargetApi;

import android.app.Activity;

import android.graphics.Typeface;

import android.os.Build;

import android.os.Bundle;

import android.os.Handler;

import android.view.MotionEvent;

import android.view.View;

import android.view.View.OnClickListener;

import android.view.Window;

import android.view.WindowManager;

import android.widget.Button;

import android.widget.TextView;



public class FullscreenActivity extends Activity {

	@Override

	protected void onCreate(Bundle savedInstanceState) {

		super.onCreate(savedInstanceState);

		requestWindowFeature(Window.FEATURE_NO_TITLE);

		if (Build.VERSION.SDK_INT < 16) {

                getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);

	    }

		setContentView(R.layout.activity_fullscreen);		

		Typeface typeface = Typeface.createFromAsset(this.getAssets(), "fonts/font.ttf");

		

		final TextView textViewTime = (TextView) findViewById(R.id.textViewTime);

		final TextView textViewTimeS = (TextView) findViewById(R.id.textViewTimeS);

		final MyCanvas c = (MyCanvas) findViewById(R.id.myCanvas);

		textViewTime.setTextColor(0xff5CB31D);

		textViewTime.setTypeface(typeface);

		textViewTimeS.setTextColor(0xff5CB31D);

		textViewTimeS.setTypeface(typeface);

		final Handler handler = new Handler();

		Runnable runnable = new Runnable(){

			@Override

			public void run() {

				String currentTime = new SimpleDateFormat("HH\nmm",Locale.getDefault()).format(new Date());

				textViewTime.setText(currentTime);

				String currentTimeS = new SimpleDateFormat("ss",Locale.getDefault()).format(new Date());

				textViewTimeS.setText(currentTimeS);

				handler.postDelayed(this, 1000);

			}	

		};

		handler.postDelayed(runnable, 0);

		final Handler handler2 = new Handler();

		Runnable runnable2 = new Runnable(){

			@Override

			public void run() {

				c.next();

				handler.postDelayed(this, 100);

			}

		};

		handler2.postDelayed(runnable2, 100);

	}

}

知识点：

1、定时器

final Handler handler = new Handler();

    Runnable runnable = new Runnable(){

    @Override

    public void run() {

        //todo

    }

};		

handler.postDelayed(runnable, 0);

2、Canvas画布就是自定义的View类

关键代码：

package org.deviceartist.clock;



import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.Locale;



import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Matrix;

import android.graphics.Paint;

import android.os.Handler;

import android.util.AttributeSet;

import android.view.View;



public class MyCanvas extends View {

	

	private Paint paint;

	Canvas canvas;



	public MyCanvas(Context context) {

		super(context);

		init();

	}



	public MyCanvas(Context context, AttributeSet attrs) {

		super(context, attrs);

		init();

	}



	public MyCanvas(Context context, AttributeSet attrs, int defStyleAttr) {

		super(context, attrs, defStyleAttr);

		init();

	}



	private void init() {

		paint = new Paint();

		paint.setColor(0xff5CB31D);

		paint.setStyle(Paint.Style.FILL);

	}



	protected void onDraw(Canvas canvas) {

		super.onDraw(canvas);

	}

}

全部代码：

package org.deviceartist.clock;



import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.Locale;



import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Matrix;

import android.graphics.Paint;

import android.os.Handler;

import android.util.AttributeSet;

import android.view.View;



public class MyCanvas extends View {



	private int index = 0;

	ArrayList<Bitmap> bitmaps = new ArrayList<>();



	Bitmap voltage;

	Bitmap nuclear;

	Bitmap shield;

	Bitmap aim;

	Bitmap gun;

	Bitmap helmet;

	

	private Paint paint;

	Canvas canvas;



	public MyCanvas(Context context) {

		super(context);

		init();

		// TODO Auto-generated constructor stub

	}



	public MyCanvas(Context context, AttributeSet attrs) {

		super(context, attrs);

		init();

	}



	public MyCanvas(Context context, AttributeSet attrs, int defStyleAttr) {

		super(context, attrs, defStyleAttr);

		init();

	}



	private void init() {

		 

		

		voltage = BitmapFactory.decodeResource(getResources(),

				R.drawable.voltage);

		nuclear = BitmapFactory.decodeResource(getResources(),

				R.drawable.nuclear);

		shield  = BitmapFactory.decodeResource(getResources(),

				R.drawable.shield);

		aim  = BitmapFactory.decodeResource(getResources(),

				R.drawable.aim);

		gun  = BitmapFactory.decodeResource(getResources(),

				R.drawable.gun);

		helmet  = BitmapFactory.decodeResource(getResources(),

				R.drawable.helmet);

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy1));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy2));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy3));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy4));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy5));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy6));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy7));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy8));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy9));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy10));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy11));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy12));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy13));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy14));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy15));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy16));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy17));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy18));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy19));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy10));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy11));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy12));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy13));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy14));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy15));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy16));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy17));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy18));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy19));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy20));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy21));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy22));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy23));

		bitmaps.add(BitmapFactory.decodeResource(getResources(),

				R.drawable.boy24));



		paint = new Paint();

		paint.setColor(0xff5CB31D); // 设置圆形的颜色

		paint.setStyle(Paint.Style.FILL); // 设置填充样式

	}



	void next() {

		index += 1;

		index += 1;

		if (index == 24) {

			index = 0;

		}

		invalidate();

	}



	protected void onDraw(Canvas canvas) {

		this.canvas = canvas;

		

		super.onDraw(canvas);

		

		Bitmap bitmap =  bitmaps.get(index);

		int w = bitmap.getWidth();

		int h = bitmap.getHeight();

		

		// 获取View的中心点坐标

		int x = getWidth() / 2 - w/2;

		int y = getHeight() / 2 - h/2;

		

		canvas.drawBitmap(bitmap, x, y, paint);

		

		

		canvas.drawLine(10, 20, 55, 20, paint);

		canvas.drawLine(55, 20, 90, 70, paint);

		canvas.drawBitmap(shield, 10, 30, paint);

		

		

		canvas.drawLine(50, getHeight()/2, 100, getHeight()/2, paint);

		canvas.drawText("98%", 50, getHeight()/2-10, paint);

		canvas.drawBitmap(voltage, 10, getHeight()/2-30, paint);

		

		

		canvas.drawLine(10, getHeight()-30, 90, getHeight()-30, paint);

		canvas.drawLine(90, getHeight()-30, 100, getHeight()-80, paint);

		canvas.drawBitmap(gun, 10, getHeight()-90, paint);

		

		canvas.drawLine(getWidth()-30, 20, getWidth(), 20, paint);

		canvas.drawLine(getWidth()-30, 20, getWidth()-90, 70, paint);

		canvas.drawBitmap(aim, getWidth()-40, 30, paint);		

		

		

		canvas.drawLine(getWidth()-110, getHeight()/2, getWidth()-50, getHeight()/2, paint);

		canvas.drawText("9.9", getWidth()-80, getHeight()/2-10, paint);

		canvas.drawBitmap(nuclear, getWidth()-50, getHeight()/2-30, paint);

		

		canvas.drawLine(getWidth()-100, getHeight()-80, getWidth()-70, getHeight()-30, paint);

		canvas.drawLine(getWidth()-70, getHeight()-30, getWidth(), getHeight()-30, paint);

		canvas.drawBitmap(helmet, getWidth()-70, getHeight()-90, paint);



	}

}

最终效果

源码地址：
git.sr.ht/~devicearti…

背景介绍

最近公司有个需求，要在浏览器端生成一大堆的 word 文件并保存到本地。

生成 word 文件直接用了docx这个库，嗖的一下很快就搞定了。但是交付给需求方的时候他们却说生成的文件乱糟糟的放在下载目录里面他们看着烦，而且还要手动整理每一批文件，问我能不能搞成一个压缩包。我一听这个要求，心想：不就是调的包的事吗，二话不说马上就答应了。

然而，，，，，

搜了很久，也没有找到直接马上就可以用的 js 库来将一大堆文件直接变成一个压缩包。又搜了一下 zip 的文件格式内容，发现好像不是很复杂。那就自己来搞一个包吧。

太长不看？直接用 zip-saver

一、zip 文件格式简介

zip 文件大致可以分成三个个部分：

1. 文件部分
   • 文件部分包含了所有的文件内容，每个文件都有一个文件头，文件头包含了文件的元信息，比如文件名、文件大小、文件的压缩方式等等。
2. 中央目录部分
   • 中央目录部分包含了所有文件的元信息，比如文件名、文件大小、文件的压缩方式等等。
3. 目录结束标识 - 目录结束标识标识了中央目录部分的结束。包含了中央目录的开始位置、中央目录的大小等信息。  图片来自：en.wikipedia.org/wiki/ZIP_(f…

对于每一个文件，他在 zip 中包含三部分

1. 本地文件头（ Local File Header）-- 图片来自：goodapple.top/archives/70…

2. 文件内容
3. 数据描述符（ Data descriptor）-- 图片来自：goodapple.top/archives/70…

数据描述符是可选的，当本地文件头中没有指明 CRC-32 校验码和压缩前后的长度时，才需要数据描述符

中央目录区的数据构成是这样的 -- 图片来自：goodapple.top/archives/70…

目录结束标识的数据构成是这样的 -- 图片来自：goodapple.top/archives/70…

二、代码实现

有了上面的信息之后，不难想到生成一个 zip 文件的步骤：

1. 生成文件部分
   1. 构造固定的文件信息头
   2. 追加文件内容
   3. 计算文件的 CRC32 校验码
   4. 生成数据描述符
2. 生成中央目录部分
   1. 构造固定的中央文件信息头
   2. 计算文件的偏移量
3. 生成目录结束标识
   1. 构造固定的目录结束标识
   2. 计算中央目录的大小和偏移

1. 生成本地文件头（local file header）

根据local file header的结构，我们很容易得知：一个local file header 的大小是 30 + n + m 个字节

其中n是文件名的长度，m是扩展字段的长度，在这里我们不考虑扩展字段，那么最终大小就是30 + n

在js中我可以直接用Uint8Array来存储一个字节，又因为 zip 是采用小端序，为了方便操作， 那么local file header变量就可以这样定义:

const length = 30 + filenameLength

const localFileHeaderBytes = new Uint8Array(length)

// 使用DataView可以更方便的操作小端序数据

const localFileHeaderDataView = new DataView(localFileHeaderBytes.buffer)

定义完 local file header 变量后我们就可以往里面塞一些东西了

// local file header 的起始固定值为 0x04034b50

// setUint第一个参数为偏移量，第二个参数是值，第三个参数为true表示以小端序存储

localFileHeaderDataView.setUint32(0, 0x04034b50, true)

// 设置最低要求的版本号为 0x14

localFileHeaderDataView.setUint16(4, 0x0014, true)

// 设置通用标志位为 0x0808

// 0x0808 使用UTF-8编码且文件头中不包含CRC32和文件大小信息

localFileHeaderDataView.setUint16(6, 0x0808, true)



// 设置压缩方式为 0x0000 表示不压缩

localFileHeaderDataView.setUint16(8, 0x0000, true)

// 设置最后修改时间, 这里假设最后修改时间为当前时间

const lastModified = new Date().getTime()

// last modified time

localFileHeader.setUint16(

  10,

  (date.getUTCHours() << 11) |

    (date.getUTCMinutes() << 5) |

    (date.getUTCSeconds() / 2)

)



// last modified date

localFileHeader.setUint16(

  12,

  date.getUTCDate() |

    ((date.getUTCMonth() + 1) << 5) |

    ((date.getUTCFullYear() - 1980) << 9)

)



// 设置文件名的长度，这里假设文件名已经转换成了字节数组nameBytes

localFileHeaderDataView.setUint16(26, nameBytes.length, true)



// 设置文件名

localFileHeaderBytes.set(nameBytes, 30)

到此，一个local file header就生成好了

2. 文件内容追加

文件内容追加这一步很简单，这里我们不考虑压缩文件，直接将文件转为Uint8Array 并计算文件的 CRC32 校验码，然后追加到local file header后面即可

    const crc = new CRC32()

    // 获取file数据备用

    const fileBytes = await file.arrayBuffer()

    crc.append(fileBytes)

3. 数据描述符（Data descriptor）生成

数据描述符用来表示文件压缩与的结束，根据他的编码格式，他包含的信息只有四个：固定的标识符、CRC-32校验码，压缩前的大小，压缩后的大小，这里我们暂且不考虑数据的压缩, 要生成他也很简单:

    const dataDescriptor = new Uint8Array(16)

    const dataDescriptorDataView = new DataView(dataDescriptor.buffer)

    // 0x08074b50 是数据描述符的固定标识字段

    dataDescriptorDataView.setUint32(0, 0x08074b50, true)

    // CRC-32校验码

    dataDescriptorDataView.setUint32(4, crc.value, true)

    // 压缩前的大小

    dataDescriptorDataView.setUint32(8, fileBytes.length, true)

    // 压缩后的大小

    dataDescriptorDataView.setUint32(12, fileBytes.length, true)

至此，一个文件在zip中所有的信息就已经都可以生成了，接下来就需要生成中央目录信息了

4. 中央目录区生成

根据上面的图，我们知道， 中央目录区也是由一个一个的文件头组成，每一个文件头对对应着一个真实文件的信息，每个文件信息大小是46 + n + m + k，其中n是文件名称的大小，m是扩展字段的大小，k是文件注释的大小。 在这里，我们可以暂时不必管扩展字段，先计算一下中央目录区的总大小：

    // 假设有一个文件列表为flieList

    const wholeLength = flieList.reduce((acc, file) => {

      // 文件名长度

      const nameBufferLength = textEncoder.encode(file.name).length

      // 假设文件有注释字段comment

      const commentBufferLength = textEncoder.encode(file.comment).length

      // 累加起来

      return acc + 46 + nameBufferLength + commentBufferLength

    }, 0)

然后，创建一个变量存储中央目录区的数据

const centraHeader = new Uint8Array(wholeLength)

const centraHeaderDataView = new DataView(dataDescriptor.buffer)

接下来就可以通过循环，将所有文件的信息都写入中央目录区

    // 假设有这样一个数据结构存储了文件的信息

    type FileZipInfo = {

        localFileHeader: Uint8Array

        fileBytes: Uint8Array

        dataDescriptor: Uint8Array

        filename: string

        fileComment: string

    }

    

    // offset表示中央目录信息中，当前文件相对于中央目录起始位置的偏移

    // entryOffset 表示一个文件的信息（本地文件头+文件数据+数据描述符）相对于整个zip文件起始位置的偏移

    let entryOffset = 0

    

    for (

      let i = 0, offset = 0;

      i < fileZipInfoList.length;

      i++

    ) {

        const fileZipInfo = fileZipInfoList[i]

        // 设置固定标识符号

        centraHeaderDataView.setUint32(offset, 0x02014b50, true)

        // 设置压缩版本号

        centraHeaderDataView.setUint16(offset + 4, 0x0014， true)

        // 因为中央目录信息中的文件数据一大部份都是本地文件头数据的冗余，所以可以直接复制过来使用

        centraHeader.set(fileZipInfo.localFileHeader.slice(4, 30), offset + 6)

        

        const textEncoder = new TextEncoder()

        // 注释长度

        const commentBuffer = textEncoder.encode(fileZipInfo.fileComment)

        centraHeaderDataView.setUint16(offset + 32, commentBuffer.length, true)

        

        // 对应的本地文件头在整个zip文件中的偏移

        centraHeaderDataView.setUint32(offset + 42, entryOffset, true)

        

        // 文件名

        const filenameBuffer = textEncoder.encode(fileZipInfo.filename)

        centraHeaderDataView.setUint16(filenameBuffer, offset + 46)

        

        // 扩展字段暂时不管，下一个直接设置文件注释

        bufferDataView.set(commentBuffer, offset + 46 + filenameBuffer.length)

        

        // 更新offset的值

        // 下一个中央目录中的文件的offset的值为此次生成的文件信息大小 + 当前的offset

        // 也就是

        offset = offset + 46 + commentBuffer.length + filenameBuffer.length

        

        // entryOffset 的值累加为当前文件信息在整个zip文件中的大小 + 当前的 entryOffset

        entryOffset += fileZipInfo.localFileHeader.length + fileZipInfo.fileBytes.length + fileZipInfo.dataDescriptor.length

        

        

    }

    

最后，再生成 目录结束标识

    // 目录结束标识的大小为22 + 注释信息（注释信息先忽略）

    const eocdBytes = new Uint8Array(22)

    const eocdDataView = new DataView(eocd.buffer)

    

    // 固定标识值

    eocdDataView.setUint32(eocdOffset, 0x06054b50, true)

    

    // 和分卷有关的数据都可以忽略，他主要是为了处理一个zip文件跨磁盘存储的问题，现在基本没有这种场景

    // 当前分卷号

    eocdDataView.setUint16(4, 0, true)

    // 中央目录开始分卷号

    eocdDataView.setUint16(6, 0, true)

    // 当前分卷的总文件数量

    eocdDataView.setUint16(8, fileZipInfoList.length, true)

    // 总文件数量

    eocdDataView.setUint16(10, fileZipInfoList.length, true)

    // 中央目录的总大小

    eocdDataView.setUint32(12, wholeLength, true)

    // 中央目录在整个zip文件中的目录偏移

    eocdDataView.setUint32(16, entryOffset, true)

    // 最后是注释的信息，先忽略

    

5. 拼接完整数据

完成了上面所有的步骤之后，我们只需要把数据都拼接起来就可以了

// 所有文件数据都存储在 fileZipInfoList中



// 组合文件数据

const fileBytesList = fileZipInfoList.map(fileZipInfo => {

    return new Uint8Array([

        ...fileZipInfo.localFileHeader,

        ...fileZipInfo.fileBytes,

        ...fileZipInfo.dataDescriptor

    ])

})



const zipBlob = new Blob([

    ...fileBytesList,

    centraHeader,

    eocdBytes

],{

    type: 'application/zip'

})

ok，搞定！

6. 完整的实现

github.com/EatherToo/z…

三、总结

经过上面的步骤，我们就可以生成一个zip文件了，当然，这里只是一个简单的实现，zip文件格式还有很多细节，比如压缩算法、加密压缩等等，这里都没有涉及到，后面有时间再来完善吧。

参考资料：

• goodapple.top/archives/70…
• en.wikipedia.org/wiki/ZIP_(f…
• github.com/jimmywartin…

作者：EatherToo
来源：juejin.cn/post/7430660826900185097

大家好，我是前端林叔。

今年我github的vue-office文档预览库star已经达到了3600+，不过这个库没什么技术含量，只不过是站在前人的肩膀上简单封装了下。目前该库包含了word（docx）、excel（xls、xlsx）和pdf的预览，唯独缺少ppt文档的预览，很多朋友都提过，能不能做一个ppt的预览库，我一直也在纠结。

为什么迟迟不做ppt的预览库

说到底，还是收益的问题，我做这件事的收益到底是什么？

一般来说做一个开源库我们会有以下几个收益：

• 证明自己的技术实力，在找工作时增加自己的竞争力（回答面试官经常问的那个问题，怎么证明你的技术深度？）


• 锻炼自己的技术能力，做一个好的开源项目需要一定的技术功底，在实战中提升自己是最快的方式


• 反哺开源社区，用爱发电，提升社区知名度


• 做得好了还可以考虑商业化赚钱

我迟迟没有做这件事就是没有想好我到底要什么，而且今年一直在忙着写掘金小册，也确实没有时间，另外就是在做vue-office库的时候，真切的感觉到，用爱发电是不长久的，如果没有利益驱动，是很难坚持下去的，试问，在如今行情这么不好的情况下，怎么平衡工作和自己的业余爱好，每个周末都去免费解决用户的问题，谁能长久地坚持下去呢？

为什么又决定做了

最近正好小册已经完结了（估计最近就会上线），自己也闲下来了，突然感觉失去了方向，不知道做啥了，整个人都变得迷茫，而且能预期到明年裁员的大刀就要砍到自己头上了，也要为后面的面试做下准备了，毕竟年龄大了，没有拿得出手的技术作品，想必后面也是很难的，把近期想做的事情排了个优先级，觉得这个事情还是比较重要的，于是决定开干！

但对于选择开源还是闭源纠结了很久，开源的话比较容易积累star，但主要还是精神支持，对长期利益来看是好的；不过开源后代码很容易被人拷贝改做他用，将自己辛辛苦苦几个月的成果免费拿走，还是不太甘心（这里忏悔下自己的格局）。我最终决定还是闭源，打赏一定金额（比如50以上）可以索取源码，源码不得用于开源，仅做学习和自己项目使用，后期可以考虑开发企业版，通过license授权。

这么做肯定会被人骂的，不过没办法，免费的事情实在坚持不下去了。当然了，只是不免费开放源码，使用都是免费的，会把最终的库发布到npm。

可行性

对于pptx格式的文件，实际上可以看做一个压缩文件，我们把任意一个pptx文件的后缀改为zip，然后解压，就可以看到pptx文件的内容，大部分都是xml文件，我们可以通过分析这个xml中的内容来获取ppt文档的信息，文档符合Microsoft Open XML（简称OOXML）规范。而对于.ppt格式的文件则无法获取其具体格式，所以本库只支持.pptx格式的文件。

说起来容易，不过由于xml的格式比较晦涩难懂，分析过程还是非常痛苦的，下面是ppt中单个幻灯片的xml，可以体会下其中的复杂度。

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

<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"

       xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"

       xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">

    <p:cSld>

        <p:bg>

            <p:bgPr>

                <a:solidFill>

                    <a:schemeClr val="accent2">

                        <a:alpha val="34902"/>

                    </a:schemeClr>

                </a:solidFill>

                <a:effectLst/>

            </p:bgPr>

        </p:bg>

        <p:spTree>

            <p:nvGrpSpPr>

                <p:cNvPr id="1" name=""/>

                <p:cNvGrpSpPr/>

                <p:nvPr/>

            </p:nvGrpSpPr>

            <p:grpSpPr>

                <a:xfrm>

                    <a:off x="0" y="0"/>

                    <a:ext cx="0" cy="0"/>

                    <a:chOff x="0" y="0"/>

                    <a:chExt cx="0" cy="0"/>

                </a:xfrm>

            </p:grpSpPr>

            <p:pic>

                <p:nvPicPr>

                    <p:cNvPr id="2" name="图片 1">

                        <a:extLst>

                            <a:ext uri="{FF2B5EF4-FFF2-40B4-BE49-F238E27FC236}">

                                <a16:creationId xmlns:a16="http://schemas.microsoft.com/office/drawing/2014/main"

                                                id="{92992223-295D-7122-C034-29375CD12672}"/>

                            </a:ext>

                        </a:extLst>

                    </p:cNvPr>

                    <p:cNvPicPr>

                        <a:picLocks noChangeAspect="1"/>

                    </p:cNvPicPr>

                    <p:nvPr/>

                </p:nvPicPr>

                <p:blipFill>

                    <a:blip r:embed="rId2"/>

                    <a:stretch>

                        <a:fillRect/>

                    </a:stretch>

                </p:blipFill>

                <p:spPr>

                    <a:xfrm>

                        <a:off x="1270000" y="635000"/>

                        <a:ext cx="1485900" cy="787400"/>

                    </a:xfrm>

                    <a:prstGeom prst="rect">

                        <a:avLst/>

                    </a:prstGeom>

                </p:spPr>

            </p:pic>

            <p:pic>

                <p:nvPicPr>

                    <p:cNvPr id="5" name="图片 4">

                        <a:extLst>

                            <a:ext uri="{FF2B5EF4-FFF2-40B4-BE49-F238E27FC236}">

                                <a16:creationId xmlns:a16="http://schemas.microsoft.com/office/drawing/2014/main"

                                                id="{D071BB10-9D98-FEF0-768B-8E826152F476}"/>

                            </a:ext>

                        </a:extLst>

                    </p:cNvPr>

                    <p:cNvPicPr>

                        <a:picLocks noChangeAspect="1"/>

                    </p:cNvPicPr>

                    <p:nvPr/>

                </p:nvPicPr>

                <p:blipFill rotWithShape="1">

                    <a:blip r:embed="rId3"/>

                    <a:srcRect r="46000"/>

                    <a:stretch/>

                </p:blipFill>

                <p:spPr>

                    <a:xfrm>

                        <a:off x="0" y="0"/>

                        <a:ext cx="685800" cy="1270000"/>

                    </a:xfrm>

                    <a:prstGeom prst="rect">

                        <a:avLst/>

                    </a:prstGeom>

                </p:spPr>

            </p:pic>

            <p:sp>

                <p:nvSpPr>

                    <p:cNvPr id="3" name="矩形 2">

                        <a:extLst>

                            <a:ext uri="{FF2B5EF4-FFF2-40B4-BE49-F238E27FC236}">

                                <a16:creationId xmlns:a16="http://schemas.microsoft.com/office/drawing/2014/main"

                                                id="{FC6BFD96-7710-5D5C-0E6D-5647BB89F8D0}"/>

                            </a:ext>

                        </a:extLst>

                    </p:cNvPr>

                    <p:cNvSpPr/>

                    <p:nvPr/>

                </p:nvSpPr>

                <p:spPr>

                    <a:xfrm>

                        <a:off x="7002462" y="2264229"/>

                        <a:ext cx="3110366" cy="522514"/>

                    </a:xfrm>

                    <a:prstGeom prst="rect">

                        <a:avLst/>

                    </a:prstGeom>

                </p:spPr>

                <p:style>

                    <a:lnRef idx="2">

                        <a:schemeClr val="accent1">

                            <a:shade val="15000"/>

                        </a:schemeClr>

                    </a:lnRef>

                    <a:fillRef idx="1">

                        <a:schemeClr val="accent1"/>

                    </a:fillRef>

                    <a:effectRef idx="0">

                        <a:schemeClr val="accent1"/>

                    </a:effectRef>

                    <a:fontRef idx="minor">

                        <a:schemeClr val="lt1"/>

                    </a:fontRef>

                </p:style>

                <p:txBody>

                    <a:bodyPr rtlCol="0" anchor="ctr"/>

                    <a:lstStyle/>

                    <a:p>

                        <a:pPr algn="ctr"/>

                        <a:endParaRPr kumimoji="1" lang="zh-CN" altLang="en-US">

                            <a:ln>

                                <a:solidFill>

                                    <a:srgbClr val="FF0000"/>

                                </a:solidFill>

                            </a:ln>

                        </a:endParaRPr>

                    </a:p>

                </p:txBody>

            </p:sp>

        </p:spTree>

        <p:extLst>

            <p:ext uri="{BB962C8B-B14F-4D97-AF65-F5344CB8AC3E}">

                <p14:creationId xmlns:p14="http://schemas.microsoft.com/office/powerpoint/2010/main" val="760063892"/>

            </p:ext>

        </p:extLst>

    </p:cSld>

    <p:clrMapOvr>

        <a:masterClrMapping/>

    </p:clrMapOvr>

</p:sld>

怎么做好这个库

就像我在我的掘金小册中说的那样，做前端开发，首先要做的就是设计，必须先编写设计文档，然后再开发，现在我也是这么做的。

第一步：分析pptx中每个xml的含义

第二步：整体架构设计

我把这个库分成了三层（我在小册中提到的分层思维）

• PPTX Reader层：负责读取pptx中的内容，将其转为便于理解的格式，也就是自己定义的PPTX的对象


• PPTX Render层：负责进行pptx单个幻灯片的渲染，入参为上一步得到的PPTX对象，不同的渲染方式实现不同的渲染对象，比如我们可以开发一个HtmlRender，将其渲染成为html格式，或者开发一个Canvas Render将其渲染成为Canvas，而不是写死，这样扩展性也更好一些（小册中提到的前端扩展方法）


• PPTX Preview层：负责整个pptx文件的预览，比如是采用左右翻页展示还是一下把pptx的幻灯片都展示出来，都由这个层来决定。

其中文件读取是非常复杂的，面对这种复杂的大型项目，必须考虑采用面向对象的方式来组织代码（也是小册中提到的），我将 PPTX Reader层细化为如下几个类。

• PPTX: pptx类，存储pptx文档的信息，比如缩略图，尺寸大小等信息


• Theme: 主题类，存储pptx的主题信息


• Slide: 单个幻灯片类，存储幻灯片信息


• PicNode：图片类，用它表示幻灯片中的一个图片


• ShapeNode：形状类，用它表示幻灯片中的一个一个形状


• Node：不同节点的基类


• ...

第三步：搭建代码仓库

这次决定还是采用monorepo方式组织代码，其中技术栈包括 turbo + ts + jest单测 + rollup打包 + eslint 等。

目前进展

目前正在开发 PPTX Reader 层的相关代码，争取元旦前完成PPTX中基础功能的预览，有什么心得和进展随时给大家同步。

感兴趣的同学可以关注我或者仓库，小册近期也要上线了，到时候大家多关注支持。

pptx-preview

为什么使用fetch时，有两个await？

提问

// first await

let response = await fetch("/some-url")

// second await

let myObject = await response.json()

你以前在使用fetch时，见过这两个await对吗？

有没有思考过，这是为什么？

思考

我们在浏览器中使用异步编程来，处理需要时间才能完成的任务（也就是异步任务），这样我们就不会阻塞用户界面。

等待 fetch 是有道理的。因为我们最好不要阻止 UI！

但是，我们到底为什么需要呢 await response.json() ？

解析 JSON 应该不会花费很长时间。 事实上，我们经常调用 JSON.parse("{"key": "value"}") ,这是一个同步调用。 那么，为什么 response.json() 返回 promise 而不是我们真正想要的呢？

这是怎么回事？

摘自 MDN 关于 Fetch API 的文章

https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API#concepts_and_usage

fetch（） 方法接受一个强制性参数，即你想要获取的资源的路径。 它返回一个 Promise，该 Promise 解析为该请求的 Response — 只要服务器使用 Headers 响应 — 即使服务器响应是 HTTP 错误状态。

因此，fetch 会在必须完全接收 body 之前解析响应。

查看前面的代码：

let response = await fetch("/some-url")



// At this point,

// 1. the client has received the headers

// 2. the body is (probably) still making its way over.



let myObject = await response.json()



// At this point,

// 1. the client has received the body

// 2. the client has tried to parse the body

// as json with the goal of making a JavaScript object

很明显，在整个正文到达之前访问 headers 是多么有用。

根据状态代码或其中一个标头，我们可能会决定根本不读取正文。

而 body 在 headers 之后到达实际上是我们已经习惯的。这就是浏览器中一切的工作方式。

HTML 通过网络缓慢发送，图像、字体等也是如此。

我想我只是被方法的名称弄糊涂了： response.json() .

有一个简单的节点服务器来演示这一点。相关代码都在这里

github.com/tom-on-the-…

YouTube视频演示在这

http://www.youtube.com/watch?v=Ki6…

原文地址 tomontheinternet.com/why-two-awa…

在 JavaScript 开发中，检查某个元素是否存在于集合中是一个常见的操作。对于这个任务，我们通常会使用两种方法：Set.has() 和 Array.includes()。尽管它们都能实现查找功能，但在性能上存在显著差异。今天我们就来探讨一下，为什么 Set.has() 通常比 Array.includes() 更快，特别是在查找大量元素时。

前言

最近感觉自己有点颓废，左思右想后觉得不能这样浪费时间，天天来摆烂。受到了群友的激励以及最近自己喜欢看小说。就想我能不能自己也做一款小说阅读器出来呢。在最开始的时候花了一段时间写了一个版本。当时用的是一个开源的接口，当我写好后使用了两天接口挂了我就只有大眼瞪小眼了。之后在 FlutterCandies里面咨询了群友，发现了一种使用外部提供书籍数据源的方法可以避免数据来源挂掉，说干就干vscode启动！

项目地址

github.com/fluttercand…

项目介绍

BITReader是一款基于Flutter实现的小说阅读器

当前功能包含：

• 源搜索：使用内置数据来源进行搜索数据（后续更新：用户可以自行导入来源进行源搜索


• 收藏书架


• 阅读历史记录


• 阅读设置：字号设置，字体颜色更改，自定义阅读背景（支持调色板自定义选择，支持image设置为背景


• 主题设置：支持九种颜色的主题样式


• 书籍详情：展示书籍信息以及章节目录等书籍信息

支持平台

项目截图

mac运行截图

windows运行截图

项目结构

lib

├── main.dart -- 入口

├── assets -- 本地资源生成

├── base -- 请求状态、页面状态

├── db -- 数据缓存

├── icons -- 图标

├── net -- 网络请求、网络状态

├── n_pages

    ├── detail -- 详情页

    ├── home -- 首页

    ├── search -- 全网搜索搜索页

    ├── history -- 历史记录 

    ├── read -- 小说阅读 

    └── like -- 收藏书架

├── pages  已废弃⚠

    ├── home -- 首页

    ├── novel -- 小说阅读

    ├── search -- 全网搜索

    ├── category -- 小说分类

    ├── detail_novel -- 小说详情

    ├── book_novel -- 书架、站源

    └── collect_novel -- 小说收藏

├── route -- 路由

└── theme -- 主题管理

    └── themes -- 主题颜色-9种颜色

├── tools -- 工具类 、解析工具、日志、防抖。。。

└── widget -- 自定义组件、工具 、加载、状态、图片 等。。。。。。

阅读器主要包含的模块

• 阅读显示：文本解析，对文本进行展示处理


• 数据解析： 数据源的解析，以及数据来源的解析（目前只支持简单数据源格式解析、后续可能会更新更多格式解析


• 功能：阅读翻页样式、字号、背景、背景图、切换章节、收藏、历史记录、本地缓存等

阅读显示

阅读文本展示我用的是extended_text因为支持自定义效果很好。

实现的效果把文本中 “ ” 引用起来的文本自定义成我自己想要的效果样式。

class MateText extends SpecialText {

  MateText(

    TextStyle? textStyle,

    SpecialTextGestureTapCallback? onTap, {

    this.showAtBackground = false,

    required this.start,

    required this.color,

  }) : super(flag, '”', textStyle, onTap: onTap);

  static const String flag = '“';

  final int start;

  final Color color;



  /// whether show background for @somebody

  final bool showAtBackground;



  @override

  InlineSpan finishText() {

    final TextStyle textStyle =

        this.textStyle?.copyWith(color: color) ?? const TextStyle();



    final String atText = toString();



    return showAtBackground

        ? BackgroundTextSpan(

            background: Paint()..color = Colors.blue.withOpacity(0.15),

            text: atText,

            actualText: atText,

            start: start,



            ///caret can move int0 special text

            deleteAll: true,

            style: textStyle,

            recognizer: (TapGestureRecognizer()

              ..onTap = () {

                if (onTap != null) {

                  onTap!(atText);

                }

              }))

        : SpecialTextSpan(

            text: atText,

            actualText: atText,

            start: start,

            style: textStyle,

            recognizer: (TapGestureRecognizer()

              ..onTap = () {

                if (onTap != null) {

                  onTap!(atText);

                }

              }));

  }

}

class NovelSpecialTextSpanBuilder extends SpecialTextSpanBuilder {

  NovelSpecialTextSpanBuilder({required this.color});

  Color color;

  set setColor(Color c) => color = c;

  @override

  SpecialText? createSpecialText(String flag,

      {TextStyle? textStyle,

      SpecialTextGestureTapCallback? onTap,

      int? index}) {

    if (flag == '') {

      return null;

    } else if (isStart(flag, AtText.flag)) {

      return AtText(

        textStyle,

        onTap,

        start: index! - (AtText.flag.length - 1),

        color: color,

      );

    } else if (isStart(flag, MateText.flag)) {

      return MateText(

        textStyle,

        onTap,

        start: index! - (MateText.flag.length - 1),

        color: color,

      );

    }

    // index is end index of start flag, so text start index should be index-(flag.length-1)

    return null;

  }

}

数据解析编码格式转换

首先数据是有不同的编码格式，否则我们直接展示可能会导致乱码问题。
先把数据给根据查找到的编码类型来做单独的处理转换。

/// 解析html数据 解码 不同编码

  static String parseHtmlDecode(dynamic htmlData) {

    String resultData = gbk.decode(htmlData);

    final charset = ParseSourceRule.parseCharset(htmlData: resultData) ?? "gbk";

    if (charset.toLowerCase() == "utf-8" || charset.toLowerCase() == "utf8") {

      resultData = utf8.decode(htmlData);

    }

    return resultData;

  }

 static String? parseCharset({

    required String htmlData,

  }) {   

    Document document = parse(htmlData);

  

    List<Element> metaTags = document.getElementsByTagName('meta').toList();

    for (Element meta in metaTags) {

      String? charset = meta.attributes['charset'];

      String content = meta.attributes['content'] ??

          ""; //<meta http-equiv="Content-Type" content="text/html; charset=utf-8">



      if (charset != null) {

        return charset; 

      }

      List<String> parts = content.split(';');

      for (String part in parts) {

        part = part.trim();

        if (part.startsWith('charset=')) {

          return part.split('=').last.trim();

        }

      }

    }



    return null; 

  }

数据结构解析-代码太多只展示部分

Document document = parse(htmlData);



    //

    List<Element> rootNodes = [];

    if (rootSelector != null && rootSelector.isNotEmpty) {

      // 

      List<String> rootParts = rootSelector.split(RegExp(r'[@>]'));

      String initialPart = rootParts[0].trim();



      //

      if (initialPart.startsWith('class.')) {

        String className = initialPart.split('.')[1];

        rootNodes = document.getElementsByClassName(className).toList();

      } else if (initialPart.startsWith('.')) {

        String className = initialPart.substring(1);

        rootNodes = document.getElementsByClassName(className).toList();

      } else if (initialPart.startsWith('#')) {

        String idSelector = initialPart.substring(1);

        rootNodes = document.querySelectorAll('#$idSelector').toList();

      } else if (initialPart.startsWith('id.')) {

        String idSelector = initialPart.split('.')[1];

        var element = document.querySelector('#$idSelector');

        if (element != null) {

          rootNodes.add(element);

        }

      } else if (initialPart.contains(' ')) {

        String idSelector = initialPart.replaceAll(' ', ">");

        var element = document.querySelector(idSelector);

        if (element != null) {

          rootNodes.add(element);

        }

      } else {

        rootNodes = document.getElementsByTagName(initialPart).toList();

      }

存储工具类 - 部分代码

/// shared_preferences

class PreferencesDB {

  PreferencesDB._();

  static final PreferencesDB instance = PreferencesDB._();

  SharedPreferencesAsync? _instance;

  SharedPreferencesAsync get sps => _instance ??= SharedPreferencesAsync();



  /*** APP相关 ***/



  /// 主题外观模式

  ///

  /// system(默认)：跟随系统 light：普通 dark：深色

  static const appThemeDarkMode = 'appThemeDarkMode';



  /// 多主题模式

  ///

  /// default(默认)

  static const appMultipleThemesMode = 'appMultipleThemesMode';



  /// 字体大小

  ///

  ///

  static const fontSize = 'fontSize';



  /// 字体粗细

  static const fontWeight = 'fontWeight';



  /// 设置-主题外观模式

  Future<void> setAppThemeDarkMode(ThemeMode themeMode) async {

    await sps.setString(appThemeDarkMode, themeMode.name);

  }



  /// 获取-主题外观模式

  Future<ThemeMode> getAppThemeDarkMode() async {

    final String themeDarkMode =

        await sps.getString(appThemeDarkMode) ?? 'system';

    return darkThemeMode(themeDarkMode);

  }



  /// 设置-多主题模式

  Future<void> setMultipleThemesMode(String value) async {

    await sps.setString(appMultipleThemesMode, value);

  }



  /// 获取-多主题模式

  Future<String> getMultipleThemesMode() async {

    return await sps.getString(appMultipleThemesMode) ?? 'default';

  }



  /// 获取-fontsize 大小 默认18

  Future<double> getNovelFontSize() async {

    return await sps.getDouble(fontSize) ?? 18;

  }



  /// 设置 -fontsize 大小

  Future<void> setNovelFontSize(double size) async {

    await sps.setDouble(fontSize, size);

  }



  /// 设置-多主题模式

  Future<void> setNovelFontWeight(NovelReadFontWeightEnum value) async {

    await sps.setString(fontWeight, value.id);

  }



  /// 获取-多主题模式

  Future<String> getNovelFontWeight() async {

    return await sps.getString(fontWeight) ?? 'w300';

  }

}