package main
import (
"fmt"
"time"
"unsafe"
)
//示例代码
var isActive bool // 全局变量声明
var enabled, disabled = true, false // 忽略类型的声明
//后面的是返回值,和python很像，表示可以返回多个值
func func_return_values() (int, int, string) {
a, b, c := 1, 2, "hello"
return a, b, c
}
//全局常量的声明和定义
const global_a string = "i am a global"
//全局常量的隐式声明，会自动推断类型
const global_b = "i am another global"
func main() {
var available bool // 一般声明
available = true // 赋值操作
valid := false // 简短生命并赋值，注意赋值:=操作只能用一次
//这种声明方式会自动进行类型推断，所以这里不用管
var my_str string = "hello another world.."
fmt.Println("hello world")
fmt.Printf("available:%d valid:%d\n", available, valid)
fmt.Println("my_str:" + my_str)
first_one := 12
second_one := 13
//_的意思是抛弃第一个值
_, first_one = second_one, 200
fmt.Printf("first_one:%d second_one:%d\n", first_one, second_one)
//相当于是抛弃掉第一个返回值
_, ret_1, ret_2 := func_return_values()
fmt.Printf("ret_1:%d ret_2:%d\n", ret_1, ret_2)
//string在go里面是一个结构体，第一个成员为指向string的指针，第二个成员为长度，每一个都是8字节，所以sizeof是16
my_str2 := "this is a string"
my_str2_len := len(my_str2)
fmt.Printf("unsafe.size: %d str2 len:%d\n", unsafe.Sizeof(my_str2), my_str2_len)
//go里面是支持指针的
my_str3 := "this is third string"
p_str3 := &my_str3
var p_int1 *int
p_int1 = nil
fmt.Printf("my_str3's type:%T p_str3's addr:%p null pointer:%p\n", my_str3, p_str3, p_int1)
//数组学习
array_slice_test()
//指针的学习
pointer_test()
//结构体的学习
struct_test()
//map学习
map_test()
//条件语句学习
if_loop_test()
//函数学习
function_test()
//方法学习，其实就是类似于类里面的函数，但是go没有类这个东西
method_test()
//interface的学习
interface_test()
//错误处理学习
error_handle_test()
//goroutine的学习
goroutine_test()
}
/**
条件语句学习
*/
func if_loop_test() {
print_start_seperator("if_loop_test")
num := 10
if num < 10 {
fmt.Println("num is smaller than 10")
} else if num == 10 {
fmt.Println("num equals to 10")
} else {
fmt.Println("num is greater than 10")
}
//go里面强大的一点儿是，if前面可以加个语句
if num2 := 10; num2 == 10 {
fmt.Println("nums2 equals to 10")
} else {
fmt.Println("nums2 not equals to 10")
}
//传统的c式循环
sum := 0
for i := 0; i <= 10; i++ {
sum += i
}
//无限循环
i := 0
for {
fmt.Print("loop forever\t")
if i++; i > 2 {
break
}
//不支持下面的方式
/*
if i++ > 2{
}*/
}
//对于map，array类型，range可以实现很方便的迭代
str_arr1 := []string{"one", "two"}
for idx, val := range str_arr1 {
fmt.Printf("str_arr1 idx:%d value:%s\n", idx, val)
}
int_arr1 := []int{10, 11, 12, 13, 14}
for idx, val := range int_arr1 {
fmt.Printf("int_arr1 idx:%d value:%d\n", idx, val)
}
map1 := map[string]string{"key1": "value1", "key2": "value2"}
for key, value := range map1 {
fmt.Printf("map key:%s value:%s\n", key, value)
}
print_end_seperator()
}
/**
值传递版本的swap
*/
func my_swap1(left int, right int) {
tmp := left
left = right
right = tmp
}
/**
指针传递版本的swap
*/
func my_swap2(left *int, right *int) {
tmp := *left
*left = *right
*right = tmp
}
//进行一个函数声明
type my_callback func(string)
/**
一起来调用callback函数
*/
func let_us_callback(cb my_callback, str string) {
fmt.Println("start call callback function...")
cb(str)
fmt.Println("callback function finished...")
}
/*
go语言里面的闭包函数
可以理解为调用该函数，然后返回一个内部的一个匿名函数，但是getSeq函数里面的状态是被保存的
*/
func getSeq() func() int {
i := 0
return func() int {
i++
return i
}
}
/**
函数测试学习
*/
func function_test() {
print_start_seperator("function_test")
//go支持值传递和引用传递，比如下面的例子
a := 100
b := 200
fmt.Printf("[before swap1] a:%d b:%d\n", a, b)
my_swap1(a, b)
fmt.Printf("[after swap1] a:%d b:%d\n", a, b)
a, b = 100, 200
fmt.Printf("[before swap2] a:%d b:%d\n", a, b)
my_swap2(&a, &b)
fmt.Printf("[after swap2] a:%d b:%d\n", a, b)
//类似于python，函数也可以直接传递给一个变量，类似于函数指针
pow_func := func(nums int) (int) {
return nums * nums
}
fmt.Printf("my pow_func:%d\n", pow_func(10))
//在go中实现callback函数
cb1 := func(str string) {
fmt.Printf("haha, i am a callback function! str:%s\n", str)
}
let_us_callback(cb1, "in caller")
//调用闭包函数
next_number := getSeq()
fmt.Printf("next_number:%d\n", next_number())
fmt.Printf("next_number:%d\n", next_number())
fmt.Printf("next_number:%d\n", next_number())
print_end_seperator()
}
