golang学习之路：从入门到实践

//常量定义
const (
	StatusOK           = iota + 1    //iota是go语言的一个预定义标识符，表示常量生成器，在const关键字出现时被重置为0，并在每个const声明中自动递增。     
	StatusBadRequest                 //2
	StatusUnauthorized               //3
	MB                 = 1024 * 1024 //1048576
)

//变量定义
func main() {
	var str1 string = "Hello Go 1" //标准定义
	var str2 = "Hello Go 2"        //类型推断

	str3 := "Hello Go 3"          //短定义（通常用于函数中）
	fmt.Println(str1, str2, str3) //output：Hello Go 1 Hello Go 2 Hello Go 3
	str1, str2 = str2, str1       //交换str1与str2的值
	fmt.Println(str1, str2, str3) // output：Hello Go 2 Hello Go 1 Hello Go 3
}

//空值
func testNonInitValue() {
	var a int
	var b string
	var c float64
	fmt.Println(a, b, c) //output: 0 “” 0
	//上一行b输出的结果代表b的值是一个空字符串，而不是null或者undefined。
}


//至于类型转换，认真学过Java都知道
...略

//类型自定义
type ll int64 // 定义一个新的类型ll，它的底层类型是int64
//为ll类型实现String方法，使其满足fmt.Stringer接口
func (l ll) String() string {
	return fmt.Sprintf("%d", l)
}
//结构体
type UserValue struct {
	name  string
	age   int
	email string
}
//同理，结构体也可以实现String方法
func (u UserValue) String() string {
	return fmt.Sprintf("name:%s, age:%d, email:%s)", u.name, u.age, u.email)
}
// slice
var arr [3]int       //只定义，为使用 output: 0,0,0
b := [3]int{1, 2, 3} //临时定义，并且附上初值 output:1,2,3
var c []int          //不定长
c1 = append(c, 1,2,3,4,5)
c2 := []int{1,2,3,4,5}
sc1 := make([]int, 0, len(c1)) // make函数创建一个长度为0，容量为len(c1)的切片
sc2 := new ([]int) // new函数创建一个指向长度为0的切片的指针

//map 键值对
m1 := map[string]int{"a": 1, "b": 2} //定义并初始化一个map output: map[a:1 b:2]
m2 := make(map[string]int)              //使用make函数创建一个空的map
m2["c"] = 3 //向map中添加一个键值对
for k, v := range m1 { // 使用range关键字遍历map，k代表键，v代表值
    fmt.Printf("key: %s, value: %d\n", k, v) //output: key: a, value: 1 \n key: b, value: 2
}

//if语句
if x > 0 {
    fmt.Println("x is positive")
} else if x < 0 {
    fmt.Println("x is negative")
} else {
    fmt.Println("x is zero")
}

//switch语句
switch day := time.Now().Weekday(); day {
case time.Monday:
    fmt.Println("It's Monday")
case time.Tuesday:
    fmt.Println("It's Tuesday")
default:
    fmt.Println("It's another day")
}

//for循环
for i := 0; i < 5; i++ {
    fmt.Println(i) //output: 0 1 2 3 4
}

//goto语句
func example() {
    fmt.Println("Start")
    goto Skip
    fmt.Println("This will be skipped")
Skip:
    fmt.Println("End")
}
//output: Start \n End

//select语句
ch1 := make(chan string)
ch2 := make(chan string)
go func() {
    time.Sleep(1 * time.Second)
    ch1 <- "Hello from channel 1"
}()
go func() {
    time.Sleep(2 * time.Second)
    ch2 <- "Hello from channel 2"
}()
select {
case msg1 := <-ch1: 
    fmt.Println(msg1) //output: Hello from channel 1
case msg2 := <-ch2:
    fmt.Println(msg2) //output: Hello from channel 2
case <-time.After(3 * time.Second):
    fmt.Println("Timeout")
}

//函数定义
func add(a int, b int) int {
	return a + b
}
//函数调用
result := add(3, 5) //output: 8
//方法定义
type Rectangle struct {
	width  float64
	height float64
}
func (r Rectangle) Area() float64 {
	return r.width * r.height
}
//方法调用
rect := Rectangle{width: 4, height: 5}
area := rect.Area() //output: 20

// 匿名函数
func() {
	fmt.Println("This is an anonymous function")
}() //output: This is an anonymous function

// 闭包
func makeAdder(x int) func(int) int {
	return func(y int) int {
		return x + y
	}
}
add5 := makeAdder(5)
result := add5(3) //output: 8

//可变参数
func sum(nums ...int) int {
	total := 0
	for _, num := range nums {
		total += num
	}
	return total
}
result := sum(1, 2, 3, 4) //output: 10

//指针定义
var p *int //定义一个指向int类型的指针
//指针赋值
x := 10
p = &x //将变量x的地址赋值给指针p
//指针解引用
value := *p //通过指针p获取x的值 output: 10
//指针修改值
*p = 20 //通过指针p修改x的值
fmt.Println(x) //output: 20

//指针与函数
func increment(n *int) {
	*n++ //通过指针n修改传入的值
}
num := 5
increment(&num) //传入num的地址
fmt.Println(num) //output: 6	

//指针与结构体
type Point struct {
	x int
	y int
}
p1 := Point{x: 1, y: 2}
p2 := &p1 //创建一个指向p1的指针
p2.x = 3 //通过指针p2修改p1的x值
fmt.Println(p1) //output: {3 2}

//指针与切片
func modifySlice(s []int) {
	s[0] = 100 //修改切片的第一个元素
}
slice := []int{1, 2, 3}
modifySlice(slice) //传入切片
fmt.Println(slice) //output: [100 2 3]

//二级指针
x := 10
p := &x
pp := &p
fmt.Println("x:", x, "p:", p, "pp:", pp, "**pp:", **pp) //output: x: 10 p:随机地址 pp: 随机地址 **pp: 10

//error类型
type error interface {
	Error() string
}

//defer语句
func example() {
	defer fmt.Println("This will be printed last")
	fmt.Println("This will be printed first")
}//output: This will be printed first \n This will be printed last

//panic和recover
func example() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Recovered from panic:", r)
		}
	}()
	panic("Something went wrong") //触发panic
	fmt.Println("This will not be printed")
}//output: Recovered from panic: Something went wrong