小记一下，记录你的精彩代码片段和架构点滴 - 新手学习网

// 定义公共模块
pub mod utils;  // 对应 src/utils.rs 或 src/utils/mod.rs

// 定义公共函数
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

// 私有模块（外部不可见）
mod internal {
    pub fn secret_function() -> &'static str {
        "This is internal!"
    }
}

2. `mod.rs` 的作用

mod.rs 用于定义子模块的内容。它可以是一个单独的文件（如 src/module_name/mod.rs），也可以简化为 src/module_name.rs。

关键特点

子模块的入口：当模块包含多个文件时，使用 mod.rs 组织它们。
模块嵌套：可以通过 mod.rs 创建多级模块结构。
现代替代方案：Rust 2018 之后，推荐使用 module_name.rs 替代 module_name/mod.rs（见下文示例）。

示例 1：传统 `mod.rs` 结构

复制代码

mylibrary/
├── Cargo.toml
└── src/
    ├── lib.rs
    └── utils/
        ├── mod.rs       # 子模块入口
        └── math.rs      # 子模块中的文件

src/utils/mod.rs 内容：

// 引入同级文件作为子模块
pub mod math;  // 对应 src/utils/math.rs

// 定义模块内的公共函数
pub fn say_hello() {
    println!("Hello from utils!");
}

src/utils/math.rs 内容：

// 子模块中的公共函数
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

示例 2：简化的模块结构（Rust 2018+）

Rust 2018 之后，可以直接用 module_name.rs 替代 module_name/mod.rs，减少嵌套层级。

复制代码

mylibrary/
├── Cargo.toml
└── src/
    ├── lib.rs
    ├── utils.rs       # 替代 utils/mod.rs
    └── utils/
        └── math.rs    # 子模块文件

src/utils.rs 内容：

// 引入子目录中的文件
pub mod math;  // 对应 src/utils/math.rs

pub fn say_hello() {
    println!("Hello from utils!");
}

3. 主要区别

对比项	`lib.rs`	`mod.rs` / `module.rs`
角色	库的根入口	子模块的入口
必需性	库项目必须存在	非必需，按需创建
文件名	固定为 `lib.rs`	可以是 `mod.rs` 或 `module_name.rs`
路径映射	对应 crate 根（如 `mylibrary::`）	对应模块路径（如 `mylibrary::utils`）
使用场景	定义公共 API、引入子模块	组织子模块的内部结构

4. 最佳实践

小型模块：直接使用 module_name.rs（如 src/utils.rs）。
大型模块：使用 module_name/mod.rs + 子文件（如 src/utils/mod.rs）。
公共 API：在 lib.rs 中通过 pub use 重导出模块内容，简化外部调用。

// lib.rs 中重导出
pub use utils::math::multiply;  // 使 mylibrary::multiply 可用

总结

lib.rs：是库项目的核心入口，负责定义公共 API 和组织顶级模块。
mod.rs / module_name.rs：用于组织子模块的内部结构，避免单个文件过大。

合理使用这两个文件，可以让 Rust 项目的模块结构清晰且易于维护。

Rust 中的 #[inline] 属性是什么意思？

在 Rust 中，内联（Inline） 是一种编译器优化技术，核心思想是将函数或方法的代码直接嵌入到调用它的位置，从而避免传统函数调用的开销（如压栈、跳转、返回等）。下面通过具体例子和对比，帮助你直观理解这一概念：

1. 什么是“代码嵌入调用位置”？

假设我们有一个简单函数 add，用于计算两个数的和：

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let result = add(1, 2);
}

未内联时的执行过程：

调用 add(1, 2) 时，程序会跳转到 add 函数的地址。
将参数 1 和 2 压入栈中。
执行 a + b，得到结果 3。
返回到 main 函数，将结果存入 result。

内联后的执行过程（添加 #[inline] 属性）：

#[inline]
fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    // 内联后等效于直接写入 a + b
    let result = 1 + 2;  // 编译器将函数体直接替换到此处
}

此时，add 函数的代码 1 + 2 被直接嵌入到 main 函数的调用位置，省去了跳转和参数传递的步骤。

2. 为什么需要内联？
优化场景：

高频调用的小函数（如数学运算、Getter/Setter）。
性能关键路径（如循环内的计算）。

示例对比：

假设有一个循环调用 square 函数计算平方：

fn square(x: i32) -> i32 {
    x * x
}

fn main() {
    let mut sum = 0;
    for i in 1..=1000 {
        sum += square(i);  // 每次循环都需执行函数调用
    }
}

未内联时：循环中每次调用 square(i) 都会产生函数调用开销。
内联优化后（添加 #[inline]）：

#[inline]
fn square(x: i32) -> i32 {
    x * x
}

fn main() {
    let mut sum = 0;
    for i in 1..=1000 {
        sum += i * i;  // 直接替换为乘法操作
    }
}

内联后，循环内直接执行 i * i，避免了 1000 次函数调用开销，性能显著提升。

3. 内联的代价与注意事项

优点：

减少函数调用开销，提升执行速度。
可能触发更多编译器优化（如常量传播、死代码消除）。

缺点：

代码膨胀：多次内联会导致编译后的二进制文件变大（如大函数被内联多次）。
调试困难：内联后的代码堆栈信息可能不直观。

适用场景建议：

小函数（如 add、getter）适合内联。
大函数或低频调用函数（如复杂算法）应避免内联。

4. 内联属性的分类

Rust 提供不同内联属性，控制优化力度：

#[inline]：建议编译器内联，但最终由编译器决定。
rust 复制代码
```
#[inline]
fn calculate(a: i32) -> i32 { a * 2 }
```
#[inline(always)]：强制内联（除非不可行）。
rust 复制代码
```
#[inline(always)]
fn critical_code(x: f64) -> f64 { x.sqrt() }
```

#[inline(never)]：禁止内联。

#[inline(never)]
fn large_function(data: &[u8]) { /* 复杂处理 */ }

package.json 中的 resolutions字段是什么意思？

在 package.json 中配置 "resolutions": { "nitro": "link:." } 是一种特殊用法，主要用于强制项目依赖指向本地路径的包（而非从远程 npm 仓库安装）。

例如：

json 复制代码

{
  "resolutions": {
    "nitro": "link:."  // 直接指向当前项目的根目录
  }
}

当前配置上述字段后，一般来说 package.json 的name 字段值为nitro.

这样，代表当前项目本身即为一个包，名称为nitro 。当项目内部引用nitro包时，优先加载本地文件。

例如：假设当前项目的src/command/dev.ts 有如下代码:

//src/command/dev.ts
//此处的nitro会node_modules安装的nitro库，而是项目本身
import { build, createDevServer, createNitro, prepare } from "nitro";

则，此处的nitro，会直接使用 src/index.ts 文件。

vite-plugin-node-polyfills 让node核心模块可以运行在浏览器

由于Node.js的核心模块（如fs、path、Buffer 等）是Node.js环境特有的，它们提供了对文件系统、路径处理等功能的访问。浏览器环境（如Chrome、Firefox等）并不支持这些模块，因为浏览器的安全模型限制了对本地文件系统的直接访问。

在使用 vite 的项目是，如果依赖的第三方包，使用了 Node's Core Modules, 项目可能会报错，通过下列插件可以解决这一问题。

vite-plugin-node-polyfills

具体配置如下：

import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import { nodePolyfills } from 'vite-plugin-node-polyfills';

// https://vite.dev/config/
export default defineConfig({
  plugins: [
    vue(),
    //
    nodePolyfills()
  ],
})

nodePolyfills 支持 include 和 exclude 选择，具体可以参考插件文档。

pnpm中如何给包设置别名？

在npm或者pnpm中，可能有一些方法可以给包设置别名。

比如，如果我们想使用h3 这个包的nightly 版本进行测试，但是代码中，还是希望通过h3 进行导入。安装的时候可能可以用类似pnpm install h3@npm:h3-nightly这样的命令。

这样安装之后，h3实际上指向h3-nightly的版本。

例如，假如package.json 如何：

json 复制代码

{
  "name": "quick_start",
  "version": "1.0.0",
  "type": "module",
  "description": "",
  "main": "server.mjs",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "dependencies": {
    "h3": "npm:h3-nightly@2.0.0-20250428-102154-f1115f3"
  }
}

这样我们在代码中，就可以直接使用 h3 这个别名进行导入了。

// 可以直接使用 h3
import { H3, serve } from "h3";
// 而不需要使用 h3-nightly
// import { H3, serve } from "h3-nightly";

调用微信公众号接口报错："errcode":41001,"errmsg":"access_token missing rid

调用微信公众号接口报错：

json 复制代码

{"errcode":41001,"errmsg":"access_token missing rid: 67e89afa-32dasdas23213123123dasd "}

请确保传递了正确的 access_token, 或缺少 access_token 参数

例如，请求接口:

http请求方式：GET https://api.weixin.qq.com/cgi-bin/menu/delete?access_token=ACCESS_TOKEN

如果是Java 中使用 httpClient 组件，确保正确的调用方式：

java 复制代码

String url = "https://api.weixin.qq.com/cgi-bin/menu/delete";
Map<String, String> params = new HashMap<>();
params.put("access_token",accessToken);
String response = HttpUtils.get(url, params);

Vue3 中KeepAlive在嵌套路由中的使用及注意事项

<KeepAlive> 是一个内置组件，它的功能是在多个组件间动态切换时缓存被移除的组件实例。通过缓存不活动的组件实例，避免重复渲染。通常在动态组件或者路由组件中使用，可以保留组件状态或者提高性能。

假设router/index.js 如下：

const routes = [
  {
    path: '/',
    component: () => import('../layouts/MainLayout.vue'),
    children: [
      {
        path: '/parent',
        component: () => import('../views/ParentView.vue'), // 父组件
        children: [
          {
            path: 'child1',
            component: () => import('../views/Child1.vue'),
            meta: { keepAlive: true } // 启用缓存
          },
          {
            path: 'child2',
            component: () => import('../views/Child2.vue')
          }
        ]
      }
    ]
  }
]

其中 App.vue 及MainLayout 中都有router-view 组件。该如何配置 keepalive呢？

代码如下：

App.vue 配置

html 复制代码

<!-- App.vue -->
<template>
  <!-- 注意在嵌套路由中使用 keep-alive -->
  <router-view  v-slot="{ Component }">
    <keep-alive :include="['MainLayout']">
      <component :is="Component" />
    </keep-alive>
  </router-view >
</template>

MainLayout.vue 配置

<template>
<el-scrollbar class="flex-1 layout-main-content">
  <div class="flex-1 shadow bg-white p-3">
    <router-view v-slot="{ Component }" >
        <keep-alive :include="cachedRoutes">
          <component :is="Component" />
        </keep-alive>
      </router-view>
  </div>
</el-scrollbar>
</template>
<script lang="ts" setup>
const router = useRouter();
// 动态计算需要缓存的路由名称
const cachedRoutes = computed(() => {
  let arr =  router.getRoutes().filter((r) => r.meta?.keepAlive).map(r =>r.name);  
  // 过滤掉 undefined 值
  const validRoutes = arr.filter((name): name is string => name !== undefined);
  return validRoutes;
});
</script>

注意事项

`component`中了key的使用

如果component 中使用了key，可能会造成重复渲染，axios 多次请求。

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

可以修改key的绑定或删除key,以生成稳定 Key。

<!-- 修改后 -->
<component :is="Component" 
  :key="`${$route.name}-${JSON.stringify($route.params)}`"/>

生命周期

keepAlive组件特有的生命周期，可用于调试或进行智能缓存策略控制。

onActivated(() => console.log('Activated'))
onDeactivated(() => console.log('Deactivated'))

如何灵活控制请求执行条件？

<script setup>
import { ref, watch, onActivated } from 'vue'
import { useRoute } from 'vue-router'

const route = useRoute()
const data = ref(null)
const hasLoaded = ref(false) // 请求状态标记

// 统一请求方法
const fetchData = async () => {
  if (hasLoaded.value) return
  try {
    const res = await axios.get(`/api/data/${route.params.id}`)
    data.value = res.data
    hasLoaded.value = true
  } catch (err) {
    console.error(err)
  }
}

// 常规加载
if (!hasLoaded.value) {
  fetchData()
}

// 监听路由参数变化
watch(() => route.params.id, (newVal, oldVal) => {
  if (newVal !== oldVal) {
    hasLoaded.value = false
    fetchData()
  }
})

// 缓存激活时刷新数据
onActivated(() => {
  if (Date.now() - lastLoadTime > 5 * 60 * 1000) { // 5分钟缓存
    hasLoaded.value = false
    fetchData()
  }
})
</script>

acme.sh 使用步骤

acme.sh 是一个开源的纯 Shell 脚本实现的 ACME 客户端，可用于自动化申请、续期和管理 SSL/TLS 证书，以下是使用 acme.sh 的详细步骤：

1. 安装 `acme.sh`

打开终端，执行以下命令进行安装：

curl https://get.acme.sh | sh -s email=your_email@example.com

或者使用 wget：

wget -O -  https://get.acme.sh | sh -s email=your_email@example.com

上述命令中的 your_email@example.com 要替换成你自己的邮箱地址，此邮箱用于接收证书相关的通知。安装完成后，acme.sh 会自动添加一个 cron 定时任务，以实现证书的自动续期。

2. 选择验证方式

acme.sh 支持多种域名验证方式，常见的有以下几种：

HTTP 验证（HTTP-01）：适用于可以通过 80 端口访问的 Web 服务器。acme.sh 会在 Web 服务器的特定目录下创建验证文件，Let's Encrypt 服务器会通过 HTTP 请求来验证文件的存在。
DNS 验证（DNS-01）：适用于各种情况，尤其是无法开放 80 或 443 端口的场景。acme.sh 会在域名的 DNS 记录中添加特定的 TXT 记录，Let's Encrypt 服务器会通过 DNS 查询来验证域名所有权。
TLS-ALPN 验证（TLS-ALPN-01）：通过 443 端口进行验证，适用于支持 ALPN 扩展的 Web 服务器。

3. 以 DNS 验证为例申请证书

3.1 配置 DNS 提供商的 API 密钥

如果你使用的是腾讯云 DNS，需要设置环境变量：

export Tencent_SecretId="your_secret_id"
export Tencent_SecretKey="your_secret_key"

将 your_secret_id 和 your_secret_key 替换为你自己的腾讯云 API 密钥。

3.2 申请证书

使用以下命令申请证书：

./acme.sh --issue --dns dns_tencent -d example.com -d *.example.com

--issue：表示触发证书申请流程。
--dns dns_tencent：指定使用腾讯云的 DNS 验证方式。
-d example.com：指定要申请证书的主域名。
-d *.example.com：指定要申请证书的泛域名（可选）。

4. 以 HTTP 验证为例申请证书

4.1 确保 Web 服务器可访问

确保你的 Web 服务器（如 Nginx、Apache）正在运行，并且可以通过 80 端口访问。

4.2 申请证书

使用以下命令申请证书：

./acme.sh --issue -d example.com --webroot /path/to/your/webroot

-d example.com：指定要申请证书的域名。
--webroot /path/to/your/webroot：指定 Web 服务器的根目录，acme.sh 会在该目录下创建验证文件。

5. 安装证书

申请成功后，需要将证书安装到 Web 服务器上。以 Nginx 为例，执行以下命令：

./acme.sh --install-cert -d example.com \
--key-file       /etc/nginx/ssl/example.com.key  \
--fullchain-file /etc/nginx/ssl/example.com.cer \
--reloadcmd     "systemctl reload nginx"

--install-cert：表示安装证书。
-d example.com：指定要安装证书的域名。
--key-file：指定私钥文件的保存路径。
--fullchain-file：指定证书链文件的保存路径。
--reloadcmd：指定安装完成后重新加载 Web 服务器的命令。

6. 自动续期

acme.sh 会自动添加一个 cron 定时任务，在证书到期前 30 天自动尝试续期。你可以通过以下命令查看 cron 任务：

crontab -l

如果需要手动触发续期，可以使用以下命令：

./acme.sh --renew -d example.com

7. 卸载 `acme.sh`

如果你不再需要使用 acme.sh，可以执行以下命令进行卸载：