Golang学习笔记20240725，Go语言基础语法

第一个Go程序

package mainimport "fmt"func main() {fmt.Println("hello world")
}

运行方式1：

go run main.go

运行方式2：

go build
.\hello_go.exe

运行方式3：goland右键运行

字符串拼接

使用加号可以对字符串进行拼接。

package mainimport "fmt"func main() {fmt.Println("hello world" + "你好世界")
}

变量的声明和初始化

package mainimport "fmt"func main() {var a, b, c inta = 11b = 22c = 333fmt.Println(a)fmt.Println(b)fmt.Println(c)
}

简短的声明

上面的变量定义和初始化有更简单的方式，如下：

package mainimport "fmt"func main() {a := 11b := 22c := 333fmt.Println(a)fmt.Println(b)fmt.Println(c)
}

格式化输出

使用%d可以在字符串中格式化输入整数类型，如下：

package mainimport "fmt"func main() {a := 11b := 22c := 333fmt.Printf("a=%d, b=%d, c=%d\n", a, b, c)
}

if语句

if语句主要有三种格式，如下：

package mainimport "fmt"func main() {a := 33// 单分支if a > 0 {fmt.Println(a)}// 双分支if a < 0 {fmt.Println(a)} else {fmt.Println(a + a)}// 多分支if a > 100 {fmt.Println(a)} else if a > 0 {fmt.Println(a + a)} else {fmt.Println(a + a + a)}
}

for循环

累加求和：

package mainimport "fmt"func main() {sum := 0for i := 0; i < 101; i++ {sum += i}fmt.Println(sum)
}

双重for循环打印九九乘法表

package mainimport "fmt"func main() {for i := 1; i < 10; i++ {for j := 1; j <= i; j++ {fmt.Printf("%d * %d = %d\t", j, i, i*j)}fmt.Println()}
}

for遍历数组

package mainimport "fmt"func main() {arr := []int{11, 22, 33}for k, v := range arr {fmt.Println(k, v)}
}

for 遍历字符串

package mainimport "fmt"func main() {arr := "abc"for k, v := range arr {fmt.Println(k, v)}
}

for遍历字典

package mainimport "fmt"func main() {arr := map[string]int{"one": 1, "two": 2, "three": 3}for k, v := range arr {fmt.Println(k, v)}
}

for 遍历管道

package mainimport "fmt"func main() {c := make(chan int)go func() {c <- 33c <- 333c <- 333333close(c)}()for v := range c {fmt.Println(v)}
}

匿名变量

如果我们在遍历的时候，不想要key或者value，也可以用下划线替代，下划线叫做匿名变量。

package mainimport "fmt"func main() {c := []int{1, 2, 3}for _, v := range c {fmt.Println(v)}
}

switch 语句

go语言里面的switch语句每个case天生就是独立的，不需要加break。

package mainfunc main() {s := "python"switch s {case "python":print("1")case "go":print("2")case "java":print("3")default:print("4")}
}

switch 可以一个分支捕获多个值

这个是go语言的特点，很少在其他语言看见，我们来看例子：

package mainfunc main() {s := "python"switch s {case "python", "go", "java":print("1")default:print("4")}
}

switch的分支可以捕获条件判断

这个也是go语言的特点，我们来看例子：

package mainfunc main() {s := 33switch {case s > 0 || s < 100:print("1")default:print("4")}
}

字符串可以通过索引访问字符

package mainfunc main() {s := "abcde"print(s[0])
}

字符串可以通过切片访问连续字符

package mainfunc main() {s := "abcde"print(s[0:3])
}

统计字符串的个数要用特殊的方法

package mainimport "unicode/utf8"func main() {s := "abcde"print(utf8.RuneCountInString(s))
}

将字符编码转换为字符

package mainfunc main() {s := "abcde"print(string(s[1]))
}

遍历字符串的每一个字符

package mainimport "fmt"func main() {s := "我 爱 你 中 国"cs := []rune(s)for _, ch := range cs {fmt.Println(string(ch))}
}

使用buffer累加字符串

package mainimport ("bytes""fmt"
)func main() {var bf bytes.Bufferfor i := 0; i < 10; i++ {fmt.Fprintf(&bf, "a%d ", i)}s := bf.String()fmt.Println(s)
}

通过指针修改变量的值

指针可以直接对内存地址进行操作。使用*表示指针，使用&取地址。

package mainimport "fmt"func main() {a := 33pa := &a*pa = 333fmt.Println(a)fmt.Println(*pa)
}

使用指针交换两个变量的值

package mainimport "fmt"func swap(a, b *int) {*a, *b = *b, *a
}func main() {a, b := 33, 11fmt.Println(a, b)swap(&a, &b)fmt.Println(a, b)
}

数组的基本使用

package mainimport "fmt"func main() {// 声明var arr [8]int// 赋值for i := 0; i < 8; i++ {arr[i] = i * 33}// 遍历for i := 0; i < 8; i++ {fmt.Println(arr[i])}
}

结构体的基本用法

package mainimport "fmt"type User struct {Name stringAge  int
}func main() {zs := User{"zs", 20}ls := User{Name: "ls", Age: 20}fmt.Println(zs, ls)
}

结构体作为函数参数

package mainimport "fmt"type User struct {Name stringAge  int
}func printUser(u User) {fmt.Printf("姓名：%s 年龄：%d \n", u.Name, u.Age)
}func main() {zs := User{"zs", 20}ls := User{Name: "ls", Age: 20}printUser(zs)printUser(ls)
}

结构体指针作为函数参数

package mainimport "fmt"type User struct {Name stringAge  int
}func printUser(u *User) {fmt.Printf("姓名：%s 年龄：%d \n", u.Name, u.Age)
}func main() {zs := User{"zs", 20}ls := User{Name: "ls", Age: 20}printUser(&zs)printUser(&ls)
}

切片的增删改查

切片在go语言里面非常常用，因为其有动态扩展的特性。

package mainimport "fmt"func main() {var arr []int// 增加arr = append(arr, 11)arr = append(arr, 22)arr = append(arr, 33)// 删除 索引1index := 1arr = append(arr[:index], arr[index+1:]...)// 修改arr[0] = 888// 遍历for _, v := range arr {fmt.Println(v)}
}

map的增删改查

package mainimport "fmt"func main() {var m = make(map[string]int)// 增加m["a"] = 11m["b"] = 12m["c"] = 13// 删除delete(m, "a")// 修改m["c"] = 888// 遍历for k, v := range m {fmt.Println(k, v)}
}

加法函数

package mainimport "fmt"func add(a, b int) int {return a + b
}func main() {fmt.Println(add(1, 2))
}

函数的可变参数

package mainimport "fmt"func add(arr ...int) int {sum := 0for i := 0; i < len(arr); i++ {sum += arr[i]}return sum
}func main() {fmt.Println(add(1, 2))fmt.Println(add(1, 2, 3, 4, 5))
}

匿名函数

package mainimport "fmt"func main() {defer func() {fmt.Println("这个是匿名函数")}()fmt.Println("xxx")
}