Golang学习（用代码来学习） - 第一篇

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()
}