当前位置：首页 > article >正文

Go语言基础教程1

article 2025/1/14 1:12:27

Go语言基础教程

一、变量声明

1.1 基本变量声明

// 标准声明
var variableName variableType

// 示例
var age int
var name string

1.2 变量声明与初始化

// 显式类型声明
var age int = 30

// 类型推断
var age = 30

// 短变量声明（函数内部）
age := 30

1.3 多变量声明

// 基本形式
var a, b, c int

// 初始化
var d, e, f = 1, 2, 3

// 短变量声明
g, h, i := 4, 5, 6

// 批量声明
var (
    a int
    b string
    c []float32
    d func(a int) int
)

1.4 特殊变量 - 下划线

// 忽略返回值
result, _ := someFunction()

// 忽略索引
for _, value := range slice {
    // 使用value
}

// 引入包但不使用
import _ "database/sql"

二、Go语言基本数据类型

2.1 数值类型

整数类型
- 有符号：int8, int16, int32, int64
- 无符号：uint8, uint16, uint32, uint64
- 平台相关：int, uint
浮点类型：float32, float64
复数类型：complex64, complex128

2.2 字符串类型

string：UTF-8编码的字符串

2.3 布尔类型

bool：true 或 false

2.4 字符类型

byte：uint8的别名
rune：int32的别名，表示Unicode码点

2.5 复合类型

数组（array）
切片（slice）
映��（map）
结构体（struct）
通道（channel）
接口（interface）
指针（pointer）

三、Go语言常量

3.1 常量声明

// 单个常量
const PI = 3.14159
const NAME string = "Go语言"

// 批量声明
const (
    Monday = 1
    Tuesday = 2
    Wednesday = 3
)

3.2 iota常量生成器

const (
    Red = iota    // 0
    Green         // 1
    Blue          // 2
)

四、切片操作

4.1 切片基础

// 声明切片
var s []int
s1 := []int{1, 2, 3}

// 使用make创建切片
s2 := make([]int, 5)    // 长度为5
s3 := make([]int, 3, 5) // 长度为3，容量为5

4.2 切片操作

// 添加元素
s = append(s, 4, 5)

// 切片截取
s1 := []int{1, 2, 3, 4, 5}
s2 := s1[1:3] // [2, 3]

五、字符串处理

5.1 字符串切片

str := "hello world"
fmt.Println(str[6:])    // "world"
fmt.Println(str[:5])    // "hello"
fmt.Println(str[6:8])   // "wo"

5.2 字符串操作注意事项

索引从0开始
切片操作包含起始索引，不包含结束索引
字符串是不可变的，切片操作会创建新的字符串

转换不同的数据类型

fmt.Println(“int8 range:”,math.MinInt8,“~”,math.MaxInt8)
fmt.Println(“int16 range:”,math.MinInt16,“~”,math.MaxInt16)
fmt.Println(“int32 range:”,math.MinInt32,“~”,math.MaxInt32)
fmt.Println(“int64 range:”,math.MinInt64,“~”,math.MaxInt64)

var c float32 = math.Pi
fmt.Println(int（c ）)

六、指针

6.1 指针基础

// 类型指值及切片

// 声明一个整型切片
var numbers []int

// 使用make创建切片
numbers = make([]int, 0) // 初始化一个空切片

// 添加元素到切片
numbers = append(numbers, 10)
numbers = append(numbers, 20, 30)

// 打印切片内容
fmt.Println(“切片内容:”, numbers) // 输出: 切片内容: [10 20 30]

// 声明一个指向切片的指针
var ptrSlice *[]int
ptrSlice = &numbers // 将切片的地址赋值给指针
fmt.Println(ptrSlice)

// 通过指针修改切片
*ptrSlice = append(*ptrSlice, 40) // 添加元素40

// 打印修改后的切片内容
fmt.Println(“修改后的切片内容:”, *ptrSlice) // 输出: 修改后的切片内容: [10 20 30 40]

// 声明指针
var ptr *int      // 声明一个指向int类型的指针
var name *string  // 声明一个指向string类型的指针

// 获取变量地址
x := 42
ptr = &x         // &运算符获取变量x的内存地址
fmt.Println(ptr) // 输出内存地址，如：0xc000014088
fmt.Println(*ptr) // 输出：42，使用*运算符获取指针指向的值

6.2 指针操作

// 通过指针修改值
x := 1
ptr := &x
*ptr = 2        // 修改指针指向的值
fmt.Println(x)  // 输出：2

// new函数创建指针
ptr := new(int) // 创建一个指向int的指针，并分配内存
*ptr = 100      // 给指针指向的内存赋值

6.3 指针的应用场景

// 1. 在函数中修改外部变量
func modify(ptr *int) {
    *ptr = 100
}

x := 1
modify(&x)
fmt.Println(x) // 输出：100

// 2. 结构体指针
type Person struct {
    name string
    age  int
}

p := &Person{
    name: "张三",
    age:  25,
}
fmt.Println(p.name) // 输出：张三
// 注意：Go语言中不需要写(*p).name，p.name即可

6.4 指针注意事项

指针的零值是nil
不支持指针运算（不能像C语言那样进行地址加减运算）
不同类型的指针不能相互转换
不能获取常量或字面量的地址
指针可以指向指针，形成多级指针（如**int）

6.5 指针的使用建议

当需要修改函数外的变量时使用指针
传递大型结构体时使用指针可以提高效率
在方法接收器中使用指针可以修改结构体的状态
注意避免悬空指针（指向已释放内存的指针）

var cat int = 1
var str string = “banana”
fmt.Printf(“%v %T\n”, cat, cat)
fmt.Printf(“%v %T\n”, str, str)
fmt.Printf(“%p %T\p”, &cat, &acat)

七、格式化输出参数

7.1 通用占位符

%v     // 以默认格式输出值
%+v    // 输出结构体时会包含字段名
%#v    // 输出值的Go语法表示
%T     // 输出值的类型
%%     // 输出百分号本身

7.2 布尔值

%t     // true 或 false

7.3 整数

%b     // 二进制
%c     // 对应的unicode字符
%d     // 十进制
%o     // 八进制
%O     // 带0o前缀的八进制
%q     // 带单引号的字符
%x     // 小写十六进制
%X     // 大写十六进制
%U     // Unicode格式：U+1234

7.4 浮点数和复数

%b     // 科学计数法
%e     // 科学计数法（小写e）
%E     // 科学计数法（大写E）
%f     // 带小数点的十进制
%F     // 等同于%f
%g     // 根据情况选择%e或%f
%G     // 根据情况选择%E或%F

7.5 字符串和切片

%s     // 字符串或切片的字面值
%q     // 双引号引起的字符串
%x     // 十六进制，小写字母，每字节两个字符
%X     // 十六进制，大写字母，每字节两个字符

7.6 指针

%p     // 带0x的指针值

// 示例
x := 42
ptr := &x
fmt.Printf("指针值：%p\n", ptr)    // 输出类似：0xc000014088

7.7 宽度和精度

%f        // 默认宽度和精度
%9f       // 宽度9，默认精度
%.2f      // 默认宽度，精度2
%9.2f     // 宽度9，精度2
%9.f      // 宽度9，精度0

// 示例
fmt.Printf("%9.2f\n", 3.14159)  // 输出：    3.14

7.8 其他格式控制

%-9s      // 左对齐，宽度9
%*9s      // 右对齐，宽度9
%9s       // 右对齐，宽度9
%09d      // 左填充0

// 示例
fmt.Printf("%-9s", "hello")     // 输出："hello    "
fmt.Printf("%09d", 123)         // 输出："000000123"

type Person struct {
    Name string
    Age  int
}

p := Person{"张三", 25}

fmt.Printf("%v\n")      // {张三 25}
fmt.Printf("%+v\n")     // {Name:张三 Age:25}
fmt.Printf("%#v\n")     // main.Person{Name:"张三", Age:25}
fmt.Printf("%T\n")      // main.Person
fmt.Printf("%p\n")      // 0xc000096000