圐圙村

Go语言入门

Tue, 09 Jun 2026 00:00:00 GMT

Go语言入门#

1.1 helloworld示例#

一个基本的helloworld示例程序如下.

1
// 这是该文件所在的包名
2
package main
3

4
// 从引入fmt
5
import "fmt"
6
// 函数以func声明,后接函数名
7
func main() {
8
    // 类似于java中的System.out.println();,同样的带有输出换行功能.
9
    // 在语句后,不再需要添加分号.
10
    fmt.Println("Hello, World!")
11
}

关于这个包名,真是个大坑

此外,go.mod必须要放在根目录中
main.go,一般放在根目录中,如果是多入口的程序,会放在/cmd/app下
需要注意,在同一级目录下,只能有一个package声明.
强烈建议包名与目录名相同! 原因是

若在子目录domain中,有一个包名为package pkg2的文件,那么
在引入时,需要写 import “GoLearn/domain”,但是在使用时,需要pkg2.xxx,这很容易导致混乱,因为包名与目录名不一致,根本不知道domain里面会有一个pkg2.
在自己写的程序中,引用自己写的模块,需要使用 <模块名>/包名的方式引入,具体使用方法见 1.9 函数作用域

1.2 数据类型#

在go语言中,int8,int16等,可以省略为int,此时,go会根据计算机架构,自动选择整型.

1
func main() {
2
  // 布尔型
3
  var boolvar bool = true
4

5
  // 大类-数字类型
6
  // 整数类型
7
  // 默认位数跟随平台.
8
  // 支持uint无符号数
9
  // 支持int8,int16,int32,int64等指定长度的类型,依次类推,uint同样支持.
10
  var intvar int = 2147483649
11
  // 浮点类型,默认为float64
12
  var float32var float32 = 100.0
13
  var float64var float64 = 100.0
14
  fmt.Println(boolvar)
15
  fmt.Println(intvar)
16
  fmt.Println(float32var)
17
  fmt.Println(float64var)
18
  // 其它数字类型
19
  // byte: 类似于uint8
20
  // rune: 类似于int32
21
  // uint: 32或64位无符号整数
22
  // int: 32或64位整数
23
  // uintptr: 无符号整型,用于存放一个指针
24

25
  // 字符串
26
  var stringvar string = "good morning,Yuili"
27
  fmt.Println(stringvar)
28

29
  // 虚数类型,需要使用函数complex(<实部>,<虚部>)创建,支持complex64,complex128.
30
  var complex64 complex64 = complex(1, 2)
31
  fmt.Println(complex64)
32
}

展开收起

其它派生类型

指针类型 *#

使用 & 取出地址

使用 *<类型> 声明一个指针类型的变量

1
func main() {
2
  var intvar int = 42
3
  var intptr *int = &intvar
4
  var float64var float64 = 24.0
5
  var float64ptr *float64 = &float64var
6

7
  fmt.Printf("%d@%p\n", intvar, intptr) // 输出内容为 值@地址
8
  fmt.Printf("%.2f@%p\n", float64var, float64ptr)
9

10
  *float64ptr = 96.1      // 通过指针修改原变量
11
  fmt.Println(float64var) // 输出: 96.1
12
}

数组类型 []#

1
func main() {
2
  // 声明一个包含指定元素数量的数组
3
  var arr [5]int = [5]int{1, 2, 3, 4, 5}
4

5
  // 简写形式
6
  arr2 := [3]string{"Go", "Python", "Java"}
7

8
  // 让编译器推断长度,将[<长度>]换成[...]就可以
9
  arr3 := [...]int{10, 20, 30}
10

11
  fmt.Println(arr[0])   // 输出: 1
12
  fmt.Println(len(arr)) // 输出: 5
13
  fmt.Println(arr2)     // 输出: [Go Python Java]
14
  fmt.Println(arr3)     // 输出: [10 20 30]
15
}

展开收起

结构体 type struct#

1
// 声明结构体
2
// 这个与java中的class不同,它不能存储方法.
3
type Person struct {
4
  Name  string
5
  Age   int
6
  Email string
7
}
8

9
func main() {
10
  // 为结构体字段赋值
11
  // 方式1: 按字段顺序
12
  p1 := Person{"Alice", 30, "alice@example.com"}
13

14
  // 方式2: 指定字段名（推荐,也就是命名方式）
15
  p2 := Person{
16
    Name: "Bob",
17
    Age:  25,
18
  }
19

20
  // 方式3: 先声明再赋值,有点类似于class
21
  var p3 Person
22
  p3.Name = "Charlie"
23

24
  fmt.Println(p1.Name) // 输出: Alice
25
  fmt.Println(p2)      // 输出: {Bob 25 }
26
}

展开收起

通道 channel#

需要注意的是,若缓冲区满了或者创建的是无缓冲区的通道,那么在接收方或发送方无法接收或发送时,程序将会阻塞.

1
func main() {
2
  // channel: 通道
3
  // 用于在协程之间通信使用
4
  // 创建缓冲为 2 的 int 类型 channel
5
  bufferedChannel := make(chan int, 2)
6

7
  // 发送数据到 channel
8
  bufferedChannel <- 100
9
  bufferedChannel <- 200
10

11
  // 从 channel 接收数据
12
  // 先进先出,类似一个队列
13
  x := <-bufferedChannel
14
  y := <-bufferedChannel
15

16
  fmt.Println(x, y) // 输出: 100 200
17

18
  // 无缓冲 channel
19
  unbufferedChannel := make(chan string)
20
  // 异步发送数据
21
  go func() {
22
    unbufferedChannel <- "Hello from goroutine"
23
  }()
24
  msg := <-unbufferedChannel
25
  fmt.Println(msg)
26
}

展开收起

函数 func#

1
// 示例1: 定义一个函数类型的接口
2
type AddFunc func(int, int) int
3

4
func main() {
5
    // 函数作为变量
6
    // 声明函数,并赋值给变量保存起来
7
    var add AddFunc = func(a, b int) int {
8
       return a + b
9
    }
10
    // 调用时,使用变量名作为函数名使用.
11
    result := add(3, 5)
12
    fmt.Println(result) // 输出: 8
13

14
    // 示例2: 函数作为参数
15
    // 参数1: a
16
    // 参数2: b:int
17
    // 参数3: op:func(int, int) int,是一个函数类型
18
    operate := func(a, b int, op func(int, int) int) int {
19
       return op(a, b)
20
    }
21

22
    // 使用,这里先声明一个函数,作用是将a,b相乘,并返回结果.
23
    multiply := func(a, b int) int { return a * b }
24
    // 使用operate函数,传入值a,b,以及函数multiply
25
    fmt.Println(operate(4, 5, multiply)) // 输出: 20
26

27
    // 示例3: 函数作为返回值
28
    // 函数名: makeMultiplier
29
    // 接收参数: factor int
30
    // 函数返回值类型: func(int) int
31
    makeMultiplier := func(factor int) func(int) int {
32
       // 在这里,返回了一个函数,用于计算x*factor.
33
       return func(x int) int {
34
          return x * factor
35
       }
36
    }
37

38
    double := makeMultiplier(2)
39
    fmt.Println(double(7)) // 输出: 14
40
}

展开收起

切片类型 slice#

1
func main() {
2
  // 方式1: 从数组创建
3
  arr := [5]int{10, 20, 30, 40, 50}
4
  s1 := arr[1:4]  // 包含索引 1,2,3
5
  fmt.Println(s1) // 输出: [20 30 40]
6

7
  // 方式2: make 创建
8
  s2 := make([]int, 3, 5) // 初始长度3,最大容量5
9
  s2[0] = 1
10
  s2[1] = 2
11
  fmt.Println(s2) // 输出: [1 2 0]
12

13
  // 方式3: 字面量
14
  s3 := []string{"a", "b", "c"}
15

16
  // 追加元素
17
  s3 = append(s3, "d", "e")
18
  fmt.Println(s3) // 输出: [a b c d e]
19

20
  // 切片复制
21
  s4 := make([]int, len(s2))
22
  copy(s4, s2)
23
}

展开收起

接口类型#

1
// 定义接口
2
type Animal interface {
3
  Speak() string
4
  Move() string
5
}
6

7
// Dog 实现 Animal 接口
8
// Go语言的接口,是隐式实现的,不需要显式声明实现的接口
9
// 只需要同时实现接口内的所有函数,就可以将实现赋值到接口类型的对象上,见下面的ShowAnimal函数,传入值是一个animal接口类型对象.
10
type Dog struct {
11
  Name string
12
}
13

14
func (d Dog) Speak() string {
15
  return "汪汪!"
16
}
17

18
func (d Dog) Move() string {
19
  return "四条腿跑"
20
}
21

22
// Cat 实现 Animal 接口
23
type Cat struct {
24
  Name string
25
}
26

27
func (c Cat) Speak() string {
28
  return "喵喵~"
29
}
30

31
func (c Cat) Move() string {
32
  return "悄无声息地走"
33
}
34

35
// 多态函数
36
func ShowAnimal(a Animal) {
37
  fmt.Printf("%s, %s\n", a.Speak(), a.Move())
38
}
39

40
func main() {
41
  // 声明两个实体类
42
  dog := Dog{"旺财"}
43
  cat := Cat{"咪咪"}
44
  // 这里调用了多态函数,传入了两个实体类,由多态函数自动处理.
45
  ShowAnimal(dog) // 输出: 汪汪!, 四条腿跑
46
  ShowAnimal(cat) // 输出: 喵喵~, 悄无声息地走
47

48
  // 空接口: 可以存储任意类型,限一个,如基本类型,函数类型,切片类型,结构体等.
49
  // 在Go中,所有的方法都实现了空接口
50
  var anything interface{} = "hello"
51
  anything = 42
52
  anything = 3.14
53
  fmt.Println(anything)
54
}

展开收起

map类型#

这是一个非常重要的类型

基本使用#

1
func main() {
2
  // 方式1: make 创建
3
  scores := make(map[string]int)
4
  scores["Alice"] = 95
5
  scores["Bob"] = 87
6

7
  // 方式2: 字面量
8
  ages := map[string]int{
9
    "Tom":   20,
10
    "Jerry": 18,
11
  }
12

13
  // 访问
14
  fmt.Println(scores["Alice"]) // 输出: 95
15

16
  // 判断键是否存在
17
  if score, ok := scores["Charlie"]; ok {
18
    fmt.Println("存在:", score)
19
  } else {
20
    fmt.Println("Charlie 不存在")
21
  }
22

23
  // 删除
24
  delete(ages, "Tom")
25

26
  // 遍历
27
  for name, score := range scores {
28
    fmt.Printf("%s: %d\n", name, score)
29
  }
30
}

展开收起

新增Map元素的几种方式#

没有单独的新增函数,若要新增函数,需要在循环中实现,利用map中键不存在,会自动新增的特性实现添加.

1
func main() {
2
  // 创建一个空的map
3
  scores := make(map[string]int)
4

5
  // 新增元素
6

7
  // 方式1: 直接赋值新增
8
  // 当键不存在时,会自动新增元素
9
  scores["Alice"] = 95
10
  scores["Bob"] = 87
11
  fmt.Println("初始map:", scores) // map[Alice:95 Bob:87]
12

13
  // 方式2: 在循环中动态新增
14
  names := []string{"Charlie", "David", "Eve"}
15
  // i: 值
16
  // name: 键
17
  // 循环遍历namesmap,利用键不存在时,自动新增元素的特性,将names中的元素添加到scores中
18
  // 若已存在,那么值将会被覆盖
19

20
  for i, name := range names {
21
    scores[name] = 90 + i*5 // Charlie:90, David:95, Eve:100
22
  }
23
  fmt.Println("新增后:", scores) // map[Alice:95 Bob:87 Charlie:90 David:95 Eve:100]
24

25
  // 方式3: 从另一个map复制新增
26
  // 原理与上一个差不多
27
  extraScores := map[string]int{
28
    "Frank": 88,
29
    "Grace": 92,
30
  }
31
  for k, v := range extraScores {
32
    scores[k] = v // 如果key不存在就是新增
33
  }
34
  fmt.Println("合并后:", scores) // map[Alice:95 Bob:87 ... Frank:88 Grace:92]
35

36
  // 方式4: 条件新增（只有key不存在时才添加）
37
  if _, exists := scores["Henry"]; !exists {
38
    scores["Henry"] = 85
39
    fmt.Println("新增Henry:", scores["Henry"]) // 85
40
  }
41
}

展开收起

1.3 变量声明#

变量声明方式

1
// 声明方式一: 若活力类型,编译器会自动推断类型
2
var <变量名> [类型] = <值>
3
// 声明方式二: 此时编译器会自动推断类型
4
<变量名> := <值>
5
// 声明方式三: 一次性声明多个变量
6
var <变量名列表> [类型] = <值列表>

1.4 值类型和引用类型#

int,float,string,bool类型为值引用类型,即在使用=时,会在内存中复制一份

其它复杂类型为引用类型.

1.5 常量声明#

基础声明#

1
package main
2

3
import "fmt"
4

5
func main() {
6
  const LENGTH int = 10
7
  const WIDTH int = 5
8
  var area int
9
  const a, b, c = 1, false, "str" // 多重赋值
10

11
  area = LENGTH * WIDTH
12
  fmt.Printf("面积为 : %d", area) // 面积为 : 50
13
  fmt.Println()
14
  fmt.Println(a, b, c) // 1 false str
15
}

展开收起

使用常量组#

1
const (
2
  a = 1
3
  b
4
  c
5
  d
6
)
7

8
func main() {
9
  fmt.Println(a)
10
  // b、c、d没有初始化，使用上一行(即a)的值
11
  fmt.Println(b) // 输出1
12
  fmt.Println(c) // 输出1
13
  fmt.Println(d) // 输出1
14
}

一个特殊的iota 常量计数器#

iota是一个特殊常量,用于生成递增的序列

基础使用#

1
// iota 从 0 开始,每行加 1
2
const (
3
  a = iota   // 0
4
  b          // 1,将会使用上一行的iota递增序列.
5
  c          // 2
6
)
7

8
func main() {
9
  fmt.Printf("a=%d, b=%d, c=%d\n", a, b, c) // a=0, b=1, c=2
10
}

进阶使用#

iota在常量声明时,若在中间有显式赋值的变量时,将会停止使用iota,显式赋值的变量之后声明的新变量,将会使用上一行的值,也就是使用显式赋值的变量的值,等到下次使用显式赋值或使用iota时,变量才会改变值.

实际上,这是go语言的机制,参见常量组的声明

1
package main
2

3
import "fmt"
4

5
func main() {
6
  const (
7
    a = iota // 0
8
    b        // 1
9
    c        // 2
10
    d = "ha" // 独立值，iota += 1,实际值为给定的值而不是iota
11
    e        // "ha"，iota += 1,实际值为上一行的值而不是iota
12
    f = 100  // 独立值，iota += 1,同样的,实际值为上一行的值而不是iota
13
    g        // 100，iota += 1,同上.
14
    h = iota // 7，恢复使用 iota 值,iota经过中间几个变量后,值为7
15
    i        // 8
16
  )
17
  fmt.Printf("a=%d, b=%d, c=%d, d=%s, e=%s, f=%d, g=%d, h=%d, i=%d\n", a, b, c, d, e, f, g, h, i)
18
}

展开收起

1.6 运算符#

同其它语言

1.7 程序结构#

if分支结构#

1
if <condition> {
2
    <if block>
3
} [else {
4
    <else block>
5
}]

switch分支结构#

1
switch var1 {
2
    case val1:
3
        ...
4
    case val2:
5
        ...
6
    default:
7
        ...
8
}

select 分支结构#

这个结构只能用于通道操作,每个case上的表达式,必须是一个通道操作,要么是发送,要么是接收

不带default子句的select,一般用于同时监听多个通道,只要任意一个通道有数据,那么就可以执行下去.

1
select {
2
  case <- channel1:
3
    // 执行的代码
4
  case value := <- channel2:
5
    // 执行的代码
6
  case channel3 <- value:
7
    // 执行的代码
8

9
    // 你可以定义任意数量的 case
10

11
  default:
12
    // 所有通道都没有准备好，执行的代码
13
}

每个case都是一个通道
所有的channel在执行到select时,都将会被求值,此时,在本次执行select时,值已经被确定,不会再修改.
如果有多个case可以运行,那么select将会随机选出一个执行,其它的不会执行
在找不到可执行的case时,如果有default,那么将执行default,如果没有default,那么将会阻塞,此时将不再对channel或值进行求值,此时即使将通道替换为nil,也不会改变select正在监听的通道内的对象

for 循环结构#

go语言中只有for循环,但有三种形式可选,可以用其中一种代替while循环.

1
// 方式一: 类似于其它语言的for
2
for init; condition; post {}
3

4
// 方式二: 类似于其它语言的while
5
for condition {}
6

7
// 方式三: 类似于其它语言的for(;;)
8
for {}

示例

1
func main() {
2
  numbers := [6]int{1, 2, 3, 5}
3
  // 这里的key, value 类似于js的解构赋值,可以同时取出键和值.
4
  for key, value := range numbers {
5
    fmt.Printf("第 %d 位 x 的值 = %d\n", key, value)
6
  }
7
}

1
// 控制循环语句
2
break: 中断本层循环,跳出本层循环
3
continue: 中断本次循环,重新开始本层循环.

1
// 无条件跳转语句,非常不建议使用该语句
2
goto <label>
3
...
4
label: <标签名>

1.8 函数#

结构

1
func <函数名>( [参数列表] ) [返回值类型] {
2
   函数体
3
}

函数是允许返回多个值的,如

1
func swap(x, y string) (string, string) {
2
   return y, x
3
}

1.9 函数作用域#

在函数内部声明的变量,包括形式参数与返回值,都是局部变量
在函数外声明的变量,可以在本包内使用
若使用导出函数,那么可以在外部包使用

如何确定是否导出?

导出: 首字母大写,如 var ExportedVar int = 100
不导出: 首字母小写,如 var unexportedVar int = 100;

使用外部包的变量,需要注意的就是文章刚开头说的,关于包,项目文件的组织安排的问题.

GoLearn/main.go展开收起

1
package main
2

3
import (
4
  "GoLearn/domain" // 这里的导入,需要从项目的模块名开始写.
5
  "fmt"
6
)
7

8
func main() {
9
  // 可以访问导出的内容
10
  fmt.Println(domain.ExportedVar)    // 正常访问
11
  fmt.Println(domain.ExportedFunc()) // 正常访问
12

13
  obj := domain.ExportedStruct{
14
    Name: "张三", // 大写字段可访问
15
    // age:  25,      // 编译错误！age 未导出
16
  }
17

18
  // 以下全部编译错误
19
  // pack2.unexportedVar     // 未导出
20
  // pack2.unexportedFunc()  // 未导出
21

22
  fmt.Println(obj.Name)
23
  fmt.Println(obj.Address)
24
}

展开收起

GoLearn/domain/pack2.go展开收起

1
package domain
2

3
// 导出（大写开头）—— 外部包可用
4
var ExportedVar = "我是导出的变量"
5

6
func ExportedFunc() string { return "导出函数" }
7

8
type ExportedStruct struct {
9
  Name    string // 导出字段
10
  age     int    // 未导出字段（包外不可见）
11
  Address string // 导出字段
12
}
13

14
// 未导出（小写开头）—— 仅限包内
15
var unexportedVar = "私有变量"
16

17
func unexportedFunc() string { return "私有函数" }

展开收起

Go 拓展使用#

2.1 指针#

啊,指针,危险又美丽的东西

基本声明与使用#

1
func main() {
2
  var a int
3
  var ptr *int
4
  var pptr **int // Go支持指向指针的指针,使用**就可以了
5

6
  a = 3000
7

8
  // 指针 ptr 地址
9
  ptr = &a
10

11
  // 指向指针 ptr 地址
12
  pptr = &ptr
13

14
  // 获取 pptr 的值
15
  fmt.Printf("变量 a = %d\n", a)
16
  fmt.Printf("指针变量 *ptr = %d\n", *ptr)
17
  fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
18
}

展开收起

指针在数组中的应用#

1
const max = 3
2

3
func main() {
4
  number := [max]int{5, 6, 7}
5
  var ptrs [max]*int // 声明int类型的指针数组
6
  // 将number数组的值的地址赋给ptrs
7
    // &number: 指向了number数组,在这块内存区域中,使用for遍历
8
    // 注意,这里使用number也是可以的,number与&number的区别在于,number是将数组复制了一份,页&number是指向数组的一个指针,使用数组复制时,是有性能开销的,但适用于单线程环境或者多线程不修改数组的环境.
9
    // i: 键
10
    // x: 值
11
  for i, x := range &number {
12
        // 取出x的内存地址,赋给指针数组的对应元素
13
    ptrs[i] = &x
14
  }
15
    // 将
16
  for i, x := range ptrs {
17
    fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%d\n", i, *&*x, x)
18
  }
19
}

展开收起

2.2 结构体#

基本声明与使用

1
// 定义
2
type <结构体名> struct {
3
   <成员名1> <类型>
4
   <成员名2> <类型>
5
   ...
6
}
7

8
// 声明
9
var <变量名> <结构体类型名>
10

11
// 使用
12
<变量名>.<成员名>

结构体同样支持指针.

2.3 切片#

基本声明与使用

这篇文章是草稿

Sat, 06 Jun 2026 00:00:00 GMT

这篇文章是草稿#

这篇文章目前处于草稿状态，尚未发布。因此，它不会对普通读者可见。内容仍在进行中，可能需要进一步编辑和审查。

当文章准备发布时，您可以在 Frontmatter 中将 “draft” 字段更新为 “false”：

1
---
2
title: 这篇文章是草稿
3
published: 1970-01-01
4
pinned: true
5
description: 这是描述
6
tags: [Markdown, 草稿, 演示]
7
category: 这是分类
8
draft: false
9
image: ./images/firefly2.avif
10
---

Firefly 一款清新美观的 Astro 博客主题模板

Fri, 02 Jan 1970 00:00:00 GMT

🌟 项目概述#

Firefly 是一款基于 Astro 框架和 Fuwari 模板开发的清新美观且现代化个人博客主题模板，专为技术爱好者和内容创作者设计。该主题融合了现代 Web 技术栈，提供了丰富的功能模块和高度可定制的界面，让您能够轻松打造出专业且美观的个人博客网站。

🖥️在线预览： Firefly - Demo site

🏠我的博客： https://blog.cuteleaf.cn

📝Firefly使用文档： https://docs-firefly.cuteleaf.cn

⭐Firefly开源地址：https://github.com/CuteLeaf/Firefly

⭐Fuwari开源地址：https://github.com/saicaca/fuwari

CuteLeaf

Firefly

Waiting for api.github.com...

Waiting for api.github.com...

00K

Waiting...

Firefly

🚀 技术架构#

静态站点生成: 基于 Astro ，提供极快的加载速度和优秀的 SEO 优化
TypeScript 支持: 完整的类型安全，提升开发体验和代码质量
响应式设计: 使用 Tailwind CSS 构建，完美适配桌面端和移动端
组件化开发: 支持 Astro、Svelte 组件，灵活可扩展

📖 配置说明#

📚 详细配置文档: 查看 Firefly使用文档获取完整的配置指南

Gradle使用指南

Sat, 06 Jun 2026 00:00:00 GMT

解决idea中,Gradle中文乱码#

idea使用gradle编译的工程,输出中文乱码

在build.gradle中添加如下内容

1
tasks.withType(JavaExec){
2
    jvmArgs = ['-Xmx512m', '-Dfile.encoding=UTF-8', '-Dsun.stdout.encoding=UTF-8','-Dsun.stderr.encoding=UTF-8']
3
}

让idea中的Gradle使用指定gradle.zip#

因为Spring initializr的限制,没有相关的项目模板可以进行一次性配置永久保存,只能每次创建后再进行更改
另外,idea疑似有bug,不会结束正在下载的gradle进程,需要强行结束idea后重新打开才可以应用修改.

新建IDEA项目时,需要修改/gradle/wrapper/gradle-wrapper.properties为以下内容

Terminal window

1
distributionBase=GRADLE_USER_HOME
2
distributionPath=wrapper/dists
3

4
distributionUrl=file:///C:/Workspace/SDK/Gradle/gradle-9.4.1-all.zip
5
networkTimeout=10000
6
validateDistributionUrl=true
7
zipStoreBase=GRADLE_USER_HOME
8
zipStorePath=wrapper/dists

Linux学习笔记

Fri, 05 Jun 2026 00:00:00 GMT

折腾Linux留下的笔记。

Linux 常用命令#

一、7z 压缩与解压#

压缩文件/文件夹#

命令	说明
7z a <压缩文件名>.7z <目录/文件名>	基础压缩
7z a <压缩文件名>.7z <目录/文件名> -mx=9	最高压缩级别（速度较慢）
7z a -p123 <压缩文件名>.7z <目录/文件名>	压缩并设置密码（示例密码：123）
7z a -p123 -mhe=on <压缩文件名>.7z <目录/文件名>	加密文件名
7z a -v4096m <压缩文件名>.7z <目录/文件名>	分卷压缩（每卷 4096MB）

解压文件#

命令	说明
7z x <压缩文件名>	基础解压
7z x <压缩文件名> -o<目录>	解压到指定目录（`-o` 与目录之间无空格）
7z x -p123 <压缩文件名>	解压加密文件
7z x <压缩文件名> -aos	跳过已存在的文件
7z x <压缩文件名> -mcp=<编码数字>	指定编码解压

编码数字对照：

GBK：936
UTF-8：65001

二、apt 包管理#

常用命令#

命令	说明
apt install <软件包名>	安装软件包（安装 deb 包时需加 `./` 定位当前目录）
apt purge <软件包名>	彻底删除软件包及配置文件
apt search <文本>	查找包含指定文本的软件包

组合搜索示例#

Terminal window

1
# 查找含有 dev 字符的 python 包
2
apt search python | grep dev

三、输入设备管理#

1. 列出输入设备#

Terminal window

1
xinput list

2. 禁用/启用设备#

Terminal window

1
xinput disable "<设备名>"|<设备id>   # 禁用指定输入设备
2
xinput enable "<设备名>"|<设备id>    # 启用指定输入设备

Docker 使用指南（Ubuntu 24.04 LTS）#

镜像站推荐： 渡渡鸟镜像同步站

一、安装 Docker#

适用于 Ubuntu 25 系统：

1. 卸载旧版本（若已安装）#

Terminal window

1
sudo apt remove docker docker-engine docker.io containerd runc

2. 更新软件包#

Terminal window

1
apt update
2
apt upgrade

3. 安装基础工具#

Terminal window

1
sudo apt install -y ca-certificates curl gnupg software-properties-common

4. 配置 GPG 密钥#

Terminal window

1
curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

5. 添加软件源#

Terminal window

1
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Terminal window

1
apt update

6. 安装 Docker#

Terminal window

1
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

7. 验证安装#

Terminal window

1
docker --version

二、镜像管理#

命令	说明
docker search <镜像名>	检索镜像
docker pull <镜像名>[:<版本号>\|]	下载镜像
docker images	列出本地镜像
docker rmi <镜像名\|镜像ID>	移除镜像

三、容器管理#

运行容器#

Terminal window

1
docker run [options] <镜像名>

适用于首次启动，创建并运行容器。

常用选项：

选项	说明
-d	后台启动
—name <容器名>	设置容器名
-p 主机端口:容器端口	端口映射

容器生命周期#

命令	说明
docker ps [-a]	查看容器（`-a` 包含已停止的）
docker stop <容器名\|容器ID>	停止容器
docker start <容器名\|容器ID>	启动容器
docker restart <容器名\|容器ID>	重启容器
docker rm [-f] <容器名\|容器ID>	删除容器（`-f` 强制删除运行中的容器）

容器监控与调试#

命令	说明
docker stats <容器名\|容器ID>	查看运行情况
docker logs <容器名\|容器ID>	查看日志
docker exec -it <容器名\|容器ID> /bin/bash	交互式进入容器

临时运行容器执行命令#

Terminal window

1
docker run -it --rm --entrypoint bash <镜像名>

四、Docker Compose 部署#

在包含 docker-compose.yaml 的目录下执行：

Terminal window

1
docker compose up

配置示例：Immich 应用#

docker-compose.yaml：

1
name: immich
2

3
services:
4
  immich-server:
5
    container_name: immich_server
6
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/ghcr.io/immich-app/immich-server:v2.5.6
7
    volumes:
8
      - ${UPLOAD_LOCATION}:/data
9
      - /etc/localtime:/etc/localtime:ro
10
    env_file:
11
      - .env
12
    ports:
13
      - '2283:2283'
14
    depends_on:
15
      - redis
16
      - database
17
    restart: always
18
    healthcheck:
19
      disable: false
20

21
  immich-machine-learning:
22
    container_name: immich_machine_learning
23
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/ghcr.io/immich-app/immich-machine-learning:v1.138.0
24
    volumes:
25
      - ${MODEL_LOCATION}:/cache
26
    env_file:
27
      - .env
28
    restart: always
29
    healthcheck:
30
      disable: false
31

32
  redis:
33
    container_name: immich_redis
34
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/valkey/valkey:8-bookworm
35
    healthcheck:
36
      test: redis-cli ping || exit 1
37
    restart: always
38

39
  database:
40
    container_name: immich_postgres
41
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/ghcr.io/immich-app/postgres:14-vectorchord0.4.3-pgvectors0.2.0
42
    environment:
43
      POSTGRES_PASSWORD: ${DB_PASSWORD}
44
      POSTGRES_USER: ${DB_USERNAME}
45
      POSTGRES_DB: ${DB_DATABASE_NAME}
46
      POSTGRES_INITDB_ARGS: '--data-checksums'
47
    volumes:
48
      - ${DB_DATA_LOCATION}:/var/lib/postgresql/data
49
    shm_size: 128mb
50
    restart: always

展开收起

配套 .env 文件：

1
# 上传文件存储位置
2
UPLOAD_LOCATION=./library
3

4
# 数据库存储位置（不支持网络共享）
5
DB_DATA_LOCATION=./postgres
6

7
# 时区设置（取消注释并修改）
8
# TZ=Etc/UTC
9

10
# Immich 版本
11
IMMICH_VERSION=release
12

13
# 数据库密码（仅使用 A-Za-z0-9，不含特殊字符或空格）
14
DB_PASSWORD=postgres
15

16
# 以下值通常无需修改
17
DB_USERNAME=postgres
18
DB_DATABASE_NAME=immich
19

20
# 模型存储位置
21
MODEL_LOCATION=./model
22
HF_ENDPOINT=https://hf-mirror.com
23
HF_MIRROR=asia

展开收起

五、容器保存#

提交为新镜像#

Terminal window

1
docker commit [options] <容器名|容器ID> <镜像名>:<版本号>

选项：

选项	说明
-a <作者名称>	指定作者
-m “<提交信息>“	添加提交说明