云升的小窝

解决腾讯云服务器无法连接GitHub

Sat, 11 Apr 2026 00:00:00 GMT

问题描述

腾讯云服务器在国内访问 GitHub 时经常遇到连接超时或无法解析的问题。

解决思路

通过手动修改 hosts 文件，将 GitHub 域名解析到可用的 IP 地址。

操作步骤

第一步：查询可用 IP 地址

访问 IP 地址查询网站，查询以下域名的 DNS 解析地址：

github.com
raw.githubusercontent.com

建议：优先选择美国节点的 IP 地址，新加坡节点可能存在问题。

第二步：目前获取到的可用 IP

域名	IP 地址
`github.com`	`140.82.116.3`
`raw.githubusercontent.com`	`185.199.108.133`

第三步：修改 hosts 文件

# 编辑 hosts 文件
sudo vim /etc/hosts

添加以下内容：

140.82.116.3 github.com
185.199.108.133 raw.githubusercontent.com

第四步：验证连接

ping github.com
ssh -T git@github.com

注意事项

如遇连接问题，可定期更新 hosts 文件中的 IP 地址
若使用代理或 VPN，请确保配置正确

无

Fri, 18 Apr 2025 00:00:00 GMT

自4月1号通知我裁员后，今天就是我在公司的最后一天了。

去年1月我曾在一家游戏公司做后端开发实习，当时有一个社招进入的和我一起培训的男生，他告诉我他去年工作被裁员后到这里来的，当时还有些诧异怎么只待了一年就被优化，没想到同样的事情在一年后发生到我身上。

说起来，当时看中现在的公司规模更大，所以最后放弃了那家游戏公司，选择了现在的一家电商公司是否是个错误呢？从3月开始在这里实习起，7月毕业后正式入职到现在，部门裁员了50%的人……几乎每月身边的同事都在离开，我周围的同事几乎都离职了，我还常常自嘲自己是同事杀手，这都是在我实际来之前完全没有预见的。

其实和公司的同事相处都很融洽，可能作为程序员的大家都比较单纯吧，我也很喜欢这儿的大家，只是部门的经营状况实在太差，业务在不断地大幅下滑，像餐补一类的福利也在去年底就砍掉了，当时就对公司的发展状况有了一个比较清晰的感受，也早早有了预期，所以在单独通知我裁员的时候我的心里几乎一点实感都没有，不过当晚在打电话告诉父母的时候还是有些难过。

都说实践是最好的学习方式，在刚毕业时我还是完全的前端小白，因为在学校里一直都学习的后端（其实后端也没学得多好:D），没想到毕业后找到的却是前端工作。

其实在短短的一年里真的进步了很多，最终也独立地完成了很多项目的相当多工作上的内容，只是可惜处在了一个不是那么好的时代。

我自己是相当热爱计算机的，毕竟从小就有接触，甚至中学时代就在管理班级的多媒体计算机，大学也自己填报了计算机专业，我不是天赋型选手，但是在班里专业成绩也还算不错，当时想着自己以后一定要以此为工作，创造一些有趣的事物来。如今我还是热爱计算机，并且热情不减，但是我却不想以此为工作了，我想象中为自己的爱好而工作不是这样子的，大概以后我还会自己去学习去实现一些东西，比如前段时间我还开始在自学Unity游戏开发，但是这些以后都可能不再会是我的职业了。

叽里咕噜也不知道记了些什么，就这样吧。

Waline的使用

Thu, 17 Apr 2025 00:00:00 GMT

1. 部署 Waline 服务端

先照着Waline官方文档把 Waline 项目给部署了，就完全照着操作就行了，官方文档写的很详细，我觉得没必要再重复写一次。一直照着操作到绑定域名为止，暂时没有必要绑定域名，如果有进行加速使国内可以访问的需求时再绑定域名（之后会写如何加速）。

记住部署好的 Waline 项目的 Domains，有需要的话可以先用我的做测试，已做国内加速，域名注册的话选有首年优惠的就行，大概10块钱左右，但是续费很贵，所以到期后我会更换新域名，所以还是需要你自己注册一个自己域名。

2. 配置前端

在 src/config.ts 中的 walineConfig 配置项里添入自己部署的 Waline 项目的域名。

3. 启用评论功能

然后在要启用评论系统的文章 Front-matter 中加入 comments: true 就可以单独对文章启用 Waline 评论了。

4. 管理员与管理面板

首个注册的账号会是管理员，管理面板在 example.yourdomain.com/ui

5. 国内访问加速

如果你使用 Vercel 部署 Waline，国内用户可能无法直接访问评论系统。需要加速的同学可以参考：这篇文章

如有疑问，欢迎留言交流！

鼠标点击爆炸特效美化

Fri, 11 Apr 2025 00:00:00 GMT

继续处理博客的升级工作，决定把旧框架下的鼠标点击爆炸特效移植过来。这是在之前的 Hexo 博客中使用过的功能，链接是hexo 博客美化。这个特效让页面点击时出现彩色粒子爆炸。

使用的文件

接下来，在 Layout 文件的 <body> 标签内添加必要的元素。过程很顺利，我把代码保存为一个单独的 JS 文件，然后引入它。具体的添加部分是：

<canvas
  id="fireworks"
  style="position: fixed; top: 0; left: 0; width: 100vw; height: 100vh; pointer-events: none; z-index: 32767"
></canvas>
<script
  type="text/javascript"
  src="https://cdn.jsdelivr.net/npm/animejs@3.2.1/lib/anime.min.js"
></script>
<script type="text/javascript" src="/utils/fireworks.min.js"></script>

要让该JS能在线上（生产环境）被访问，必须把它放到 Astro 项目的 public 目录下。

快速上手 Google Tag Manager (GTM) 与 Microsoft Clarity 集成教程

Fri, 11 Apr 2025 00:00:00 GMT

在网站分析和用户行为追踪中，Google Tag Manager (GTM) 是一个强大的工具，可以帮助我们轻松管理各种追踪代码。而 Microsoft Clarity 则是一款优秀的用户行为分析工具，能够提供热图、会话录制等功能。

一、创建 Google Tag Manager (GTM) 账号和容器

访问 GTM 官网
打开 GTM 官网，使用你的 Google 账号登录。
创建账号和容器
- 点击“创建账号”，填写账号名称（通常是公司或项目名）。
- 创建一个新的“容器”，选择“网页”类型，并输入网站域名。
- 完成设置后，GTM 会生成两段代码，用于嵌入到你的网站中。

二、将 GTM 代码嵌入网站

获取 GTM 代码
创建容器后，GTM 会提供两段代码：一段放在 <head> 标签内，另一段放在 <body> 标签内。
嵌入代码到项目
- 找到项目的主布局文件（通常是 Layout 文件）。
- 将第一段代码粘贴到 <head> 标签的最前面。
- 将第二段代码粘贴到 <body> 标签的最前面。
解决 TypeScript 报错（可选）
如果你的项目使用 TypeScript (ts)，可能会在 <script> 标签处报错。解决方法是给 <script> 标签加上 type="text/javascript" 属性，例如：
```
<script type="text/javascript">
  // GTM 代码内容
</script>
```
发布并测试
- 代码嵌入完成后，部署你的网站。
- 使用浏览器开发者工具或 GTM Preview 模式测试，确保代码正常运行，无报错。

三、通过 GTM 集成 Microsoft Clarity

访问 Microsoft Clarity 官网
打开 Clarity 官网，使用 Microsoft 账号登录。
创建新项目
- 点击“新建项目”，填写项目名称和网站 URL。
- 选择“在第三方平台上安装”，然后选择“Google Tag Manager (GTM)”作为集成方式。
连接 GTM 项目
- Clarity 会生成一段代码或指引你完成连接。
- 在 GTM 界面中，创建一个新的“标签”，选择“自定义 HTML 标签”，将 Clarity 提供的代码粘贴进去。
- 设置触发器为“所有页面”，确保代码在每个页面加载时触发。
- 保存并发布 GTM 容器。

四、等待数据同步

完成以上步骤后，通常需要等待几个小时（视网站流量而定），Clarity 才会开始显示数据。
登录 Clarity 仪表板，查看热图、会话录制等用户行为数据，确保一切正常。

五、总结与注意事项

通过以上步骤，你已经成功将 GTM 集成到网站，并通过 GTM 连接了 Microsoft Clarity，用于用户行为分析。以下是一些注意事项：

确保 GTM 代码正确嵌入，避免因位置错误导致追踪失败。
定期检查 GTM 和 Clarity 的数据，确保没有异常。
如果网站有多个子域名或复杂结构，可能需要额外配置 GTM 容器。

搜索引擎活用手册

Thu, 12 Dec 2024 00:00:00 GMT

一直苦于像牛皮癣一样到处都是的 CSDN 文章，现在似乎连必应都被这个二流网站给铺满了，于是开始好好研究如何正确使用搜索引擎，过滤掉那些不需要的信息。

过滤信息

首先，让我们来干掉该死的 CSDN 吧。

根据网络上给出的方法，可以在搜索框加上-site:csdn.net，这样会过滤掉csdn.net网站的搜索结果。

但是这样似乎需要写的东西太长了，很麻烦，可以直接去掉site，写-csdn.net，虽然在必应上仍然有些漏网之鱼，但是总的来说依然是生效的。

似乎每次都要输入一次-csdn.net也有点麻烦，如果能每次搜索的时候都自动添加上这个关键词，那是不是更方便呢？

我们可以打开 EDGE 中的设置面板，在"管理搜索引擎"选项中，可以添加上一个地址栏搜索引擎，其中的搜索地址为：https://cn.bing.com/search?q=%s+-site:csdn.net，其他两项"搜索引擎"和"快捷方式"都可以自行随意设置。

同样，用这个方法也可以过滤掉一些不需要的信息，例如我们搜索一个电子游戏，但是和一部电影重名了，也可以-movie或是-多余的搜索结果中出现的关键词来过滤掉对应的搜索结果。

如果需要在特点的网站上进行搜索的话，将-site前的-去掉即可，例如：Vue教程 site:github.com

现在我们成功干掉了 CSDN，接下来顺势学习一下搜索引擎的更多技巧吧。

精确搜索

如果要进行精确搜索，可以将搜索的参数加上""，当没有引号时，搜索的是以任意顺序包含关键词的内容，而加上引号后，将会把引号内的参数作为一个整体进行精确搜索。

不过目前实际应用中需要用到精确搜索的场景比较少，了解即可。

填充模糊信息

使用*可以填充关键词间的模糊信息。

文档搜索

使用filetype可以搜索指定文档格式的资料，例如:filetype:pdf 区块链报告，这样搜索出来的结果都是 pdf 格式的资料。

一般而言，以上的技巧就足够应付实际应用中的大部分场景了。

Vue2开发学习笔记

Sat, 13 Apr 2024 21:31:01 GMT

好想直接学最新的 vue3……

最近听到一首挺好听的歌，《若月亮没来》。

没啥用的一篇文章，以后自己的这些东西都会改为放到另一个网站里

vue2 安装

vue2 的 CLI 与 vue3 的 CLI 有所不同，应参照该文档进行安装

安装 Vue CLI

npm install -g @vue/cli
# or
yarn global add @vue/cli

创建项目

vue create my-project
# or
vue ui

启动项目

npm run serve

Vue 自定义组件

<!-- src\components\product-item\product-item.vue -->
<template>
  <div class="product-item">
    <img :src="products.img" alt="商品" />
    <div class="title">{{ products.title }}</div>
    <div class="price">
      <div class="current-price">{{ products.currentPrice }}</div>
      <div class="original-price">{{ products.originalPrice }}</div>
    </div>
  </div>
</template>

<script>
  export default {
    props: {
      products: {
        type: Object,
        default: () => ({
          img: "",
          title: "",
          currentPrice: "",
          originalPrice: "",
        }),
      },
    },
  };
</script>

<!-- src\App.vue -->
<template>
  <body>
    <div class="layout-default">
      <topNavigation />
      <div class="list">
        <Product
          v-for="(product, index) in products"
          :key="index"
          :products="product"
        ></Product>
      </div>
    </div>
  </body>
</template>

<script>
  import Product from "@/components/product-item/product-item.vue";
  import topNavigation from "@/components/top-navigation/top-navigation.vue";
  import { mapState } from "vuex";

  export default {
    components: {
      Product,
      topNavigation,
    },
    computed: {
      ...mapState({
        products: (state) => state.shop.products,
      }),
    },
  };
</script>

slot

在 Vue 中，slot是一种分发内容的机制，允许我们将组件的一部分内容插入到组件的模板中。这种方式使得我们可以编写可复用的组件，而不需要在每次使用时都写重复的内容。

例如，如果有一个自定义的<my-button>组件，我们可能想在不同的地方使用不同的文本。这就可以通过slot来实现：

<!-- my-button组件的模板 -->
<button>
  <slot>默认按钮文本</slot>
</button>

使用这个组件时，可以这样做：

<my-button> 点击我 </my-button>

这样<my-button>组件里的<slot>标签就会被替换为“点击我”，而不是默认的“默认按钮文本”。

slot还可以有名字，这样你就可以定义多个插槽，让父组件决定哪些内容放在哪里。例如：

<!-- my-layout组件的模板 -->
<div>
  <header>
    <slot name="header"></slot>
  </header>
  <main>
    <slot></slot>
  </main>
  <footer>
    <slot name="footer"></slot>
  </footer>
</div>

在使用时：

<my-layout>
  <template v-slot:header>
    <h1>这是标题</h1>
  </template>

  <p>这是主体内容</p>

  <template v-slot:footer>
    <p>这是页脚信息</p>
  </template>
</my-layout>

这样，my-layout组件就会在相应的位置显示“这是标题”、“这是主体内容”和“这是页脚信息”。

总之，slot是 Vue 中一种非常有用的特性，用于创建灵活且可复用的组件。

Vuex 的使用

使用常量存储静态数据

// src\constants\constants.js
import {
  productImageUrl1,
  productImageUrl2,
  productImageUrl3,
  productImageUrl4,
} from "@/constants/image";

export const SHOP_PRODUCTS_DATA = [
  {
    img: productImageUrl1,
    title: "AC/DC North American Tour T-shirt",
    currentPrice: "$25.90",
    originalPrice: "$37.50",
  },
  {
    img: productImageUrl2,
    title: "Brown Janis Joplin Printed HoodedLight Trailer  S...",
    currentPrice: "$19.90",
    originalPrice: "",
  },
];

关于 image.js 的示例:

import productImage1 from "@/assets/img/image 1.png";
export const productImageUrl1 = productImage1;

Vuex 的引入

创建 store 文件夹，在 store 文件夹下创建 module 文件夹和 index.js 文件，在 module 文件夹中创建 module.js 文件.
在 module.js 文件中创建 state,mutations,actions,getters 对象。
在 index.js 中创建 store 对象，在 main.js 中引入 store 对象，在 main.js 中挂载 store 对象

// src\store\modules\shop.js
import { SHOP_PRODUCTS_DATA } from "@/constants/constants";

export default {
  state: {
    products: SHOP_PRODUCTS_DATA,
  },
};

// src\store\index.js
import Vue from "vue";
import Vuex from "vuex";
import shopProducts from "@/store/modules/shop";

Vue.use(Vuex);

export default new Vuex.Store({
  modules: {
    shop: shopProducts,
  },
});

// src\main.js
import Vue from "vue";
import App from "./App.vue";
import store from "@/store/index";

Vue.config.productionTip = false;

new Vue({
  store,
  render: (h) => h(App),
}).$mount("#app");

在主模块中引入 Vuex

<script>
  import Product from "@/components/product-item/product-item.vue";
  import { mapState } from "vuex";

  export default {
    components: {
      Product,
    },
    computed: {
      ...mapState({
        products: (state) => state.shop.products,
      }),
    },
  };
</script>

vue-router 的使用

vue-router 安装

npm install vue-router@version

vue-router 结构目录

src
- router
  - index.js

路由配置

// src\router\index.js
import Vue from "vue";
import Router from "vue-router";
Vue.use(Router);

// 路由规则
const routes = [
  {
    path: "/",
    component: () => import("../page/ShoppingList.vue"),
  },
  {
    path: "/PDP",
    component: () => import("../page/PDP.vue"),
  },
  {
    path: "/ShoppingCart",
    component: () => import("../page/ShoppingCart.vue"),
  },
  {
    path: "*",
    ridirect: "/",
  },
];

// 路由器
const router = new Router({
  routes,
  mode: "hash", // history
});

export default router;

路由模式：如果需要去掉 URL 中的 "#" ，需要在创建 VueRouter 实例时设置 mode 为 history 。

// src\main.js
import router from "./router/index";

new Vue({
  router, // new
  render: (h) => h(App),
}).$mount("#app");

路由使用

对于动态导航，可以这样使用：

<!-- 在组件模板中 -->
<router-link to="/">Home</router-link>
<router-view>
</router-view>

或者在 JavaScript 中：

this.$router.push("/");

router-link内的属性值：

<!-- replace 不保留历史记录 -->
<!-- tag 改变标签 -->
<!-- target 改变链接打开方式 -->
<router-link to="/" replace tag="div" target="_blank">Home</router-link>

路由传参

在本项目中，要实现跳转到 PDP 页面，需要将商品 ID 传过去。

动态匹配路由跳转时路由规则的修改

const routes = [
  {
    path: "/pdp/:id",
    name: "pdp",
    component: () => import("../page/PDP.vue"),
  },
];

添加上 name 属性后，就可以在 <router-link> 中进行动态匹配了：

<router-link :to="{ name: 'pdp', params: { id: products.id } }"></router-link>

这里进行路由跳转时，会动态匹配 name=pdp 的路由规则，并把 params 参数传过去。

获取路由中传递过来的参数

首先注入 $route 对象，使得组件可以直接访问 vue-router 中的 $route 实例，从而获取当前路由的信息。
之后定义一个属性来获取路由参数。

<script>
  export default {
      // ...
      inject: ['$route'],
      // ...
      data() {
          return {
              getIdFromRoute: this.$route.params.id,
          }
      }
      // 另外一种使用computed的方法:
      computed: {
          getIdFromRoute() {
            return this.$route.params.id
          }
      }
  }
</script>

通过一个自定义的属性来取到当前的商品信息，然后就可以在组件中直接使用。

<template>
  <!-- 使用示例 -->
  <img :src="currentProduct.img" />
  <div>{{ currentProduct.title }}</div>
</template>

<script>
  export default {
    // ...
    computed: {
      currentProduct() {
        return this.products.find(
          (product) => product.id === this.getIdFromRoute
        );
      },
    },
    // ...
  };
</script>

在 main.js 中注入 VueRouter 的标准流程：

在 Vue 应用中，$router 和 $route 对象是通过 Vue Router 插件自动注入到每个 Vue 实例（包括组件实例）中的。当在 main.js 文件中创建并使用 VueRouter 实例，并将其作为选项传递给 Vue 构造器时，Vue 将会自动处理注入过程。

// 导入 Vue 和 VueRouter
import Vue from "vue";
import VueRouter from "vue-router";
import App from "./App.vue"; // 你的主组件
import Home from "./components/Home.vue"; // 示例组件
import About from "./components/About.vue"; // 示例组件

// 创建 VueRouter 实例
const router = new VueRouter({
  routes: [
    { path: "/", component: Home },
    { path: "/about", component: About },
    //另一种写法： component: () => import("@/components/HelloWorld.vue")
  ],
});

// 注册 VueRouter 插件并注入 $router
Vue.use(VueRouter);

// 创建并挂载 Vue 根实例，传入 router
new Vue({
  router, // 这里是关键，传入 router 实例
  render: (h) => h(App),
}).$mount("#app");

在这个例子中，Vue.use(VueRouter) 是注册插件的必要步骤，然后在创建 Vue 根实例时，通过 router 选项将路由器实例传递给 Vue。这使得 $router 可以在任何组件中通过 this 访问。

// 在任何组件中，你都可以使用 $router
export default {
  methods: {
    navigateToAbout() {
      this.$router.push("/about");
    },
  },
};

Swiper11在Vue2项目中的使用

Wed, 10 Apr 2024 19:37:05 GMT

今年《天国：拯救 2》就要发售了，明年还有《GTA6》，期待( •̀ ω •́ )✧。

swiper11 在 vue2 项目中的使用

因为公司使用的仍然是 vue2，所以被迫在 vue2 项目下进行 swiper11 的使用，而 swiper 的中文文档是有很多坑的，英文文档是基于 vue3 的，所以记录以下自己在 vue2 下使用 swiper11 的爬坑过程（￣︶￣）↗ 　。

虽然 swiper 中文网有很多坑，但是还是把中文文档和官方文档都贴出来。

安装

尝试过 swiper7 版本，引入方式跟之后的版本很不一样，本文仅适用于 7 之后的版本。安装 swiper7 及以前的版本采用我的方法的话会报错，无法使用。

npm install swiper

导入包

正确的引入方式：

<script>
  import Swiper from "swiper";
  import "swiper/swiper-bundle.css";
</script>

使用

直接 copy 文档中的代码：

<template>
  <div class="swiper-demo">
    <div class="swiper">
      <div class="swiper-wrapper">
        <div class="swiper-slide">
          <img src="./assets/imges/1.png" alt="img-1" />
        </div>
        <div class="swiper-slide">
          <img src="./assets/imges/2.png" alt="img-1" />
        </div>
        <div class="swiper-slide">
          <img src="./assets/imges/3.png" alt="img-1" />
        </div>
      </div>
      <!-- If we need pagination -->
      <div class="swiper-pagination"></div>
      <!-- If we need navigation buttons -->
      <div class="swiper-button-prev"></div>
      <div class="swiper-button-next"></div>
      <!-- If we need scrollbar -->
      <div class="swiper-scrollbar"></div>
    </div>
  </div>
</template>

<script>
  export default {
    mounted() {
      new Swiper(".swiper", {
        // Optional parameters
        loop: true,
        // If we need pagination
        pagination: {
          el: ".swiper-pagination",
        },
        // Navigation arrows
        navigation: {
          nextEl: ".swiper-button-next",
          prevEl: ".swiper-button-prev",
        },
        // And if we need scrollbar
        scrollbar: {
          el: ".swiper-scrollbar",
        },
      });
    },
  };
</script>

到这里其实轮播图已经能正常显示了，关于 css 样式自行设置，这就是官方文档给出的使用方式，但是如果自己接着进行一下操作，马上就能发现问题。

如果自己操作一下的话，一定马上就能发现，分页器没有显示、左右导航键按了没反应，如果再尝试着加入auto: true的话，更会发现这个自动轮播功能根本就没有生效！

在网上找了很多，但都是老版本 swiper 或是 vue3 的，反正横竖不能解决问题，最后在查 swiper 的包时，终于发现了在其中有个modules文件夹，打开后马上恍然大悟，原来相关的模块都在这个文件夹里，要再引入！

那么接下来就简单了，正确的引入方式：

<script>
  import Swiper from "swiper";
  import { Autoplay, Pagination } from "swiper/modules";
  import "swiper/swiper-bundle.css";
  Swiper.use([Autoplay, Pagination]);
</script>

其中我只用了autoplay和pagination两个模块，需要什么再引入什么即可，再测试功能已能正常实现了。

图片的自适应问题

在写 banner 图时，发现一个问题，轮播图中使用的图片大小不同，会出现撑起的容器高度不一致，没法对其的情况，如果简单地采用明确的宽高(px 单位)，又无法自适应多种设备。

在网上找到了合适的教程，原理是使用 vw 解决，现简单的总结下：

理解 vw 单位，即将视窗宽度分为 100 份，每份即为 1vw；
width 正常设置为 100%，然后设置height: 需要图片的高度 / 设备宽度 * 100，例如我需要的正常图片高度为 624px，设备宽度为 768px，那么height: 624 / 750 * 100，即可得到需要的高度；
接下来使用到object-fit: cover，关于 object-fit，可以参考MDN；

参考地址

Erlang语言基础学习笔记

Wed, 17 Jan 2024 16:33:26 GMT

Erlang语言基础学习笔记

常用的一些语法

API类（及其实现）

%%%-------------------------------------------------------------------
%%% lists:max()
max([H|T]) -> max(T, H).
max([H|T], Max) when H > Max -> max(T, H);
max([_|T], Max)              -> max(T, Max);
max([],    Max)              -> Max.
%%%-------------------------------------------------------------------
%%% lists:min()
min([H|T]) -> min(T, H).
min([H|T], Min) when H < Min -> min(T, H);
min([_|T], Min)              -> min(T, Min);
min([],    Min)              -> Min. 
%%%-------------------------------------------------------------------
%%% lists:sum()
sum(L)          -> sum(L, 0).
sum([H|T], Sum) -> sum(T, Sum + H);
sum([], Sum)    -> Sum.
%%%-------------------------------------------------------------------
%%% lists:reverse()
reverse(List) ->
    reverse(List, []).
reverse([], Acc) ->
    Acc;
reverse([Head | Tail], Acc) ->
    reverse(Tail, [Head | Acc]).
%%%-------------------------------------------------------------------
%%% lists:member(Elem, List) 存在返回true,不存在返回false
member(_, []) -> false;
member(Element, [Element | _]) -> true;
member(Element, [_ | Tail]) -> member(Element, Tail).
%%%-------------------------------------------------------------------
%%% ++
concatenate_lists(List1, List2) ->
    case List1 of
        [] ->
            List2;
        [Head | Tail] ->
            [Head | concatenate_lists(Tail, List2)]
    end.
%%%-------------------------------------------------------------------

算术表达式

操作符	描述	参数类型
+ X	+ X	数字
- X	- X	数字
X * Y	X * Y	数字
X / Y	X / Y （浮点除法）	数字
X div Y	X被Y整除	整数
X rem Y	X除以Y的整数余数	整数

练习题总结

元组，列表相关练习题

遍历方式与累加器

对于列表的遍历，用尾递归，结合累加器，进行数据存储，示例：

test([H | T], Acc) ->
	test(T, [H | Acc]).

其中，H是列表的头元素，T是H以后的列表，[H | Acc]为通过头插的形式把H插入到Acc头部。

终止遍历条件

要终止对列表的遍历非常简单：

test([], Acc) ->
    Acc;
%% 以下为遍历
test([H | T], Acc) ->
	test(T, [H | Acc]).

这里的意思是，当传入的第一个参数，列表为空时，输出Acc。

简化调用API

继续上面，我们的累加器是自己设置的，实际用户调用的时候不需要设置Acc，所有调用接口可以简化：

-export([test/1]).

test(List) ->
    test(List, []).

test([], Acc) ->
    lists:reverse(Acc);
%% 以下为遍历
test([H | T], Acc) ->
	test(T, [H | Acc]).

一个简单的遍历列表并把每个元素加到累加器中的功能就写好了，如果需要的话可以用lists:reverse()将Acc进行反转。

索引的控制

一般情况下，在调用函数的时候就进行索引的比较与控制：

$$$ 计算数字列表或元组索引N到M的和

%% API
-export([get_sum/3]).

get_sum(List, N, M) ->
    get_sum(List, N, M, 1, []).

get_sum([], _, _, _, Acc) ->
    lists:sum(Acc);
get_sum([H | T], N, M, Index, Acc) when (Index =< M) and (Index >= N)->
    get_sum(T, N, M, Index + 1, [H | Acc]);
get_sum([_ | T], N, M, Index, Acc) ->
    get_sum(T, N, M, Index + 1, Acc).

其中，我们在调用get_sum函数的时候，就对要传入其中的Index参数进行了控制，并用关卡机制对Index进行了检查，使其能够完成题目的要求。

关于索引控制的经典例题：

%%% 替换元组或列表中指定位置的元素，新元素作为参数和列表或元组一起传入函数内

%% API
-export([replaceIdx/3]).

replaceIdx(List, Index, Val) ->
    replaceIdx(List, Index, Val, 1, []).

%% 列表空后反转累加器。
replaceIdx([], _, _, _, Acc) ->
    lists:reverse(Acc);

%% 到达替换位置的处理：把Val放到累计器的头部
replaceIdx([_ | Rest], Index, Val, Index, Acc) ->
%%    io:format("[~p]~n", [[Val | Acc]]),
    replaceIdx(Rest, Index, Val, Index + 1, [Val | Acc]);

%% 未到达指定位置：把头元素放到累加器的头部。
replaceIdx([Element | Rest], Index, Val, CurrentIndex, Acc) ->
%%    io:format("[~p]~n", [[Element | Acc]]),
    replaceIdx(Rest, Index, Val, CurrentIndex + 1, [Element | Acc]).

case与if表达式

%%% 对数字列表中的奇数进行求和，后除以3的商得值为A，并将偶数求和后除以3的余数得值为B，然后求A+B结果，输出A、B、A+B

%% API
-export([get_res/1]).

%% 求和
get_sum([]) -> 0;
get_sum([H | T]) -> H + get_sum(T).

%% 求偶数和
get_even_sum([], Acc) -> Acc;
get_even_sum([H | T], Acc) ->
    %% 这里的case用来做一种类似if的判断，如果`H rem 2 = 0`说明是偶数，就把H加到累加器中。
    case H rem 2 of
        0 -> get_even_sum(T, Acc + H);
        _ -> get_even_sum(T, Acc)
    end.

%% 求值
get_res([H | T]) ->
    A = get_sum([H | T]) div 3,
    B = q5:get_even_sum([H | T], 0) rem 3,
    {A, B, A + B}.

%%% 查找元素在元组或列表中的位置

%% API
-export([get_index/3]).

get_index([], _, _) -> 0; %% 不会用到的参数用_传入即可。
get_index([H | T], N, Index) when (Index =< T) ->
    if
        (H == N) ->
            Index;
        true ->
            get_index(T, N, Index + 1)
    end.

%%% 移除元组或列表中指定位置的元素

%% API
-export([remove/2]).

remove(List, Position) ->
    case Position of
        1 ->
            [H | T] = List,
            T;
        N when N > 1 ->
            [H | T] = List,
            [H | remove(T, N - 1)]
    end.

列表推导

[ F(X) || X <- L]标记的意思是“由F(X)组成的列表（X从列表L中提取）”。

%%% 对数字列表或元组，输出所有偶数乘以它在此列表或元组中的偶数位数

%% API
-export([evens_mul/1]).

evens_mul(List) ->
    Even = evens(List, [], 1),
    [H * Idx || {H, Idx} <- Even].

evens([], Even, _) ->
    Even;
%% 先拿到偶数与坐标
evens([H | T], Even, Idx) ->
    if
        H rem 2 == 0 ->
            evens(T, [{H, Idx} | Even], Idx + 1);
        true ->
            evens(T, Even, Idx)
    end.

冒泡排序

%%% 使用冒泡排序对列表进行排序

%% API
-export([bubble_sort/1]).

%% 取列表头作为最大值和
bubble_sort(List) ->
    bubble_sort(List, length(List)).

bubble_sort(List, 0) -> List; % 当迭代次数为 0 时，排序完成
bubble_sort(List, N) ->
    SortedList = bubble_pass(List, N), % 对列表进行下一趟冒泡,一个元素到达最终位置
    bubble_sort(SortedList, N - 1). % 递归的进行下一趟冒泡

bubble_pass([X, Y | Rest], N) when X > Y ->
    [Y | bubble_pass([X | Rest], N - 1)]; % 如果 X > Y 就交换他们
bubble_pass([X | Rest], N) ->
    [X | bubble_pass(Rest, N - 1)]; % 否则位置保持不变
bubble_pass([], _) -> [].

列表更方便的匹配方式

%%% 对一个字符串按指定符字劈分

%% API
-export([split/2]).

split(String, [C | _]) ->
    split_head(String, C, []).
split_tail([], _, RAcc) ->
    lists:reverse(RAcc);
split_tail([H | T], Seps, RAcc) ->
    split_tail(T, Seps, [H | RAcc]).
split_head([Seps | T], Seps, FAcc) ->
    [lists:reverse(FAcc), split_tail(T, Seps, [])];
split_head([H | T], Seps, FAcc) ->
    split_head(T, Seps, [H | FAcc]).

其中split_head([Seps | T], Seps, FAcc)为在传参，条件判断的时候就进行了匹配，更方便好用。

列表的链式反应

%%% 对相同类型的数据进行拼接

%% API
-export([merge_lists/2, merge_tuples/2, merge_binary/2]).

%% 列表拼接
merge_lists([], List2) -> List2;
merge_lists([Head | Tail], List2) ->
    [Head | merge_lists(Tail, List2)].

%% 元组拼接
merge_tuples(Tuple1, Tuple2) ->
    TupleList1 = tuple_to_list(Tuple1),
    TupleList2 = tuple_to_list(Tuple2),
    Tuples = merge_lists(TupleList1, TupleList2),
    list_to_tuple(Tuples).

%% 二进制拼接
merge_binary(Binary1, Binary2) ->
    BinaryList1 = binary_to_list(Binary1),
    BinaryList2 = binary_to_list(Binary2),
    BinaryList = merge_lists(BinaryList1, BinaryList2),
    list_to_binary(BinaryList).

[Head | merge_lists(Tail, List2)]为链式反应，不断把每次递归的头结点依次塞到该列表内。

字符串相关练习题

回文题

%%% 检查一个字符串是否是回文

%% API
-export([check/1]).

check(String) ->
    Middle = (length(String) div 2) + (length(String) rem 2),
    split_string(String, Middle, 1, []).
split_string([_ | T], Index, Index, Acc) ->
    check_equal(lists:reverse(Acc), split_string_right(T, []));
split_string([H | T], Index, CIndex, Acc) ->
    split_string(T, Index, CIndex + 1, [H | Acc]).
split_string_right([], Acc) ->
    Acc;
split_string_right([H | T], Acc) ->
    split_string_right(T, [H | Acc]).
check_equal(List, List) ->
    true;
check_equal(_, _) ->
    false.

多层嵌套

%%% 查找一个字符串中的最长单词

%% API
-export([check_max_length/1]).

%% 经过测试，空格是32
check_max_length(String) ->
    check_max_length(String, 32, 0, 0).
check_max_length([], _, Length, Max) ->
    check_max(Length, Max);
check_max_length([Seps | T], Seps, Length, Max) ->
    check_max_length(T, Seps, 0, check_max(Length, Max));
check_max_length([_ | T], Seps, Length, Max) ->
    check_max_length(T, Seps, Length + 1, Max).
check_max(Length1, Length2) ->
    if
        Length1 > Length2 ->
            Length1;
        true ->
            Length2
    end.

Web3.0与区块链简单调研

Wed, 13 Dec 2023 14:57:33 GMT

Web1.0、Web2.0、Web3.0简述

关于 Web 1.0 、Web 2.0 、Web 3.0 不同点:

Web 1.0 是用户读取互联网，Web 2.0 是用户写入互联网，Web3 是用户生活在互联网。

Web1.0简述

Web 1.0：第一代互联网，静态互联网；

Web 1.0 的核心为：平台创造、平台所有、平台控制、平台受益。

代表：静态网页、传统报刊、Yahoo

所谓的Web1.0，从用户角度来看，就是由平台单方面向用户输送信息，而用户仅具备只读权利，平台输送什么信息，用户就看什么信息。即我的这个博客也就是Web1.0

Web2.0简述

Web 2.0：第二代互联网，交互式互联网；

Web 2.0 的核心为：用户创造、平台所有、平台控制、平台受益。

代表：微博、Facebook

Web 2.0也是目前网络上最主要的形式，在Web2.0上，平台只需提供一个基础设施及环境，但平台创造的内容占比较小，且鼓励用户自我创作。在整个创作的环境、发布的平台、读者的阅读等，都将由平台掌握。

从用户角度来看 Web2.0，用户观看了其他用户在平台所创造的内容及收益，于是自己也想创造新的内容，这是创造者数量激增的原因。用户在遵守平台规则的同时，获得内容带来的收益，同时对自己的账户及内容有极大的自主控制权。

这无疑是平台为用户营造了一种虚假 Web3.0 的情况，因为无论是归属权、管理权还是利益分配，看似都在用户手中，实则均为平台说了算。

Web3.0简述

Web 3.0：第三代互联网，协议互联网；

Web 3.0 的核心为：用户创造、用户所有、用户控制、协议分配利益。

代表：区块链、元宇宙、NFT

在 Web 3.0 中，用户所创造的数字内容，归属权明确为用户所有，控制管理权明确由用户所有，其所创造的价值，根据用户与他人签订的协议进行分配。

Web3.0的特征

Web3.0是分布式的

（1）它不是集中式的，就没有单一的公司可以控制它；

（2）任何一种服务都有多家提供商，通过分布式协议连起来，用户可以极小的成本，从一个提供商转移到另一个服务商。

这里有个疑问，Web3.0真的能在中国的环境里成长吗？换句话说我国会允许Web3.0存在吗？

Web3.0利用区块链的协议创造与自动执行的技术，即通过智能合约，权利与价值的分配协议可以不通过第三方，即得到高效、准确、可信的执行，并且全过程可审计。用一句通俗易懂的话来说，就是“没有中间商赚差价”。但区块链只是手段，目的是实现用户数字资产权益的确认和保护。

Web3.0的核心特色是去中心化，用户的行为生成的一系列数据构成的资源库，并不是由某一个中心化的平台或媒体所掌握，而是大众共同拥有所有权和使用权。

区块链

区块链简述

区块链本质上是一个去中心化数据库。是一种分布式数据存储，点对点传输，共识机制，加密算法等计算机技术的新型应用模式。

举例：

比如说小明找大康借一百块钱，但大康怕他赖账，于是就找来村长做公证，并记录下这笔账，这个就叫中心化。但如果，你不找村长，直接拿个喇叭在村里大喊“我大康借给小明一百块钱！请大家记在账本里”，这个就叫去中心化。

以前村长德高望重，掌握全村的账本，大家都把钱存在他这里，这是过去大家对中心化的信任。现在，大家都担心村长会偷偷挪用大家的钱，怎么办呢？于是大家就给每个人都发了一本账本，任何人之间转账都通过大喇叭发布消息，收到消息后，每个人都在自家的账本上记下这笔交易，这就叫去中心化。有了分布式账本，即使老孔或老周家的账本丢了也没关系，因为老朱、老杨等其他家都有账本。

区块链特点

去中心化
开放性
安全
不可篡改
匿名性

其他

什么是Web3？和区块链的关系是什么？ - 知乎 (zhihu.com)

区块链白皮书（2023）问世，Web3.0助力网络空间安全_发展_数字_创新 (sohu.com)

Web3.0出海：日本区块链行业监管政策介绍_腾讯新闻 (qq.com)

粗谈区块链与Web3.0 - 知乎 (zhihu.com)：关于以太坊部分很有趣，对于区块链讲解很易懂。

个人对于何为赋值的新理解：将虚拟货币送给我的朋友，当然了现在它是没有任何价值的，因为我没有对其赋予任何价值。如果哪一天我公布说谁拥有这个虚拟货币，可以来找我领取10W人民币，那么瞬间，它的价值就是10W人民币。即一个产品是否真的能转化为真实的价值。

什么是Web3，为什么币圈的人都开始谈Web3了？-36氪 (36kr.com)

以太坊 - 维基百科，自由的百科全书 (wikipedia.org)

参考资料

一文读懂"什么是 Web 3.0 ？" - 知乎 (zhihu.com)

为什么 Web3 与区块链有关 - 阮一峰的网络日志 (ruanyifeng.com)

区块链是什么通俗解释 - 知乎 (zhihu.com)

Web3.0与区块链有何不同？现在处于哪个阶段？|区块链_新浪财经_新浪网 (sina.com.cn)

Vercel+CloudFlare实现近零成本Twikoo评论系统CDN加速

Thu, 23 Nov 2023 09:54:03 GMT

问题分析

可以通过Vercel对Twikoo评论系统服务进行免费的部署，但因为*.vercel.app因某种不可抗力在国内无法访问，所以用到了CloudFlare的免费CDN服务，来实现对评论系统的加速，实现国内网络环境也能访问的效果。

前置工作

已在Vercel成功部署Twikoo。

CloudFlare账户。

至少4块钱。

解决过程

成本一共6元钱——在腾讯云随便注册一个便宜的域名。

腾讯云控制台

在域名DNS解析里选快速添加解析，输入Vercel中项目的Domains地址，例如*.vercel.app，快速添加解析记录。

Vercel

进入Domains界面下，添加刚注册域名的域名，选择第三项，添加。

CloudFlare

点击add site输入自己的域名，一直下一步。

按照CloudFlare提示更换nameservers，具体为在腾讯云控制台，进入我的域名，选择修改DNS服务器，将CloudFlare提供的DNS服务器添加上去。

等待一段时间即可。

后记

因为免费的CloudFlare服务，其服务器在中国以外，实际上并不稳定，但是已经比原本一定不能访问到要强很多了，偶尔评论系统连接出现问题属正常现象。

关于CDN访问异常之重定向次数过多的问题，在我的上一篇文章里有写过了，遇到问题的伙伴可以看看，希望能有所帮助。

CDN访问异常之重定向次数过多

Thu, 21 Sep 2023 15:53:37 GMT

问题原因

源站开启了HTTP重定向至HTTPS的功能，并且CDN控制台上配置的回源端口为80。在这种情况下，由于CDN回源端口为80，客户端无论是通过HTTP还是HTTPS访问CDN加速域名时，CDN在回源的时候都是使用HTTP请求源站，此时会触发源站的HTTPS强制跳转逻辑，然后源站会要求CDN重新发送一个HTTPS的请求，但是CDN回源的时候仍然会发送HTTP回源请求，然后再进行跳转，以此类推，就会出现反复重定向问题，最终导致出现报错。

可见无限301重定向的情况

解决方法

查了一下相关资料，CloudFlare导致的重定向次数过多可以通过将“SSL/TLS 加密模式”设置为完全（Strict）解决。

其他产品的CDN可以通过将回源端口设置为443来解决，CDN回源时会以HTTPS协议请求源站，就不会触发源站的强制跳转逻辑。

另一种方法是将协议跟随回源设置为“跟随”。设置为跟随以后，源站发起HTTPS重定向以后，CDN回源协议跟随为HTTPS回源。

经验总结

自行用F12控制台分析网络连接情况，定位问题，然后查找相关资料。

计算机开发综合知识总结（偏Java方向）

Thu, 24 Aug 2023 02:44:45 GMT

数据结构

列表

数组
链表
队列，栈

树

二叉树
搜索树
堆/优先队列

push(1);push(3);push(2);pop();pop();pop();
栈：2; 3; 1
队列：1; 3; 2
优先队列：1; 2; 3

图

无向图
有向图
有向无环图

图的算法

深度优先遍历
广度优先遍历
拓扑排序
最短路径/最小生成树

Java集合类型

ArrayList和LinkedList的区别

都是线性表的结构，他们都是List接口，但是实现不同，ArrayList是数组实现，LinkedList是链表实现。

HashMap和Hashtable的区别

Hashtable是Java 1的遗留产物；

Hashtable不允许null；

Hashtable线程安全，因为所有危险函数都加了synchronized（一种同步锁），会让开销变得很大；

HashMap更快，想要线程安全用ConcurrentHashMap。

二叉树

前序遍历
- 先遍历树根
- 前序遍历左子树
- 前线遍历右子树
中序遍历
- 中序遍历左子树
- 遍历树根
- 中序遍历右子树
后序遍历
- 后序遍历左子树
- 后序遍历右子树
- 遍历树根

二叉树的性质

非空二叉树上第k层上至多有$2^{k-1}$个结点（k>=1）
高度为h的二叉树至多有$2^h-1$个结点（h>=1）
- 满二叉树：高度为h的有$2^h-1$个结点（h>=1）的二叉树
- 满二叉树：每一层有$2^{k-1}$个结点
非空二叉树上的叶节点数等于度为2的结点数加1，即$n_0$=$n_2$+1
- 设度为0，1，2的结点个数分别为$n_0,n_1,n_2$，结点总数$n=n_0+n_1+n_2$
具有n个（n>0）结点的完全二叉树的高度为$log_2(n+1)$（n向上取整）或$log_2n+1$（n向下取整）

根据前序中序构造二叉树

前序：树根 + （左子树 + 右子树）

中序：（左子树） + 树根 + （右子树）

递归思想，不停找树根，定左右子树，即可构造出二叉树！

二叉查找树和中序遍历

因为二叉查找树每一个左子树都比根小，每一个右子树都比根大，所以它的中序遍历序列是从小到大的。

B/B+树

一文彻底搞懂MySQL基础：B树和B+树的区别_mysql b树和b+树的区别-CSDN博客

m阶B/B+树

每个非叶子节点（除根外）至多有m个儿子，至少有[m/2]个儿子
根节点（如果不是叶子）至少有两个儿子
所有叶子节点在同一层

B/B+树的区别

B树的值可以出现在非叶子节点上，B+树真正有用的东西全在叶子节点上，它的根和非叶子节点作用在于帮助找到这个真正的数值所在的地方。

B树和二叉搜索树的区别

B树的每一个节点可以放更多的元素，可以有更多的儿子——为了优化磁盘的读写次数（磁盘存取次数与B树的高度成正比）。

红黑树

【精选】【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树_小七mod的博客-CSDN博客

进制转换

例：13 --> 三进制 --> 111

1 * 3 * 3 + 1 * 3 + 1 = 13

13 % 3 = 1 13 / 3 = 4

4 % 3 = 1 4 / 3 = 1

1 % 3 = 1 1 / 3 = 0

二进制运算

位运算

与（&）（两位同时为 1，结果才为 1，否则为 0）

  1 0 0 1 1
& 1 1 0 0 1
------------------------------
  1 0 0 0 1

或（|）（参加运算的两个位只要有一个为 1，其值为 1 ）

  1 0 0 1 1
| 1 1 0 0 1
------------------------------
  1 1 0 1 1

异或（^）（参加运算的两个位只要不相同则为 1）

  1 0 0 1 1
^ 1 1 0 0 1
-----------------------------
  0 1 0 1 0

取反（~）（0 则变为 1，1 则变为 0）

~ 1 0 0 1 1
-----------------------------
  0 1 1 0 0

实例

int a = 5; //二进制表示为 101
int b = 3; //二进制表示为 011
int c = a & b; //与运算，结果为 001，即 1
int d = a | b; //或运算，结果为 111，即 7
int e = a ^ b; //异或运算，结果为 110，即 6
int f = ~a; //取反运算，结果为 11111111111111111111111111111010，即-6

移位运算

位运算包括左移（<<）、右移（>>）以及无符号右移（>>> , 无符号右移就是右移之后，无论该数为正还是为负，右移之后左边都是补上 0），它们分别将一个二进制数左移或右移一定的位数。

int a = 5; //二进制表示为 101
int b = a << 1; //左移一位，结果为 1010，即 10
int c = a >> 1; //右移一位，结果为 10，即 2
int d = a >>> 1; //无符号右移一位，结果为 10，即 2

位运算赋值运算符

位运算赋值运算符（&=、|=、^=、<<=、>>=、>>>=）是将位运算结果赋值给左操作数的运算。

int a = 5; //二进制表示为 101
int b = 3; //二进制表示为 011
a &= b; //相当于 a = a & b 
a |= b; //相当于 a = a | b
a ^= b; //相当于 a = a ^ b
a <<= 1; //相当于 a = a << 1
a >>= 1; //相当于 a = a >> 1
a >>>= 1; //相当于 a = a >>> 1

操作系统

进程和线程

进程包含若干个线程、逻辑内存（不同进程间的内存相互独立——为了安全性）以及文件/网络句柄（不同进程所共有的，以打开同一个文件或抢同一个网络的端口）。

线程包含栈、PC（放在内存中；下一条执行指令的地址）以及TLS。

操作系统实际真正在运行的是一个一个的线程，进程只是一个容器。

Java线程基本方法详解_java中线程相关的基本方法-CSDN博客

线程让步可以通过 yield ()方法来实现,该方法和 sleep ()方法有点相似,都可以让当前正在运行的线程暂停,区别在于 yield() 方法不会阻塞该线程,它只是将线程转换成就绪状态,让系统的调度器重新调度一次。当某个线程调用 yield ()方法之后,只有与当前线程优先级相同或者更高的线程才能获得执行的机会。

线程安全不安全的区别在于有没有加锁机制。

存储

快寄存器贵

| 缓存 |

| 内存 |

慢硬盘便宜

寻址空间

进程里面指针能取到的地址的范围。

32位-->4G

64位-->~10^19Bytes

进程间通信

文件
Signal Linux上常见
消息队列

消息队列（定义、结构、如何创建、消息队列的发送与接收、发送与接收实例）_消息队列的数据结构_咋么又饿了的博客-CSDN博客

MQ（消息队列）功能介绍 - 简书 (jianshu.com)

管道/命名管道

匿名管道

匿名管道主要用于本地父进程和子进程之间的通信，只支持半双工通信。

第一：匿名管道只能实现本地进程之间的通信，不能实现跨网络之间的进程间的通信。

第二：匿名管道只能实现父进程和子进程之间的通信，而不能实现任意两个本地进程之间的通信。

共享内存
同步机制，如信号量

信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常会被作为一种锁机制，用于防止某进程正在访问共享资源时，其他进程也来访问该资源。

Socket 重要

Socket 连接是计算机网络中的一种通信机制，它允许两个程序在不同计算机上通过网络进行通信。在使用套接字进行通信时，一个程序作为客户端，另一个程序作为服务器端，它们通过创建和使用套接字进行数据传输。我们可以将套接字理解为网络通信的接口，它提供了一种标准的通信方式，使得不同的程序能够在网络上进行数据交换。

在Socket 连接中，客户端程序首先会向服务器端发送一个连接请求，服务器端会接受这个连接请求，然后通过套接字与客户端进行通信。在通信过程中，客户端和服务器端通过套接字发送和接收数据。一旦通信完成，连接就会被断开，套接字也会被关闭。

（1）在计算机网络中，Socket 连接是一种重要的通信机制。它允许两个程序在不同计算机上进行实时通信，通过套接字的创建和使用来实现数据的传输。

（2）在 Socket 连接中，我们需要指定套接字的一些参数，例如 IP 地址、端口号、协议等等，以确保通信能够顺利进行。

（3）常见的协议有 TCP 和 UDP 两种，它们在数据传输的方式和效率上有所不同。

TCP 协议是一种可靠的协议，它保证数据在传输过程中不会丢失或损坏。TCP 协议通过连接的建立、数据的传输和连接的释放等步骤来保证数据的完整性和可靠性。TCP 协议适合于需要数据传输可靠性的场合，例如文件传输、网页浏览等。

UDP 协议是一种不可靠的协议，它不对数据传输的可靠性做出保证。UDP 协议的传输速度比 TCP 更快，但在传输过程中数据可能会丢失或损坏。UDP 协议适合于实时通信，例如视频和音频流的传输。

（4）Socket 连接被广泛应用于网络游戏、视频和音频流、文件传输、网络聊天、远程控制等方面。

中断

中断（interrupt）是指CPU对I/O设备发来的中断信号的一种响应。CPU暂停正在执行的程序，保存CPU现场环境后，自动转去执行该I/O设备的中断处理程序。执行完后再回到断点，继续执行原来的程序。陷入和陷阱（trap）时由CPU内部事件所引起的中断。中断和陷入的主要区别是信号的来源不同，即来自CPU外部（外中断或硬中断）还是CPU内部（内中断或软中断）。

同步

原子操作 (Atomic)。是指比如在一个原子操作哪检查和增加一个变量的值，中间不被打断。这保证了数据的完整性。但对于运行时长，其实没啥关系。
互斥锁 (Mutex)。互斥，就是我只让一个人干活，其他人都等着。然后这个人运行时间还长，占着这个锁不放，系统的性能就非常低了。因此互斥锁更好的用于运行时间较短的任务。
自旋锁 (SpinLock)。这个锁采用了不是被挂起，而是通过不断循环检查锁是否释放的机制。这个检查的过程是消耗CPU的。肯定只能适用于更短的任务。比如毫秒级。
信号量 (Semaphore)。信号量是所有这些同步元语中稍微复杂的一种。信号量确保了同时最多只能有n个人占着“坑”干活。相对来说，这里面的活可以干的久一点。

同步和异步的区别

同步就相当于是当客户端发送请求给服务端，在等待服务端响应的请求时，客户端不做其他的事情。当服务端做完了才返回到客户端。这样的话客户端需要一直等待。用户使用起来会有不友好。

异步就相当于当客户端发送给服务端请求时，在等待服务端响应的时候，客户端可以做其他的事情，这样节约了时间，提高了效率。

Linux系统

Linux命名空间概述

计算机网络

五层协议的体系结构

应用层

运输层

网络层

数据链路层

物理层

OSI的体系结构

应用层

表示层

会话层

运输层

网络层

数据链路层

物理层

网络传输

不可靠

丢包，重复包
出错
乱序

不安全

中间人攻击
窃取
篡改

滑动窗口

TCP协议
维持发送方/接收方缓冲区

计算机网络（7）——滑动窗口_接收窗口跟滑动窗口的区别-CSDN博客

能更好地利用带宽和流量控制。

TCP协议

建立连接->三次握手:发[SYN];接[SYN, ACK];发[ACK]

断开连接->四次挥手:发[FIN];接[ACK];接[FIN];发[ACK]

理解TCP序列号（Sequence Number）和确认号（Acknowledgment Number）_relative sequence number-CSDN博客

Acknowledgment number：期待收到的包。

三次握手之后建立可靠的联系，可以发送HTTP协议。

网络是不可靠的，任何包都有可能丢
遇见问题，解决问题，不断迭代
能用就好

TCP协议要达成什么目的？

TCP协议是一种基于连接的协议，在连接的基础上达到一种可靠的传输。可靠的传输指发包的顺序和收包的顺序是一样的、能够保证包不出错、流量控制（不会发得太快来不及收）、拥塞控制（网络出现拥塞的时候不会使情况进一步恶化）。

TCP协议如何做到流量控制、拥塞控制？

流量控制：滑动窗口

计算机网络——TCP的拥塞控制（超详细） - 特务依昂 - 博客园 (cnblogs.com)

因为网络层不会提供拥塞的反馈信息，所以TCP协议采用的是第一种方式——自己判断网络的拥塞情况。当TCP检测到网络拥塞，则降低数据的发送速率，否则增加数据的发送速率。

TCP与UDP的区别

基于连接与无连接；
对系统资源的要求（TCP较多，UDP少）；
UDP程序结构较简单；
流模式与数据报模式；
TCP保证数据正确性，UDP可能丢包；
TCP保证数据顺序，UDP不保证。

部分例题

TCP采用的滑动窗口大小为0是合法的。
传输问题，已知距离、数据大小、要求时间、传输速率，问发送缓冲区最小设置大小
- 一个来回的时间：距离 / 传输速度 * 2
- 来回的最多次数：要求传输时间 / 一个来回的时间
- 每次来回最少传输大小：文件大小 / 来回的最多次数

帧同步

帧同步是通过在数据传输过程中插入同步字节或同步信号来保证数据的同步。

【网络同步】浅析帧同步和状态同步 - 知乎 (zhihu.com)

DHCP与NAT的含义与作用

两个协议都是IP协议。

DHCP（动态主机配置协议）是一个局域网的网络协议。指的是由服务器控制一段IP地址范围，客户机登录服务器时就可以自动获得服务器分配的IP地址和子网掩码。

NAT英文全称是“Network Address Translation”，中文意思是“网络地址转换”，它允许一个整体机构以一个公用IP地址出现在Internet上。

顾名思义，它是一种把内部私有网络地址（IP地址）翻译成合法网络IP地址的技术。简单的说，NAT就是在局域网内部网络中使用内部地址，而当内部节点要与外部网络进行通讯时，就在网关（可以理解为出口，打个比方就像院子的门一样）处，将内部地址替换成公用地址，从而在外部公网（internet）上正常使用，NAT可以使多台计算机共享Internet连接，这一功能很好地解决了公共IP地址紧缺的问题。

子网掩码

例：A和B的IP地址分别为10.105.1.113和10.105.1.91，它们需要在一个子网中，求他们的子网掩码，选出不能使用的那个

	10.105.1.113	10.105.1.91
	00001010.01101001.00000001.01110001	00001010.01101001.00000001.01011011
255.255.255.0	11111111.11111111.11111111.00000000	11111111.11111111.11111111.00000000
255.255.255.128	11111111.11111111.11111111.10000000	11111111.11111111.11111111.10000000
255.255.255.192	11111111.11111111.11111111.11000000	11111111.11111111.11111111.11000000
255.255.255.224	11111111.11111111.11111111.11100000	11111111.11111111.11111111.11100000

可知到255.255.255.224时不能使用，其实……根本不用算，这道题可以直接盲选嘛。

SSH

SSH简介及两种远程登录的方法_ssh @-CSDN博客

Secure Shell(SSH) 是由 IETF(The Internet Engineering Task Force) 制定的建立在应用层基础上的安全网络协议。它是专为远程登录会话(甚至可以用Windows远程登录Linux服务器进行文件互传)和其他网络服务提供安全性的协议，可有效弥补网络中的漏洞。通过SSH，可以把所有传输的数据进行加密，也能够防止DNS欺骗和IP欺骗。还有一个额外的好处就是传输的数据是经过压缩的，所以可以加快传输的速度。目前已经成为Linux系统的标准配置。

SSH之所以能够保证安全，原因在于它采用了非对称加密技术(RSA)加密了所有传输的数据。

数据库

关系型数据库

基于关系代数理论
缺点：表结构不直观，实现复杂，速度慢
优点：健壮性高，社区庞大

事务

事务管理（ACID）

原子性（Atomicity）

原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

一致性（Consistency）

事务前后数据的完整性必须保持一致。

隔离性（Isolation）

事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。

持久性（Durability）

持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。

事务的隔离级别

Read uncommitted

读未提交，即一个事务可以读取另一个未提交事务的数据；并发操作会导致脏读。

Read Committed

读操作，即一个事务要等到另一个事务提交后才能读取数据；解决脏读问题；并发操作会导致不可重复读。

Repeatable Reads

重复读，即开始读取数据（事务开启）时，不再允许修改操作；解决不可重复读问题；并发操作会导致幻读（对应insert操作）。

Serializable

序列化，最高的事务隔离级别，该级别下，事务串行化顺序执行；避免脏读、不可重复读与幻读；但是该级别效率低下，比较消耗数据库性能，一般不用。

乐观锁

乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。

读取数据，记录Timestamp
修改数据
检查和提交数据

MySQL数据库的锁 --- 六种分类 - 14种锁详细介绍_mysql 数据库锁-CSDN博客

重点看粒度

范式

什么是第一，第二，第三范式_第一范式第二范式第三范式的定义-CSDN博客

第一范式：简单说列不能再分

第二范式：简单说建立在第一范式基础上，消除部分依赖

第三范式：简单说建立在第二范式基础上，消除传递依赖。

索引

【精选】MySQL 数据库--索引（理论详解及实例演示）_https://blog.csdn.net/weixin_51486343/article/deta-CSDN博客

最好把要查的字段都加上索引，不然会很慢，怎么知道有没有索引呢？用EXPLAIN去看，看type，ref就是对的。

主键和外键会自动建索引，自己把要查的数据量大的字段加上索引。

索引的实现

B树
B+树
二叉树优先比较次数，B/B+树优化磁盘读写次数

数据库索引的作用

加快查找速度
约束数据的值

数据库索引的分类

浅谈 MySQL 索引的分类 - 知乎 (zhihu.com)

数据库的连接池

建立连接要花很多时间
每个用户建立连接造成浪费

内连接和外连接

数据库-内连接与外连接的区别(举例说明)_数据库内连接和外连接的区别举例-CSDN博客

内连接：

取出两张表中匹配到的数据，匹配不到的不保留。

外连接：

取出连接表中匹配到的数据，匹配不到的也会保留，其值为NULL。

外连接的分类：

左外连接，右外连接，全外连接

当前读和快照读

当前读：每次读取的都是当前最新的数据，但是读的时候不允许写，写的时候也不允许读。
快照读：读写不冲突，每次读取的是快照数据，
- 隔离级别Repeatable Read下（默认隔离级别）：有可能读取的不是最新的数据
- Read Committed隔离级别下：快照读和当前读读取的数据是一样的，都是最新的。

当前读

Mysql实现当前读是通过共享锁+排他锁+Next-Key Lock实现的。

每次对行数据进行读取的时候，加共享锁。此时就不允许修改，但是允许其他事务读取，所以每次都可以读到最新的数据。
每次对行数据进行修改的时候，加排他锁，不允许其他事务读取和修改。这种情况下其他事务读取的数据也一定是最新的数据。
每次对范围行数据进行读取的时候，对这个范围加一个范围共享锁。
每次对范围行数据进行修改的时候，读这个范围加一个范围排它锁。

基于上述锁机制，实现当前读，确保每次读取的都是最新的数据。

快照读

mysql中的快照读是通过MVCC+undolog实现的。快照读，顾名思义，就是读取快照数据，也就是说当某个数据正在被修改的时候，也可以进行读取该数据，保证读写不冲突。刚刚提到undolog，当我们对记录做了变更操作时，就会产生undo记录，undo记录中存储的是老版数据，当一个旧的事务需要读取数据时，为了能够读取到老版本的数据，需要顺着undo列找到满足其可见性的记录，这个找满足可见行的记录依赖。就是说每次都是读取undolog中的数据。

MVCC

MVCC也称多版本并发控制，说的通俗易懂一点就是记录数据的不同版本。实际上，不同事务或者相同事务的对同一记录的修改，会导致该记录的undo log成为一条记录版本线性表，既链表，undo log的链首就是最新的旧记录，链尾就是最早的旧记录。所以快照读都是去读取undolog中链首的最新的旧记录。

undolog

在操作数据之前,把需要操作的数据和事务记录备份到undo log中,目的就是为了保证原子性，如果一个事务执行中发生了故障，就可以通过undolog进行回滚。

常见问题

介绍一下关系型数据库的理论基础

基于关系代数理论，一到五范式。

给定一个场景，请设计表结构

至少到三范式

如何生成安全且不易重复的数据库ID？

[如何生成安全且不易重复的数据库ID？_生成不重复id_谢少迪的博客-CSDN博客](https://blog.csdn.net/youngerxsd/article/details/131001528#:~:text=使用自增主键可能会暴露数据库信息，采用随机数生成id%2C而使用随机数作为ID有重复的风险，下面我提供一些建议。 1、UUID（通用唯一识别码）%3A,可以考虑使用UUID作为主键。 UUID是一个128位的数字，其生成算法旨在确保在不同计算机和时间上生成的ID具有极低的重复概率。)

程序设计与算法

归类

类型检查

编译时：C，C++，Java，GO
运行时：Python，Perl，JavaScript，Ruby

运行/编译

编译为机器代码运行：C，C++

速度快

编译为中间代码，在虚拟机运行：Java，C#

提供程序跨平台的能力

解释执行：Python，Perl，JavaScript

不需要编译，看到一行代码就运行一行代码

编程范式（Programming Paradigm）

面向过程：C，Visual Basic
面向对象：Java，C#，C++，Scala
函数式：Haskell，Erlang

常见问题

比较一下Java和C++语言

介绍一下面向对象思想

介绍一下函数式编程，函数式编程和函数指针的区别

Java创建对象的几种方式

【面试题】Java中创建对象的方式有几种？_创建对象的方式有哪些面试题-CSDN博客

Java IO

Java 把 Input输入流和 Output 输出流，统称为IO流，它的核心就是对文件的操作，对于字节、字符类型的输入和输出。

IO流主要分为两大类，字节流和字符流。字节流可以处理任何类型的数据，如图片，视频等，字符流只能处理字符类型的数据。

IO流的本质是数据传输，并且流是单向的。

Java——IO流超详细总结 - 说故事的五公子 - 博客园 (cnblogs.com)

Java IO学习整理 - 知乎 (zhihu.com)

数据类型

整数类型

32位int的范围

-2^31 ~ 2^31-1

补码

取反加1

符号位可以和数值位一起参加运算
可以直接利用加法的形式计算整数间的减法
唯一表示0，没有+0，-0
总共表示2^32个数

浮点数与定点数

64位double范围：+/-10^308

64位double精度：10^15

浮点数比较

因为精度问题，直接比较经常出错，常用Math.abs(a - b) < eps ?来判断

使用BigDecimal算钱

Java数据类型

primitive type: int, long, float ...
- 值类型
- 用a == b来判断值相等
Object: Integer, Long, Float, String ...
- 引用类型
- 用a == b判断是否为同一个Object
- 用a.equals(b)或Object.equals(a, b)判断是否相等

什么是值传递，什么是引用传递

在Java里面primitive type之间就是值传递，Object之间就是引用传递。

在C++里面值传递和引用传递由程序员说了算。

String s = new String("test");创建了多少对象

两个对象。

equals和hashCode的关系

hashCode相等不一定equal，但equal一定hashCode相等。

什么是序列化和反序列化

当我们把内存中的对象转成字节流就是序列化，反序列化就是把字节流还原成原来的对象放进内存。

装箱和拆箱

Integer a = 2; // Boxing
Integer b = new Integer(2); // Boxing
int v = a.intValue(); // Unboxing

new Integer(2) == 2; // true-->编译的时候会自动帮我们拆箱
new Integer(2) == new Integer(2); // false
Integer.valueOf(2) == Integer.valueOf(2); // true 数值比较小的时候会分配到同一个箱子，但是当数值比较大的时候可能不会分配到同一个箱子，即可能true可能false
Integer.valueOf(2).intValue() == 2; // true
new Integer(2).equals(new Integer(2)); // true

面向对象

面向对象编程三大特性------封装、继承、多态_面向对象，封装继承多态-CSDN博客

就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

从用户（终端用户，使用代码的用户）的角度思考问题，摈弃完全基于逻辑的思维。（易读性）

封装

系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是无需知道对象内部的细节，但可以通过该对象对外的提供的接口来访问该对象。

对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。

1、良好的封装能够减少耦合。

2、类内部的结构可以自由修改。

3、可以对成员进行更精确的控制。

4、隐藏信息，实现细节。

尽量只使用private和public

继承

继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。

1、子类拥有父类非private的属性和方法。

2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

3、子类可以用自己的方式实现父类的方法。。

多态

一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

Java实现多态有三个必要条件：继承、重写、向上转型。

不可变性

final关键字

类声明-->类不可以被继承
函数声明-->函数不可以在派生类中重写
变量声明-->变量不可以指向其他对象

不可变性的实现

final关键字无法保证不可变性
从接口定义，类的实现上保证不可变性

类与对象

类的成员变量-->对象状态
类的成员函数-->对象行为
类的静态变量

没有this引用，全局变量。

类的静态函数

普通函数可以引用静态变量、静态函数。

静态函数引用普通成员变量、函数是编译错误的。

对象上引用静态变量、函数会被编译器警告。

类的特殊函数

构造函数
equals
hashCode
toString

接口与抽象类

接口里面定义了很多函数，但是他们没有实现，这个就叫接口，它做到了一个合约的作用，明确对象需要满足什么样的要求。

为什么要有接口的概念

从用户（使用实现的代码）角度看问题，用户不需要关心它是怎么实现的。

接口与类相比

由编译器强制的一个模块间协作的合约（Contract）；
无成员变量；
成员函数只能申明不能有实现。

接口的申明

Java：interface BankEndPoint {...}
C++：一个全部是纯虚函数的类
Python/大部分动态语言：依靠注释申明

接口和抽象类的区别

从实现角度看

抽象类可以有成员变量

抽象类可以有部分实现

抽象类不可以多重继承，接口可以

父类/子类的实例化/析构顺序

实例化顺序为先父类再子类，析构反之。

final(Java)和const(C++)的作用

final可以用在变量上也可以用在方法、类上。

C语言中const关键字的用法-CSDN博客

虚函数与纯虚函数

C++ 虚函数和纯虚函数的区别 | 菜鸟教程 (runoob.com)

虚函数：它虚就虚在所谓"推迟联编"或者"动态联编"上，一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被称为"虚"函数。虚函数只能借助于指针或者引用来达到多态的效果。

纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。纯虚函数的声明就是在告诉子类的设计者，"你必须提供一个纯虚函数的实现，但我不知道你会怎样实现它"。

多重继承

C++允许多重继承，Java不允许，但实现接口可以。

Iterable接口

【Java】Iterable接口的使用_iterable的用法_何为xl的博客-CSDN博客

泛型

JAVA中泛型和Object的区别_使用范型和object的区别-CSDN博客

ArrayList<Integer>是List<Integer>

List<Integer>不是List<Object>

// 把List<Integer>转换成List<Object>
// 1.
new ArrayList<Object>(intList);
// 2.能运行，但危险！
(List<Object>)(List)intList;

C++中的虚函数表

C++虚函数表剖析 | Leo的技术分享 (leehao.me)

Java里所有的函数都相当于C++里的虚函数。

理解指针的指向，引用的对象，vtable->虚函数表，在其中找到虚函数。

程序编码

数学归纳法（俗称……找规律，显然法，高数里高阶函数问题常用的方法，这里用来推程序正确性）

用于证明断言对所有自然数成立

证明对于N=1成立
证明N>1时：如果对于N-1成立，那么对于N成立

递归控制

要点

严格定义递归函数的作用，包括参数、返回值、Side-effect
先写一般情况，后写特殊情况
每次调用必须缩小问题规模
每次问题规模缩小程度必须为1

不要尝试递归改非递归

一般化的方法仍需要使用栈
代码复杂
不能根本解决问题

循环控制

循环不变式

是一句断言定义各变量所满足的条件，说人话就是变量进入循环必须满足的条件。

循环书写方法

定义循环不变式，并在循环体每次结束后保持循环不变式
先一般，后特殊
每次必须向前推进循环不变式中涉及的变量值
每次推进的规模必须为1

边界控制

凭经验。

静态绑定与动态绑定

java的动态绑定与静态绑定(彻底理解多态与重载)-CSDN博客

静态绑定是发生在编译阶段；而动态绑定是在运行阶段；

重载方法(overloaded methods)使用的是静态绑定，而重写方法(overridden methods)使用的是动态绑定

常见问题

如何判断对象已死亡

【JAVA】如何判断对象已经死亡？_java 如何判断对象已经“死去”-CSDN博客

引用计数法

程序给对象添加一个引用计数器，每有一个变量引用它时，计数器加1。当引用断开时，计数器减1。当计数器为0时，代表着没有任何变量引用它，该对象就是死亡状态，JVM需要对此类对象进行回收。

可达性分析法

程序创建一系列的GC Roots作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链，当一个对象与GC Roots没有任何引用链相连的话，即此对象到GC Roots不可达，则证明此对象是不可用的，JVM稍后将会对此类对象进行回收。

web开发安全问题

[web开发常见的几大安全问题 - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/113179679#:~:text=web开发常见的几大安全问题 1 1、涉及到私密信息使用post请求，因为信息放在请求体中而不像get请求暴露在url上 2 2、HTTPS。 ... 3,XSS。 ... 7 7、点击劫持，点击劫持是一种视觉欺骗的攻击手段。 ... 8 8、URL跳转漏洞，借助未验证的URL跳转，将应用程序引导到不安全的第三方区域，从而导致的安全问题。更多项目)

设计模式

单例模式

确保全局至多只有一个对象
用于：构造缓慢的对象，需要统一管理的资源
缺点：很多全局状态，线程安全性

实现的方法为先判断实例存在与否，如果存在则直接返回，如果不存在就创建了再返回，这就确保了一个类只有一个实例对象

工厂模式

工厂模式通常会分成3个角色：

工厂角色-负责实现创建所有实例的内部逻辑
抽象产品角色-是所创建的所有对象的父类，负责描述所有实例所共有的公共接口
具体产品角色-是创建目标，所有创建的对象都充当这个角色的某个具体类的实例

观察者模式

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，其所有依赖者都会收到通知并自动更新。

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

暂未分类

分布式

大白话告你什么是分布式，史上最全详解！ - 知乎 (zhihu.com)

分布式ID

全局唯一性

不能出现有重复的ID标识，这是基本要求。

递增性

确保生成ID对于用户或业务是递增的。

高可用性

确保任何时候都能生成正确的ID。

高性能性

在高并发的环境下依然表现良好。

UUID

Java自带的生成一串唯一随机36位字符串（32个字符串+4个“-”）的算法。它可以保证唯一性，且据说够用N亿年，但是其业务可读性差，无法有序递增。

雪花算法

Twitter开源的由64位整数组成分布式ID，性能较高，并且在单机上递增。

面试官：讲讲雪花算法，越详细越好 - 知乎 (zhihu.com)

MVC

基础 | 三层架构与MVC模式 - 知乎 (zhihu.com)

MVC模式是软件工程中常见的一种软件架构模式，该模式把软件系统（项目）分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。

使用MVC模式有很多优势，例如:简化后期对项目的修改、扩展等维护操作；使项目的某一部分变得可以重复利用；使项目的结构更加直观。

具体来讲，MVC模式可以将项目划分为模型（M）、视图（V）和控制器（C）三个部分，并赋予各个部分不同的功能，方便开发人员进行分组。

设计原则

六大设计原则超详细介绍（再不理解你打我） - 知乎 (zhihu.com)

单一职责原则：一个类或接口只承担一个职责。
里氏替换原则：在继承类时，务必重写（override）父类中所有的方法，尤其需要注意父类的protected方法（它们往往是让你重写的），子类尽量不要暴露自己的public方法供外界调用。
依赖倒置原则：高层模块不应该依赖于低层模块，而应该依赖于抽象。抽象不应依赖于细节，细节应依赖于抽象。
接口隔离原则：不要对外暴露没有实际意义的接口。
迪米特法则：尽量减少对象之间的交互，从而减小类之间的耦合。
开闭原则：对软件实体的改动，最好用扩展而非修改的方式。

深拷贝与浅拷贝

浅拷贝只复制指向某个对象的指针，而不复制对象本身，相当于是新建了一个对象，该对象复制了原对象的指针，新旧对象还是共用一个内存块。

深拷贝是新建一个一模一样的对象，该对象与原对象不共享内存，修改新对象也不会影响原对象。

GC

【JAVA核心】Java GC机制详解-CSDN博客

程序运行时，内存空间是有限的，那么如何及时的把不再使用的对象清除将内存释放出来，这就是GC要做的事。

需要进行回收的对象就是已经没有存活的对象，判断一个对象是否存活常用的有两种办法：引用计数和可达分析。

(1)程序调用System.gc时可以触发

(2)系统自身来决定GC触发的时机（根据Eden区和From Space区的内存大小来决定。当内存大小不足时，则会启动GC线程并停止应用线程）

主要做了清理对象，整理内存的工作。

标记-清除算法，标记-压缩算法，复制算法，分代收集算法。

新一代垃圾回收器ZGC的探索与实践 - 美团技术团队 (meituan.com)

与CMS中的ParNew和G1类似，ZGC也采用标记-复制算法，不过ZGC对该算法做了重大改进：ZGC在标记、转移和重定位阶段几乎都是并发的，这是ZGC实现停顿时间小于10ms目标的最关键原因。

Redis

Redis【入门】就这一篇！ - 知乎 (zhihu.com)

NoSQL是一种基于内存的数据库，并且提供一定的持久化功能。Redis的性能十分优越，可以支持每秒十几万此的读/写操作，其性能远超数据库，并且还支持集群、分布式、主从同步等配置，原则上可以无限扩展，让更多的数据存储在内存中，更让人欣慰的是它还支持一定的事务能力，这保证了高并发的场景下数据的安全和一致性。

Redis 在 Java Web 主要有两个应用场景：

存储缓存用的数据；
需要高速读/写的场合使用它快速读/写；

Redis是什么？看这一篇就够了 - 葡萄城技术团队 - 博客园 (cnblogs.com)

相比于其他数据库类型，Redis具备的特点是：

C/S通讯模型
单进程单线程模型
丰富的数据类型
操作具有原子性
持久化
高并发读写
支持lua脚本

Redis 的应用场景包括：缓存系统（“热点”数据：高频读、低频写）、计数器、消息队列系统、排行榜、社交网络和实时系统。

Redis提供的数据类型主要分为5种自有类型和一种自定义类型，这5种自有类型包括：String类型、哈希类型、列表类型、集合类型和顺序集合类型。

什么是Redis？简述它的优缺点？_redis介绍和优缺点_SONNIE在路上的博客-CSDN博客

Redis的特点

【精选】简述redis特点及其应用场景-CSDN博客

Redis的一些问题

【面试】redis缓存穿透、缓存击穿、缓存雪崩区别和解决方案-CSDN博客

缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求。由于缓存是不命中时被动写的，并且出于容错考虑，如果从存储层查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。

接口层增加校验，如用户鉴权校验，id做基础校验

缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力。

接口限流与熔断，降级

设置热点数据永远不过期

加互斥锁

缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。

如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。

设置热点数据永远不过期。

JVM中导致OOM的原因与解决

1篇文章搞清楚8种JVM内存溢出（OOM）的原因和解决方法-阿里云开发者社区 (aliyun.com)

堆溢出
永久代/元空间溢出
方法栈溢出
非常规溢出
swap溢出
本地方法溢出

字节对齐

例：

class` `A {
  ``int` `a;
  ``short` `b;
  ``int` `c;
  ``char` `d;
};
class` `B {
  ``double` `a;
  ``short` `b;
  ``int` `c;
  ``char` `d;
};

在32位机器上用gcc编译以上代码，求sizeof(A)，sizeof(B)分别是（）

A ----->   △△△△||△△==||△△△△||△=== 

B ----->  △△△△△△△△||△△==(short)△△△△(int)||△=======

其中△为数据存储，=为填充

A: int a （4个字节） 4

short b (2个字节，起始地址4是2的倍数，不补) 4+2

int c (4个字节，4+2不是4的倍数，补2个 ) 4+2+2（补）+4

char d (1个字节，4+2+2+4是1的倍数，不补) 4+2+2（补）+4 +1

最后补3个字节，让整体大小为4的倍数 4+2+2(补)+4+1+3（补） =16

B: double a （8个字节） 8

short b (2个字节，起始地址8是2的倍数，不补) 8+2

int c (4个字节，8+2不是4的倍数，补2个 ) 8+2+2（补）+4

char d (1个字节，8+2+2+4是1的倍数，不补) 8+2+2（补）+4 +1 最后补7个字节，让整体大小为8的倍数 8+2+2(补)+4+1+7（补） =24

总结

结构体变量的首地址必须是内部最宽数据类型的倍数
按顺序一个变量一个变量看，要求current变量的首地址必须是自己大小的倍数。
到了最后一个变量，要求整个结构体的大小的最宽数据类型的倍数。

排序算法

算法复杂度与初始状态无关的有：选择排序、堆排序、归并排序、基数排序；
元素总比较次数与初始状态无关的有：选择排序、基数排序；
元素总移动次数与初始状态无关的有：归并排序、基数排序。

简单排序算法

插入排序

就像扑克牌一张张排序一样，我们每次从牌堆摸一张牌到手上，就把牌插入相应的位置。

for (int i = 0; i < a.length; i++) {
  for (int j = i; j > 0 && a[j] < a[j - 1]; j--) {
    swap(a, j, j - 1);
  }
}

选择排序

我们考虑桌上有一堆面相上的明牌，我们要排序的话，通常会先选择A，然后选择2,3…K，完成排序。选择排序就是这样，每次从数组中剩下的元素中选择最小的那个即可。

for (int i = 0; i < a.length; i++) {
  // a[0...i)为原数组中最小的i个元素排序完成的结果
}

冒泡排序

for (int i = 0; i < a.length; i++) {
  for (int j = a.length - 1; j > i; j--) {
    if (a[j] < a[j - 1]) {
      swap(a, j, j - 1);
    }
  }
}

在里层的for里面，我们j是反向移动的，这个非常重要。每次这样反向比较+交换一轮之后，我们总能保证剩下的数据中最小的数被换到a[i]的位置，这个交换的过程就像在模拟气泡在水中慢慢升起的过程。

高效排序算法

平均复杂度为O(nlogn)的算法。

快速排序

快速排序和归并排序更是“分治”思想方法的典型体现。

void sort(int[] a) {
  // 分组：扫描a，把比a[0]小的数移到左边，把比a[0]大的数移到a[0]右边。
  // 递归：对于左右两半边分别递归调用sort
}

归并排序

void sort(int[] a) {
  // 分组：把a分成左右两边，这次我们不管数据大小，直接中间切一刀，分组就完成了
  // 递归：把左右两边分别递归调用归并排序，获得两个排好序的子数组
  // 归并：把两个排好序的子数组进行归并
}

把问题分成（若干个）互相独立的子问题，分别解决它们，并把子问题的解合成最终解。

堆排序

所有数据建堆
不断从堆中取出一个元素，重复n次。由于堆中取出的总是最小元素，因此排序完成。

非基于比较的排序算法

计数排序

我们考虑一个问题，如果我告诉你我们所有的数据都是0-100的范围内的整数，但是数据的个数非常大，我们如何来排序呢？我们这样来做

分别数一下有几个0，有几个1，几个2。。。
计算累进的计数c，c[i]为<=i的个数。比如有2个0，3个1，那么c[0]=2, c[1]=5
这个累进的计数c有一个重要的特点，数值为i的数在排好序的数组中位于[ c[i-1]…c[i] )
利用这个累进计数的特点，可以重建出排序结果

桶排序

扫描数据，放在自己建立的对应的“桶”里。

基数排序

根据位数来排序，不需要像桶排一样人为指定桶。

比如

原始数据：       10,21,17,34,44,11,654,123
根据个位数排序：  10,21,11,123,34,44,654,17
根据十位数排序：  10,11,17,21,123,34,44,654
根据百位数排序：  10,11,17,21,34,44,123,644

总结

算法	平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
插入排序	n2	n	n2	1	稳定
选择排序	n2	n2	n2	1	不稳定
冒泡排序	n2	n	n2	1	稳定
快速排序	nlogn	nlogn	n2	logn	不稳定
归并排序	nlogn	nlogn	nlogn	n	稳定
堆排序	nlogn	nlogn	nlogn	1	不稳定
计数排序	n+s			n+s	稳定
桶排序	n+s			n+s	稳定
基数排序	dn			n	稳定

RocketMQ因内存不足无法启动的一个坑（Linux）

Thu, 15 Jun 2023 14:34:29 GMT

RocketMQ启动了将近一个小时，均无法启动，以失败告终，查了一堆文档，都没有找到解决方法，最后找到logs文件，里面记录了error原因，系JVM内存不足，于是才终于找到解决方法。

到bin文件夹下，修改runserver.sh、runbroker.sh、tools.sh三个文件中以下值：~~默认设定为8g和4g，怪不得我的小破云服务器启动不起来，不是，就一个消息队列都这么吃内存吗？~~

JAVA_OPT="${JAVA_OPT} -server -Xms256m -Xmx256m -Xmn128m"

相关参数

Xms 是指设定程序启动时占用内存大小。一般来讲，大点，程序会启动的快一点，但是也可能会导致机器暂时间变慢。 Xmx 是指设定程序运行期间最大可占用的内存大小。如果程序运行需要占用更多的内存，超出了这个设置值，就会抛出OutOfMemory异常。 xmn 年轻代的heap大小，一般设置为Xmx的3、4分之一。

成果

终于启动成功，但是似乎还有一些其他建议，与GC有关，暂时先忽略，等之后优化，仅此记录一下。

本地远程连接云服务器上Docker下的MySQL

Mon, 12 Jun 2023 14:51:26 GMT

Linux

docker ps
docker exec -it [container name] /bin/bash
mysql -u -p
# 对远程连接进行授权
GRANT ALL ON *.* TO 'root'@'%';
# 刷新权限
flush privileges;

云服务器实例

在网卡中新建安全组，新增MySQL规则。

Navicat

通过SSH连接虚拟机及其中Docker下的MySQL数据库

Sat, 10 Jun 2023 21:10:11 GMT

通过SSH连接虚拟机

Oracle VM VirtualBox

MobaXterm

连接其中Docker下的MySQL数据库

在Docker中成功启动MySQL，确认Docker中MySQL无问题。

在Oracle VM VirtualBox中给端口转发列表添加Docker中映射的端口。

在宿主机中打开cmd，用ipconfig查到虚拟机ip地址。

打开Navicat，输入对应信息即测试连接。

基于Astro的全新静态网站搭建部署回顾

Sun, 04 Jun 2023 12:02:01 GMT

问题分析

网站地址：Home • 云升的手推车 (yunsheng-car.cn)

之前有过计划做一个用来个人记录生活（游记、影评等等）的网站，于是在上周周末的时候开始完成了这个网站，这次不想再用Hexo框架，想尝试一下新鲜的东西，于是选中了去年正式发布并迅速迭代的Astro框架（2023Web框架性能报告），并且这次直接采用Vercel部署，尝试引入CMS，原本以为有相关的技术经验，但是这次还是遇到了不少麻烦。

首先是Astro作为一款极新的前端框架，目前国内相关教程极少，较老框架来说门槛较高，好在有比较详尽的官方文档，基本还是可以自主解决问题。

其次是困扰最久的CMS（内容管理系统，方便编辑管理Web内容），由于Astro是新框架，与之相关的CMS文档就更少了，而且是全英文档，后续在打包的package.json配置文件和CMS相关配置以及schema等模块方面都花了较长的时间处理解决，最后才终于解决，并通过TinaCMS Cloud连接GitHub仓库实现生产模式部署。

前置工作

Node.js
TinaCMS
VS Code
GitHub
Vercel

过程重点

Astro

Astro的基本构建是最简单的，参考Astro官方文档就可以简单地通过脚手架搭建，入门指南 🚀 Astro 文档，大多数资料都可以参考官方文档解决，完成简单的构建后的各种调试以及组件的引入、部署才是困难的地方。

CDN

CDN和这篇文章中的操作一直，已经踩过的坑后面就很难再踩了，照着完成即可。

VS Code

Astro项目推荐用VS Code进行编写以及终端调试。

TinaCMS

最折磨的地方，第一次尝试使用CMS，而且还是全英文的文档，需要慢慢啃，花了两天的时间才自己啃下来，目前已经实现了远程控制。

但是我还不知道该怎么记录这块，虽然我是都啃下来了，但是要写这块的实现的话可能得单独写一整篇文章，而且有些功能还没有完全实现，可能等以后更加熟悉了会专门记录一下。

基本原理是连接GitHub仓库，然后远程对GitHub存储库的内容进行管理。

后记

目前感受来看Astro框架确实比Hexo好很多，Hexo的优势似乎只剩下使用门槛低了，但后续的管理远不如Astro，大概到明年Astro更加成熟，并且我也对其更加熟练以后应该会把博客迁移过去。

后续想利用其做个个人简历使用，这个大概月底前完成吧，目前又要把精力回到毕设和竞赛上了。

这次的折腾其实收获很大，主要在于自主解决问题的能力得到了验证和提升，我觉得这是很重要的，以后总会遇到不会的事情，自己能不能够解决至关重要。

部分使用远程客户端连接MySql时报错问题的解决

Wed, 24 May 2023 14:21:47 GMT

使用网上一些老旧的项目来完成课设时出现连接不上Mysql报错：

报错原因：mysql8 之前的版本中加密规则是mysql_native_password,而在mysql8之后,加密规则是caching_sha2_password

查看Mysql版本：

查看SQL用户信息：

select host,user,plugin,authentication_string from mysql.user;

修改密码：

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '123456';
更新user为root，host为localhost 的密码为123456

参考文章：Mysql 解决1251- Client does not support authentication protocol requested by server...的问题_慕城南风的博客-CSDN博客

补充一个mysql8.0的连接问题

网上有些项目用的是老版mysql，我个人电脑用的是mysql8.0.27版本，与老版项目jar包版本不符，需要更换对应版本jar包。

MySQL :: Download MySQL Connector/J (Archived Versions)

数据库配置文件：

dataSource.driverClass=com.mysql.cj.jdbc.Driver
dataSource.jdbcUrl=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC

算法学习笔记

Sun, 16 Apr 2023 00:33:43 GMT

工作后就停更啦！

入门

循环结构

P1307数组反转

如何将数字逐位剥离

while (n != 0)
{
    int t = n % 10;
    n /= 10;
}

如何求解

int ans = 0;
ans = 10 * ans + t;

随机数

计算机通过确定的算法生成“伪随机数”，因此每次执行随机数算法前都要“喂给它”不同的初始值(srand()函数)作为随机数种子，这样才能生成不同的随机数。喂给它当前的时间就是一个比较好的选择，当然也可以把部分输入数据作为随机数种子。

int ans;
srand(time(0)); // 以当前时间作为随机数种子
ans = rand() % 100 + 1; // 定义变量ans是一个1~100的随机数

rand() % a 看起来能产生一个 0 到 a - 1 的随机数，但是每个数字并不是等可能的。假设 RAND_MAX 是 32767 ，取 0 ~ 99 的随机数时，抽到 0 ~ 67 的可能要比剩下的数字大一点。如果 RAND_MAX 远大于 a 时，影响并不大。

质数口袋

P5723 【深基4.例13】质数口袋 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

如何判断质数：如果一个大于1的整数仅能被1和自身整除，它就是一个质数，否则就是合数（1既不是质数也不是合数）。

#include <iostream>
using namespace std;

int main()
{
    int L;
    cin >> L;
    int i = 2, weight = 0, count = 0;
    // 从2开始
    for (int i = 2;; i++)
    {
        bool flag = true; // 质数标识
        for (int j = 2; j * j <= i; j++)
            if (i % j == 0)
            {
                flag = false; // i可以被j整除，i不是质数，标识改变
                break;        // 退出j的for循环
            }
        if (flag == false)
            continue; // 如果不是质数，i++，进入while的下一循环
        if (i + weight > L)
            break; // 如果超重了，直接退出循环
        cout << i << endl;
        count++;
        weight += i;
    }
    cout << count << endl;
    return 0;
}

质因数分解

P1075 [NOIP2012 普及组] 质因数分解 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

想复杂了，只要找出 n 的最小约数，再用 n 除以这个数，就能得到结果。~~其实这是一道数学题~~

一个数能且只能分解为一组质数的乘积。

#include <iostream>
using namespace std;

int main()
{
    long long n;
    cin >> n;
    for (int i = 2; i <= n; i++)
        if (n % i == 0)
        {
            cout << n / i;
            break;
        }
    return 0;
}

其他

常见的输入输出占位符

占位符	说明
%d	一个十进制整数
%nd	输出一个整数，如果不足 n 位，前面用空格补齐直到够 n 位
%.nf	输出一个固定n位小数的浮点数
%0nd	输出一个整数，如果不足 n 位，前面用 0 补齐知道够 n 位
%c	一个 char 类型的字符
%s	一个字符串

关于浮点数精度误差

一种解决方式是先乘以 10^n 让其不触及浮点数，最后将其结果除回来。

数学函数

函数原型	说明
double sin(double x) double cos(double x)	三角函数正弦和余弦，x是弧度
double exp(double x)	返回$$e^x$$，其中e是自然常熟
double pow(double x, double y)	返回$$x^y$$，也可以用来运算多次根式
double sqrt(double x)	返回$$\sqrt{x}$$
double ceil(double x)	返回大于或等于x的最小的整数值(上取整)

命令行过长导致SpringBoot项目无法启动问题解决方法

Sun, 13 Nov 2022 13:55:36 GMT

application.yml文件过长后项目无法启动了，最后找到了解决方法：

如图设置即可！

hexo博客美化

Tue, 12 Apr 2022 14:00:29 GMT

鼠标点击爆炸特效

在制作完评论系统后逛博客时看到的不错的烟花爆炸特效博文地址。

在 Blog\themes\particlex\source\js 目录下创建文件 fireworks.min.js 。

在 Blog\themes\particlex\layout 目录下打开 layout.ejs 文件，添加：

<canvas
	id="fireworks"
	style="position: fixed; top: 0; left: 0; width: 100vw; height: 100vh; pointer-events: none; z-index: 32767"
></canvas>
<script src="https://cdn.staticfile.org/animejs/3.2.1/anime.min.js"></script>
<script src="/js/fireworks.min.js"></script>

流星雨特效

根据主题作者的原教程使用。

在 Blog\themes\particlex\source\js 目录下创建文件 background.min.js 。

在 Blog\themes\particlex\layout 目录下打开 layout.ejs 文件，添加：

<canvas
    id="background"
    style="position: fixed; top: 0; left: 0; width: 100vw; height: 100vh; pointer-events: none; z-index: -1"
></canvas>
<script src="/js/background.min.js"></script>

补充

要将背景图片层级上移，在 Blog\themes\particlex\source\css 目录下对 main.css 文件进行修改：

#home-head #home-background {
    background-position: center;
    background-repeat: no-repeat;
    background-size: cover;
    height: 100vh;
    left: 0;
    position: absolute;
    top: 0;
    width: 100vw;
    z-index: 0;
}

代码雨特效

在 Blog\themes\particlex\source\js 目录下创建文件 digitalrain.min.js

在 Blog\themes\particlex\source\css 目录下创建文件 digitalrain.min.css

在 Blog\themes\particlex\layout 目录下打开 layout.ejs 文件，添加：

<!-- 数字雨 -->
<canvas id="canvas" width="1440" height="900" ></canvas>
<link rel="stylesheet" href="/css/digitalrain.min.css" />
<script type="text/javascript" src="/js/digitalrain.min.js"></script>

补充

因为在 layout.ejs 文件下设置会在全局生效，而代码雨在文章页会显得非常乱，所以我把其挪到了 index.ejs 文件下，然后将流星雨特效放回 layout.ejs 文件，即可实现代码雨特效仅在主页生效。

用Git上传项目到GitHub或Gitee

Tue, 12 Apr 2022 00:19:50 GMT

上传本地项目到GitHub

在GitHub上创建一个仓库，进入仓库，点击 code ，在展开菜单内复制仓库路径。

Git全局设置

全局环境已设置可略过

$ git config --global user.name "云升"
$ git config --global user.email "bycj1106@163.com"

用Git上传到仓库

$ mkdir 项目名 #一般略过这一段！
$ git init
$ touch README.md
$ git add README.md
$ git commit -m "first commit"
$ git remote add origin git@gitee.com:Gitee仓库路径.git
$ git push -u origin "main" #Gitee上似乎是master

Git的部分指令注释

$ git init #把这个目录变成Git可以管理的仓库
$ git add README.md #文件添加到仓库
$ git add . #不但可以跟单一文件，还可以跟通配符，更可以跟目录。一个点就把当前目录下所有未追踪的文件全部add了 
$ git commit -m "first commit" #把文件提交到仓库
$ git remote add origin git@github.com:wangjiax9/practice.git #关联远程仓库
$ git push -u origin master #把本地库的所有内容推送到远程库上

.gitignore文件的使用方法

# dir 不需要提交的目录
/node_modules

# file 不需要提交的文件
config.ini

# log 不需要提交的任意包含后缀名为log的文件
*.log

# Package Files 不需要提交的任意包含后缀名为jar的文件
*.jar

简明指南

git 简明指南 (runoob.com)