Pseudowang

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

出现这个就是成功了