## 简介

作为一门编程语言，操作文件是必不可少的功能需求。

本文记录一些使用 `Golang` 语言操作文件的示例。

前排提示：有些API用到的 `os` 库函数，可能已经弃用，变更为 `ioutil`



## 文件夹

### 创建

```go
package main

import (
	"fmt"
	"os"
)

func main() {
	// 创建单个文件夹
	err := os.Mkdir("mydir", 0755)
	if err != nil {
		fmt.Println("Error creating directory:", err)
	}

	// 递归创建多层文件夹
	err = os.MkdirAll("mydir/subdir/subsubdir", 0755)
	if err != nil {
		fmt.Println("Error creating directory:", err)
	}
}
```

### 删除

```go
package main
import (
	"fmt"
	"os"
)

func main() {
	// 删除单个文件夹
	err := os.Remove("mydir")
	if err != nil {
		fmt.Println("Error removing directory:", err)
	}

	// 递归删除文件夹及其所有子文件夹和文件
	err = os.RemoveAll("mydir/subdir")
	if err != nil {
		fmt.Println("Error removing directory:", err)
	}
}
```

### 检查

```go
package main

import (
	"fmt"
	"os"
)

func main() {
	// 检查文件夹是否存在
	_, err := os.Stat("mydir")
	if os.IsNotExist(err) {
		fmt.Println("Directory does not exist.")
	} else {
		fmt.Println("Directory exists.")
	}
}
```

### 获取

```go
package main

import (
	"fmt"
	"os"
)

func main() {
	// 要读取的文件夹路径
	dirPath := "mydir"

	// 打开文件夹
	dir, err := os.Open(dirPath)
	if err != nil {
		fmt.Println("Error opening directory:", err)
		return
	}
	defer dir.Close()

	// 读取文件夹内部的文件和子文件夹列表
	fileInfos, err := dir.Readdir(-1) // -1 表示读取文件夹内的所有内容
	if err != nil {
		fmt.Println("Error reading directory:", err)
		return
	}

	// 遍历文件夹内的文件和子文件夹列表
	fmt.Println("Files and subdirectories in", dirPath, ":")
	for _, fileInfo := range fileInfos {
		// 打印文件名或子文件夹名
		fmt.Println(fileInfo.Name())

		// 如果是子文件夹，则打印 " (Dir)" 标记
		if fileInfo.IsDir() {
			fmt.Println(" (Dir)")
		}
	}
}
```

## 文件

### API
Go语言提供了许多用于文件操作的标准库，主要包含在 os 和 io/ioutil 包中。以下是一些常见的文件相关操作：

- `os.Open(name string) (*File, error)`：打开指定名称的文件用于读取。
- `os.Create(name string) (*File, error)`：创建或截断指定名称的文件用于写入。
- `file.Close() error`：关闭文件。
- `file.Read(b []byte) (n int, err error)`：从文件中读取数据到字节切片。
- `file.Write(b []byte) (n int, err error)`：将字节切片写入文件。
- `ioutil.ReadFile(filename string) ([]byte, error)`：读取整个文件的内容到字节切片。
- `ioutil.WriteFile(filename string, data []byte, perm os.FileMode) error`：将字节切片写入文件。
- `os.FileInfo` 接口：提供了关于文件或文件夹的信息，如名称、大小、权限等。
- `file.Stat() (FileInfo, error)`：返回文件信息。
- `filepath.Join(elem ...string) string`：连接多个路径元素为一个路径。
- `filepath.Abs(path string) (string, error)`：返回绝对路径。

其他操作：

- 文件权限管理：`os.Chmod(name string, mode FileMode) error`
- 文件重命名：`os.Rename(oldpath, newpath string) error`
- 文件截断：`file.Truncate(size int64) error`
- 文件权限获取：`file.Chmod(mode FileMode) error`

这些是Go语言中一些常用的文件操作函数和方法。您可以根据具体的需求使用这些函数和方法来进行文件的读取、写入、创建、删除等操作。

### 示例

这里有几个最简单的示例。
```go
package main

import (
	"fmt"
	"io/ioutil"
	"os"
)

func main() {
	// 创建文件并写入内容
	content := []byte("Hello, world!")
	err = ioutil.WriteFile("mydir/myfile.txt", content, 0644)
	if err != nil {
		fmt.Println("Error writing file:", err)
		return
	}

	// 读取文件内容并打印
	data, err := ioutil.ReadFile("mydir/myfile.txt")
	if err != nil {
		fmt.Println("Error reading file:", err)
		return
	}
	fmt.Println("File content:", string(data))

	// 删除文件
	err = os.Remove("mydir/myfile.txt")
	if err != nil {
		fmt.Println("Error removing file:", err)
		return
	}

	fmt.Println("File operations completed successfully.")
}

```

## 赞助请求V3

**建站因为热爱，生活需要Money，请屏幕前的大佬动动您发财的小手，点击一次以示鼓励，祝您生活愉快！**


<div class="article-ads"></div>

> PS：就目前的访问量，即便每个访客都点一次广告，收入也不足以支付运营成本。`如果看不到广告，可能是网络原因或被拦截了，那就算了吧。再次祝您生活愉快~~`

go语言读取文件相关操作

## 简介

学习 `Python` 的时候，相信大家都接触过写一个贪食蛇类似的小练习。

下面是一个使用 `Pyhton` 实现的贪食蛇程序（使用`freegames`）：

|run|game over|
|--|--|
|![game1](https://images.oldmoon.top/images/dingdangdog/dingdangdog1711682222358.png)|![game2](https://images.oldmoon.top/images/dingdangdog/dingdangdog1711682338058.png)|

其中黑色是蛇，绿色是食物。

PS：代码由 `ChatGPT` 优化并生成。



## 成功运行的源码

```python
from random import randrange
from freegames import vector, square
import turtle

food = vector(0, 0)
snake = [vector(10, 0)]
position = vector(0, -10)

def change(x, y):
    position.x = x
    position.y = y

def is_inside(head):
    return -200 < head.x < 190 and -200 < head.y < 190

def generate_food():
    while True:
        food.x = randrange(-15, 15) * 10
        food.y = randrange(-15, 15) * 10
        if food not in snake:
            break

def move():
    head = snake[-1].copy()
    head.move(position)
    
    if not is_inside(head) or head in snake:
        turtle.update()
        turtle.color('red')
        turtle.goto(0, 0)
        turtle.write("Game Over!", align="center", font=("Arial", 24, "normal"))
        return
    
    snake.append(head)  # 将新的蛇头添加到蛇的列表中
    
    if head == food:
        print('Snake:', len(snake))
        generate_food()
    else:
        snake.pop(0)  # 移除蛇的尾部，以实现蛇的移动
    
    turtle.clear()  # 清除之前的绘制
    
    for body in snake:
        square(body.x, body.y, 9, 'black')
    
    square(food.x, food.y, 9, 'green')
    turtle.update()
    turtle.ontimer(move, 100)

def main():
    turtle.setup(420, 420, 370, 0)
    turtle.hideturtle()
    turtle.tracer(False)
    move()
    turtle.listen()
    turtle.onkey(lambda: change(10, 0), 'Right')
    turtle.onkey(lambda: change(-10, 0), 'Left')
    turtle.onkey(lambda: change(0, 10), 'Up')
    turtle.onkey(lambda: change(0, -10), 'Down')
    turtle.done()

if __name__ == '__main__':
    main()

```

## 贪食蛇源码优化过程

原本是使用国内AI `小艺` 生成的代码，但是有问题，所以使用 `ChatGPT` 优化了一下，最终正确运行了贪食蛇程序，下面是与 `ChatGPT` 的对话记录：

### User

找出以下代码问题并优化： 

```python
from random import randrange  #导入随机函数
from freegames import vector, square  #导入向量函数与绘图函数
import turtle  #导入绘图海龟模块

food = vector(0, 0)  #食物
snake = [vector(10, 0)]  #蛇
position = vector(0, -10)  #移动位置，一步的距离为10

def change(x, y):  #改变蛇的移动方向
  position.x = x
  position.y = y

def is_inside(head):  #判断蛇头是否在窗体内
  return -200 < head.x < 190 and -200 < head.y < 190

def move():  #可以让蛇移动的方法
  head = snake[-1].copy()  #确定蛇头的位置
  head.move(position)  #移动一步
  if not is_inside(head) or head in snake:  #如果蛇的头部位于边界外或者蛇头在蛇的身体中
    square(head.x, head.y, 9, 'red')  #绘制红色蛇头，说明游戏结束
    turtle.update()  #更新
    return snake.append(head)  #更新蛇的位置
  if head == food:  #如果蛇吃到食物
    print('Snake:', len(snake))  #根据蛇的长度进行加分
    food.x = randrange(-15, 15) * 10  #随机生成食物x坐标
    food.y = randrange(-15, 15) * 10  #随机生成食物y坐标
  else:
    snake.pop(0)  #移除蛇走过的坐标
    turtle.clear()  #清空蛇走过的位置
  for body in snake:  #循环遍历蛇的坐标
    square(body.x, body.y, 9, 'black')  #绘制黑色蛇
    square(food.x, food.y, 9, 'green')  #绘制绿色食物
    turtle.update()
    turtle.ontimer(move, 100)  #定时执行move函数

if name == 'main':  #程序入口
  turtle.setup(420, 420, 370, 0)  #创建窗体大小
  turtle.hideturtle()  #隐藏箭头显示
  turtle.tracer(False)  #关闭绘画效果
  move()  #调用让蛇移动的方法
  turtle.listen()  #事件监听器
  turtle.onkey(lambda: change(10, 0), 'Right')  #按键盘右键，蛇向右走
  turtle.onkey(lambda: change(-10, 0), 'Left')  #按键盘左键，蛇向左走
  turtle.onkey(lambda: change(0, 10), 'Up')  #按键盘上键，蛇向上走
  turtle.onkey(lambda: change(0, -10), 'Down')  #按键盘下键，蛇向下走
  turtle.done()  #停止画笔绘制，但绘图窗体不关闭
```



### ChatGPT

以下是对代码中存在的问题的诊断和优化建议：

1.  **事件处理位置问题**： 在当前代码中，事件处理函数 `move()` 中被递归调用，这会导致事件处理被阻塞，因为每次调用 `move()` 都会等待递归调用结束。这意味着蛇只会在一个移动周期后才响应新的按键事件。  
    **解决方案**： 将 `turtle.ontimer(move, 100)` 移动到主程序中的键盘事件处理函数中。这样，每次按下键盘时都会重置定时器，从而实现即时响应。
    
2.  **食物生成位置问题**： 食物生成的位置不应该与蛇的位置重叠。当前代码中，食物生成位置是随机的，可能会与蛇的身体位置重叠，这样会导致游戏不公平。  
    **解决方案**： 添加一个函数来确保食物不会生成在蛇的身体上。可以在食物生成时检查其位置，并在需要时重新生成。
    
3.  **游戏结束条件**： 当蛇撞到边界或者撞到自己时，游戏应该结束并给出相应的提示。当前的代码只是在蛇头超出边界或撞到自己时绘制一个红色的方块，但并没有给出任何提示。  
    **解决方案**： 在游戏结束时，可以在界面上显示一个提示信息，例如 "Game Over!"，并停止游戏进行。
    
4.  **代码结构问题**： 目前的代码结构不够清晰，逻辑上存在一些混乱。例如，键盘事件处理函数中既有对移动的处理，又有食物生成的逻辑。这种混合可能会导致代码更难维护和理解。  
    **解决方案**： 将代码模块化，将不同的逻辑功能分别放入不同的函数中，使代码更易读和维护。
    

基于以上问题和解决方案，以下是对代码的优化和改进后的版本：

```python
from random import randrange
from freegames import vector, square
import turtle

food = vector(0, 0)
snake = [vector(10, 0)]
position = vector(0, -10)

def change(x, y):
    position.x = x
    position.y = y

def is_inside(head):
    return -200 < head.x < 190 and -200 < head.y < 190

def generate_food():
    while True:
        food.x = randrange(-15, 15) * 10
        food.y = randrange(-15, 15) * 10
        if food not in snake:
            break

def move():
    head = snake[-1].copy()
    head.move(position)
    
    if not is_inside(head) or head in snake:
        turtle.update()
        turtle.color('red')
        turtle.goto(0, 0)
        turtle.write("Game Over!", align="center", font=("Arial", 24, "normal"))
        return
    
    if head == food:
        print('Snake:', len(snake))
        generate_food()
    else:
        snake.pop(0)
    
    for body in snake:
        square(body.x, body.y, 9, 'black')
    
    square(food.x, food.y, 9, 'green')
    turtle.update()
    turtle.ontimer(move, 100)

def main():
    turtle.setup(420, 420, 370, 0)
    turtle.hideturtle()
    turtle.tracer(False)
    move()
    turtle.listen()
    turtle.onkey(lambda: change(10, 0), 'Right')
    turtle.onkey(lambda: change(-10, 0), 'Left')
    turtle.onkey(lambda: change(0, 10), 'Up')
    turtle.onkey(lambda: change(0, -10), 'Down')
    turtle.done()

if __name__ == '__main__':
    main()

```

在优化后的代码中，主要改进了事件处理、食物生成、游戏结束逻辑以及代码结构，使代码更清晰易懂，游戏逻辑更合理。

### User

报错ModuleNotFoundError: No module named 'freegames'

### ChatGPT

看起来代码中引用的模块 `freegames` 无法被找到，导致了 `ModuleNotFoundError` 错误。这可能是因为在您的环境中缺少了这个模块，或者这个模块没有被正确安装。

解决这个问题有几种方法：

1. **安装 `freegames` 模块**：您可以尝试通过 `pip` 命令安装 `freegames` 模块。在命令行中运行以下命令：
   ```bash
   pip install freegames
   ```
   这将会从 PyPI（Python Package Index）安装 `freegames` 模块到您的 Python 环境中。

2. **检查 `freegames` 模块位置**：如果您已经安装了 `freegames` 模块，但是代码仍然报错，可能是因为 Python 解释器无法找到该模块。您可以检查 Python 的模块搜索路径，确保模块被正确安装并位于 Python 解释器可以找到的路径中。

3. **修改代码使用本地模块**：如果您没有找到 `freegames` 模块或者无法安装它，您可以尝试修改代码，以使用您本地环境中已有的模块替代 `freegames`。或者您也可以尝试寻找替代的模块来完成相同的功能。


根据您的选择，选择其中一种方法来解决 `ModuleNotFoundError` 错误。

### User

```python
from random import randrange
from freegames import vector, square
import turtle

food = vector(0, 0)
snake = [vector(10, 0)]
position = vector(0, -10)

def change(x, y):
    position.x = x
    position.y = y

def is_inside(head):
    return -200 < head.x < 190 and -200 < head.y < 190

def generate_food():
    while True:
        food.x = randrange(-15, 15) * 10
        food.y = randrange(-15, 15) * 10
        if food not in snake:
            break

def move():
    head = snake[-1].copy()
    head.move(position)
    
    if not is_inside(head) or head in snake:
        turtle.update()
        turtle.color('red')
        turtle.goto(0, 0)
        turtle.write("Game Over!", align="center", font=("Arial", 24, "normal"))
        return
    
    if head == food:
        print('Snake:', len(snake))
        generate_food()
    else:
        snake.pop(0)
    
    for body in snake:
        square(body.x, body.y, 9, 'black')
    
    square(food.x, food.y, 9, 'green')
    turtle.update()
    turtle.ontimer(move, 100)

def main():
    turtle.setup(420, 420, 370, 0)
    turtle.hideturtle()
    turtle.tracer(False)
    move()
    turtle.listen()
    turtle.onkey(lambda: change(10, 0), 'Right')
    turtle.onkey(lambda: change(-10, 0), 'Left')
    turtle.onkey(lambda: change(0, 10), 'Up')
    turtle.onkey(lambda: change(0, -10), 'Down')
    turtle.done()

if __name__ == '__main__':
    main()
```

以上贪食蛇代码运行时，只有食物，没有蛇，请修复

### ChatGPT

在您提供的代码中，蛇的移动逻辑似乎存在一些问题，导致蛇没有正确显示在游戏窗口中。主要的问题可能在于蛇的移动和绘制逻辑。让我们来仔细检查并修复这些问题。

我将重点关注蛇的移动和绘制部分的逻辑。以下是更新后的代码：

```python
from random import randrange
from freegames import vector, square
import turtle

food = vector(0, 0)
snake = [vector(10, 0)]
position = vector(0, -10)

def change(x, y):
    position.x = x
    position.y = y

def is_inside(head):
    return -200 < head.x < 190 and -200 < head.y < 190

def generate_food():
    while True:
        food.x = randrange(-15, 15) * 10
        food.y = randrange(-15, 15) * 10
        if food not in snake:
            break

def move():
    head = snake[-1].copy()
    head.move(position)
    
    if not is_inside(head) or head in snake:
        turtle.update()
        turtle.color('red')
        turtle.goto(0, 0)
        turtle.write("Game Over!", align="center", font=("Arial", 24, "normal"))
        return
    
    snake.append(head)  # 将新的蛇头添加到蛇的列表中
    
    if head == food:
        print('Snake:', len(snake))
        generate_food()
    else:
        snake.pop(0)  # 移除蛇的尾部，以实现蛇的移动
    
    turtle.clear()  # 清除之前的绘制
    
    for body in snake:
        square(body.x, body.y, 9, 'black')
    
    square(food.x, food.y, 9, 'green')
    turtle.update()
    turtle.ontimer(move, 100)

def main():
    turtle.setup(420, 420, 370, 0)
    turtle.hideturtle()
    turtle.tracer(False)
    move()
    turtle.listen()
    turtle.onkey(lambda: change(10, 0), 'Right')
    turtle.onkey(lambda: change(-10, 0), 'Left')
    turtle.onkey(lambda: change(0, 10), 'Up')
    turtle.onkey(lambda: change(0, -10), 'Down')
    turtle.done()

if __name__ == '__main__':
    main()

```

在这个修复后的版本中，我确保了蛇的移动逻辑正确，即将新的蛇头添加到蛇的列表中，并在每次移动时移除蛇的尾部，以实现蛇的移动。同时，我也更新了绘制逻辑，确保在每次移动后清除之前的绘制，以避免出现蛇重叠的情况。希望这次修复能够解决您遇到的问题。

## 赞助请求V3

**建站因为热爱，生活需要Money，请屏幕前的大佬动动您发财的小手，点击一次以示鼓励，祝您生活愉快！**


<div class="article-ads"></div>

> PS：就目前的访问量，即便每个访客都点一次广告，收入也不足以支付运营成本。`如果看不到广告，可能是网络原因或被拦截了，那就算了吧。再次祝您生活愉快~~`

Python实现简单的贪食蛇小程序(全靠ChatGPT)

## 简介

对于不了解 `Python` 的同学们，看到 `pkl` 文件往往不知道这是什么东西，老狗自认也不知道，所以去请教了一下GPT。yixia

下面是交流记录。



## pkl是什么文件？

- GPT回答如下：

`.pkl` 文件通常是 `Python` 中用于序列化（将数据转换为字节流以便于存储或传输）对象的一种常见格式。PKL 是 `Pickle` 的缩写，`Pickle` 是 `Python` 标准库中的模块，用于序列化和反序列化 `Python` 对象。

当您将 `Python` 对象保存到 `.pkl` 文件中时，您实际上将对象转换为字节流并将其写入文件。这使得您可以在需要时重新加载该对象，而无需重新创建它。这在许多情况下都很有用，例如在机器学习中保存训练好的模型、保存程序状态等等。

要使用 `.pkl` 文件，您需要在 `Python` 中使用 `pickle` 模块的 `load` 和 `dump` 函数来加载和保存对象。以下是一个简单的示例：

```python
import pickle

# 将对象保存到 .pkl 文件
data = {'example': [1, 2, 3, 4, 5]}
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f)

# 从 .pkl 文件加载对象
with open('data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)

print(loaded_data)  # 输出 {'example': [1, 2, 3, 4, 5]}
```
*注意：由于 `.pkl` 文件包含 `Python` 对象的二进制表示形式，因此请确保仅从受信任的来源加载 .pkl 文件，以防止执行恶意代码。*

## 如何使用pkl文件中的对象？

要使用 `.pkl` 文件中的对象，您需要在 `Python` 中使用 `pickle` 模块的 `load` 函数将其加载回内存中。然后，您就可以像使用任何其他 `Python` 对象一样使用它们。

以下是一个简单的示例，演示如何加载 `.pkl` 文件中的对象并使用它：

```python
Copy code
import pickle

# 从 .pkl 文件加载对象
with open('data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)

# 使用加载的对象
print(loaded_data)  # 输出 {'example': [1, 2, 3, 4, 5]}

# 对加载的对象进行操作
loaded_data['example'].append(6)
print(loaded_data)  # 输出 {'example': [1, 2, 3, 4, 5, 6]}
```
在这个示例中，我们首先使用 `pickle.load` 函数从名为 `'data.pkl'` 的 `.pkl` 文件中加载了一个对象。然后，我们将加载的对象打印出来，并对其进行了简单的操作，向其列表中添加了一个元素。最后，我们再次打印对象，以显示操作后的结果。

**请确保在使用 `.pkl` 文件中的对象时，您可以理解它们的结构和类型，以便正确地使用它们。**

## 总结

1. `PKL` 是什么：`PKL` 是一种文件格式的扩展名，通常用于存储 `Python` 对象的序列化版本。它允许将 `Python` 对象转换为字节流以便于存储和传输。
2. 如何使用 `PKL`：
    - 使用 `Python` 标准库中的 `Pickle` 模块来序列化和反序列化对象。
    - 使用 `pickle.dump()` 函数将对象保存到 `.pkl` 文件中。
    - 使用 `pickle.load()` 函数从 `.pkl` 文件中加载对象回到内存中。
3. 使用时的注意事项：
    - 来源可信度：只从可信任的来源加载 .pkl 文件，以防止执行恶意代码。
    - `Python` 版本兼容性：在加载 `.pkl` 文件时，确保使用相同或兼容的 `Python` 版本。`pickle` 格式可能不兼容不同版本之间的一些更改。
    - 对象结构和类型：了解加载的对象的结构和类型是很重要的，以确保正确地使用它们。
    - 数据版本控制：当对象结构发生更改时，`.pkl` 文件可能会变得不兼容。在生产环境中，建议使用更稳健的数据版本控制策略，如使用数据库或者序列化库中的更稳健格式。

总之，`PKL` 是 `Python` 中用于序列化对象的文件格式，是 `Pickle` 模块的一种常见使用方式的结果。`PKL` 文件提供了一种方便的方式来序列化和存储 `Python` 对象，但在使用时需要注意来源可信性、`Python` 版本兼容性以及对象结构和类型的了解。

## 赞助请求V3

**建站因为热爱，生活需要Money，请屏幕前的大佬动动您发财的小手，点击一次以示鼓励，祝您生活愉快！**


<div class="article-ads"></div>

> PS：就目前的访问量，即便每个访客都点一次广告，收入也不足以支付运营成本。`如果看不到广告，可能是网络原因或被拦截了，那就算了吧。再次祝您生活愉快~~`

什么是PKL（pkl）文件？

## 简介

本文用于记录一些不是强制要求的开发规范，这些开发规范一般用于规范代码结构、名称等，使代码不再杂乱无章。

不定期更新……



## 通用

### 变量

1. **命名**：变量名建议使用驼峰式命名，如：`userName`。
2. **控制**：应该掌控变量的全部变化情况，避免出现预料之外的数值导致程序出现BUG。这不是说要掌控其值的全部确定值，而是按照规律分类，掌控其所有可能性，使其无论出现什么类型的数据都可以进行相应的操作。`PS：抛出异常也算是一种操作`。
3. **释放**：变量一般有固定的作用域，如果是需要手动控制内存释放的编程语言，要在变量超出作用域时or不再需要是，手动释放变量占用的内存；如果是具有垃圾回收机制的JVM类语言，也要了解其回收机制，确保无用的变量能被正确回收。
4. **初始化**（网友补充）：有些场景，需要注意变量值的初始化。在面向对象编程中，自定义对象变量时要格外注意，避免出现 NULL 异常。

## 前端
### BEM

该规范一般用于前端开发中，来规范元素 `class` 的命名。*BEM* 开发规范的核心思想包括以下几点：

1. 块（`Block`）：块是指页面上的独立的、可重用的组件，比如按钮 `v-button` 、导航栏 `v-tabs` 等。其中开头的 `v` 一般使框架的简称，如 `ElementUI` 的简称是 `el`。
2. 元素（`Element`）：元素是块的组成部分，它们只能在块的上下文中存在，不能单独使用。元素的命名是由块名加上双下划线再加上元素名构成的，比如 `.block__element`。
3. 修饰符（`Modifier`）：修饰符是用于修改块或元素外观、状态或行为的标记。修饰符的命名是由块或元素名加上双连字符再加上修饰符名构成的，比如 `.block--modifier` 或 `.block__element--modifier`。

一些开发规范记录

## 简介

GithubApi 官方提供一了一些SDK，node仓库的好用一些，Java的也有官方推荐的，但是用的不是很多，所以还是决定自己写以下。

本文记录几个使用 `RestTemplate` 调用 `GithubApi` 的实例。

- 环境：`Java17` + `Springboot3.2+`



## 输出List：分页请求

```java

    /**
     * 仓库发布信息列表查询URL
     */
    private static final String RELEASE_LIST_URL = "https://api.github.com/repos/{user}/{repo}/releases";
    
    /**
     * 获取仓库Releases列表
     *
     * @param user user
     * @param repo repo
     * @param pageParam 分页参数
     * @return List<GithubRelease>
     */
    public static List<GithubRelease> getReleases(String user, String repo, Map<String, Object> pageParam) {
        String url = RELEASE_LIST_URL
                .replace("{user}", user)
                .replace("{repo}", repo);
        RestTemplate restTemplate = new RestTemplate();
        // 请求信息封装
        RequestEntity<Void> requestEntity = getRequestEntity(url, null, pageParam);
        // 发送请求并获得响应
        ResponseEntity<List<GithubRelease>> responseEntity = restTemplate.exchange(requestEntity, new ParameterizedTypeReference<List<GithubRelease>>() {
        });
        return responseEntity.getBody();
    }
    
    
    private static RequestEntity<Void> getRequestEntity(String url, Map<String, String> headerMap, Map<String, Object> param) {
        HttpHeaders headers = new HttpHeaders();
        if (AitLogProperties.getGithubToken() != null) {
            headers.setBearerAuth(AitLogProperties.getGithubToken());
        }
        if (headerMap != null) {
            for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                headers.add(entry.getKey(), entry.getValue());
            }
        }

        return new RequestEntity<>(headers, HttpMethod.GET, URI.create(url + mapToUrlParam(param)));
    }
```

## 输出Map/Object

```java
    /**
     * 仓库基本信息查询URL
     */
    private static final String REPO_INFO_URL = "https://api.github.com/repos/{user}/{repo}";

    /**
     * 获取仓库信息
     *
     * @param user GithubUser
     * @param repo GithubRepo
     * @return GithubRepository
     */
    public static GithubRepository getRepoInfo(String user, String repo) {
        String url = REPO_INFO_URL
                .replace("{user}", user)
                .replace("{repo}", repo);
        return get(url, null, GithubRepository.class);
    }

    /**
     * Get 请求封装
     *
     * @param  url   请求地址
     * @param  param 请求参数
     * @param  clazz 响应数据实体类型
     * @return 响应数据实体
     */
    public static <T> T get(String url, Map<String, Object> param, Class<T> clazz) {
        RestTemplate restTemplate = new RestTemplate();
        RequestEntity<Void> requestEntity = getRequestEntity(url, null, param);
        ResponseEntity<T> responseEntity = restTemplate.exchange(
                requestEntity,
                clazz
        );
        return responseEntity.getBody();
    }
```

## 输出String

```java
    /**
     * Readme URL
     */
    private static final String README_URL = "https://api.github.com/repos/{user}/{repo}/readme";

    /**
     * 获取一个仓库的Readme内容，以Html格式返回
     *
     * @param user the username of the repository owner
     * @param repo the name of the repository
     * @return the HTML content of the README file
     */
    public static String getReadmeHtml(String user, String repo) {
        String url = README_URL
                .replace("{user}", user)
                .replace("{repo}", repo);

        RestTemplate restTemplate = new RestTemplate();

        HttpHeaders headers = new HttpHeaders();
        // 设置请求头
        if (AitLogProperties.getGithubToken() != null) {
            headers.setBearerAuth(AitLogProperties.getGithubToken());
        }
        headers.setAccept(MediaType.parseMediaTypes("application/vnd.github.html+json"));

        RequestEntity<Void> requestEntity = new RequestEntity<>(headers, HttpMethod.GET, URI.create(url));
        // 发送请求并获得响应
        ResponseEntity<String> responseEntity = restTemplate.exchange(
                requestEntity,
                String.class
        );
        return responseEntity.getBody();
    }

```