```

feat(array): 添加数组遍历和排序功能及切片基础内容

添加了数组的range遍历方式详细说明，包括通用遍历法和专用遍历法的对比，
实现了冒泡排序函数MySort和指针版本MySortV2，完善了数组作为函数参数的
示例代码。同时新增了切片基础知识，包括slice结构定义、容量和长度概念，
以及切片与数组的区别说明。

chore: 初始化DevOps项目目录结构

创建了DevOps平台的整体目录框架，包含server、agent、web等子模块的
基础README文件，为后续DevOps功能开发奠定结构基础。
```

day02/array/README.md

@@ -89,15 +89,63 @@ func main() {
 
 1. 循环遍历(for)
 ```go
-
+	/*
+	  数组遍历
+	*/
+	// 1. 通用遍历法(不局限于数组, 切片, map, 字符串)
+	// 对象的编号，通常叫索引, index (0, ...)
+	// (0, 1, 2, 3)
+	// 1. for : 定义变量(开始元素的索引，0), 条件(循环结束条件， 不满足条件，结束循环), 变化(索引加1， 找下一个元素)
+	// len 函数: 求数组的长度
+	// 127 0 0 1
+	// for i := 0; i < len(ip); i++ {
+	// 	fmt.Println(ip[i])
+	// }
+	// range 专用遍历法, 语法糖，更简洁, 自动处理索引的变化
+	// range len(ip)  range 4
+	// range [0, 1, 2, 3]
+	// for i := range len(ip) {
+	// 	fmt.Println(ip[i])
+	// }
+	// 专门针对数组, 切片, map, 字符串的遍历
+	// 最常用的写法
+    // range array
+    // (index, value)
+	for i, v := range ip {
+		fmt.Println(i, v)
+	}
 ```
 
+## 数组作为函数参数(比较少)
 
-## 数组作为函数参数
+[3, 2, 5, 7] 进行排序, 
 
+```go
+func MySort(arr [5]int) [5]int {
+	// 冒泡排序
+	for i := 0; i < len(arr)-1; i++ {
+		for j := 0; j < len(arr)-1-i; j++ {
+			if arr[j] > arr[j+1] {
+				// 值交换: a, b = b, a
+				arr[j], arr[j+1] = arr[j+1], arr[j]
+			}
+		}
+	}
+	return arr
+}
 
-## 多维数组
-
+func MySortV2(arr *[5]int) {
+	// 冒泡排序
+	for i := 0; i < len(arr)-1; i++ {
+		for j := 0; j < len(arr)-1-i; j++ {
+			if arr[j] > arr[j+1] {
+				// 值交换: a, b = b, a
+				arr[j], arr[j+1] = arr[j+1], arr[j]
+			}
+		}
+	}
+}
+```
 
 ## 作业
 
@@ -112,10 +160,7 @@ func main() {
 3. **数组拷贝**  
    创建一个数组，拷贝到另一个数组，修改原数组的第一个元素，观察拷贝后的数组是否改变。
 
-4. **多维数组**  
-   定义一个3x3的整数二维数组，初始化为九宫格形式（1到9），并打印出来。
-
-5. **数组作为函数参数**  
+4. **数组作为函数参数**  
    编写一个函数，接受一个整数数组作为参数，计算并返回数组中所有元素的和。
 
 请将代码写在 `main.go` 文件中，并运行测试。

day02/array/main.go

@@ -1,6 +1,8 @@
 package main
 
-import "fmt"
+import (
+	"fmt"
+)
 
 func main() {
 	/*
@@ -46,8 +48,49 @@ func main() {
 	// 	fmt.Println(ip[i])
 	// }
 	// range 专用遍历法, 语法糖，更简洁, 自动处理索引的变化
-	for i := range len(ip) {
-		fmt.Println(ip[i])
+	// range len(ip)  range 4
+	// range [0, 1, 2, 3]
+	// for i := range len(ip) {
+	// 	fmt.Println(ip[i])
+	// }
+	// 专门针对数组, 切片, map, 字符串的遍历
+	// 最常用的写法
+	for i, v := range ip {
+		fmt.Println(i, v)
 	}
 
+	// 排序
+	arr1 := [5]int{3, 5, 1, 4, 2}
+	sorted_arr1 := MySort(arr1)
+	fmt.Println("source arr1:", arr1)
+	fmt.Println("sorted_arr1:", sorted_arr1)
+
+	// 数组指针
+	MySortV2(&arr1)
+	fmt.Println("source arr1:", arr1)
+}
+
+func MySort(arr [5]int) [5]int {
+	// 冒泡排序
+	for i := 0; i < len(arr)-1; i++ {
+		for j := 0; j < len(arr)-1-i; j++ {
+			if arr[j] > arr[j+1] {
+				// 值交换: a, b = b, a
+				arr[j], arr[j+1] = arr[j+1], arr[j]
+			}
+		}
+	}
+	return arr
+}
+
+func MySortV2(arr *[5]int) {
+	// 冒泡排序
+	for i := 0; i < len(arr)-1; i++ {
+		for j := 0; j < len(arr)-1-i; j++ {
+			if arr[j] > arr[j+1] {
+				// 值交换: a, b = b, a
+				arr[j], arr[j+1] = arr[j+1], arr[j]
+			}
+		}
+	}
 }

day02/slice/README.md

@@ -1,17 +1,22 @@
-# 切片
+# 切片(slice)
 
 ![alt text](image.png)
 
 Go中的slice依赖于数组，它的底层就是数组，所以数组具有的优点, slice都有。 且slice支持可以通过append向slice中追加元素，长度不够时会动态扩展，通过再次slice切片，可以得到得到更小的slice结构，可以迭代、遍历等
 
+基于数组的 复合数据结构
+
+```go
 // runtime/slice.go
 type slice struct {
     array unsafe.Pointer // 数组指针
-    len   int // 长度 
     cap   int // 容量
-}
-每一个slice结构都由3部分组成：
+    len   int // 长度 
 
+}
+```
+
+每一个slice结构都由3部分组成：
 + 容量(capacity): 即底层数组的长度，表示这个slice目前最多能扩展到这么长
 + 长度(length)：表示slice当前的长度，即当前容纳的元素个数
 + 数组指针(array): 指向底层数组的指针
@@ -24,6 +29,25 @@ fmt.Println(a, len(s), cap(s)) // [0 0 0] 3 5
 
 ![alt text](image-1.png)
 
+## 切片与数组
+
+为了灵活(不需要制定长度, 自动扩容)
+
+```go
+func main() {
+	// 1. 声明切片, 切片不是一个值，是一个boxed结构体, array unsafe.Pointer // 数组指针
+	// 底层数组的长度: 容量10, 当前有几个元素3
+	slice1 := make([]int, 3, 5)
+	fmt.Println(slice1, len(slice1), cap(slice1))
+	// 底层数组的长度: 容量10, 当前有几个元素3
+	slice1 = append(slice1, 4, 5)
+	fmt.Println(slice1, len(slice1), cap(slice1))
+	// 这里的容器, 不是硬性限制，是超过容量后，底层数组是自动扩容的(重要)
+	// 扩容: 一般是原来的2倍, 新申请一块更大的数组， 把老数据copy过去
+	slice1 = append(slice1, 6)
+	fmt.Println(slice1, len(slice1), cap(slice1))
+}
+```
 
 ## 创建和初始化
 

day02/slice/main.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func main() {
+	// 1. 声明切片, 切片不是一个值，是一个boxed结构体, array unsafe.Pointer // 数组指针
+	// 底层数组的长度: 容量10, 当前有几个元素3
+	slice1 := make([]int, 3, 5)
+	fmt.Println(slice1, len(slice1), cap(slice1))
+	// 底层数组的长度: 容量10, 当前有几个元素3
+	slice1 = append(slice1, 4, 5)
+	fmt.Println(slice1, len(slice1), cap(slice1))
+	// 这里的容器, 不是硬性限制，是超过容量后，底层数组是自动扩容的(重要)
+	// 扩容: 一般是原来的2倍, 新申请一块更大的数组， 把老数据copy过去
+	slice1 = append(slice1, 6)
+	fmt.Println(slice1, len(slice1), cap(slice1))
+}

devops/README.md

@@ -0,0 +1,2 @@
+# DevOps平台
+

devops/agent/README.md

@@ -0,0 +1 @@
+# DevOps Agent

devops/agent/script/README.md

@@ -0,0 +1,2 @@
+# 脚本执行器
+

devops/server/README.md

@@ -0,0 +1,2 @@
+# DevOps Server
+

devops/web/README.md

@@ -0,0 +1,2 @@
+# Web UI
+