Go语言学习笔记

package main

import (
	"fmt" 
	"time"
)

func main() {
	fmt.Println("hello, world")
	testClass()
}
// 单行注释
/* 
多行注释
*/

func testClass() {
	// 字符类型
	var a string = "runoob"
	// 数字类型
	var b, c int = 1, 2
	fmt.Println(a,b,c)
	// 布尔类型 默认值 
	var d bool
	var e string
	fmt.Println(d,e)
	// 常量声明后不能修改值，否则会报错
	const f int = 10
	// f = 20
	fmt.Println(f)

	// 运算符
	var j = 10
	var k = 20
	var l int
	l = j + k
	fmt.Println("第一次运算，l的值", l)
	l = j - k
	fmt.Println("第二次运算，l的值", l)
	l = j * k
	fmt.Println("第三次运算，l的值", l)
	l = j / k
	fmt.Println("第四次运算，l的值", l)
	l = j % k
	fmt.Println("第五次运算，l的值", l)
	l++
	fmt.Println("第六次运算，l的值", l)
	l--
	fmt.Println("第七次运算，l的值", l)

	// 逻辑运算符 && || ！ 
	// 位运算符 & | ^ <<左移  >> 右移
	// & + 变量 返回变量存储地址 * + 变量 指针变量

	var m int = 1
	var ptr *int
	ptr = &m
	// fmt.Println("&m", &m)
	fmt.Println("*m", ptr)
	fmt.Println("*m的值为 %d\n", ptr)

	// 条件语句 if else elseif switch select

	// 循环语句 for循环 for ture{} for i=0;i<10;i++{} for i:=0;i<10;i++{}

	// 函数
	/*
	函数格式声明
	func function_name( [parameter list] ) [return_types] {
   		函数体
	}
	*/
	var n, o = maxNum(j,k)
	fmt.Println("maxNum", n, o)
	// 测试变量作用域
	testSocpe()
	// 测试数组
	testArray()
	// 测试指针
	testPointor()
	// 测试结构体
	testType()
	// 测试切片
	testSlice()
	// 测试range
	testRange()
	// 测试map
	testMap()
	// 测试并发
	go say("world")
	say("hello")
	// 测试channel
	testChannel()
}


func maxNum(n1, n2 int) (int, int) {
	var result int
	if(n1 > n2) {
		result = n1
	}else {
		result = n2
	}
	return result, n2
}

/*
默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
值传递	值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递	引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
*/

// go语言变量作用域
// 作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。
// Go 语言中变量可以在三个地方声明：
// 函数内定义的变量称为局部变量
// 函数外定义的变量称为全局变量
// 函数定义中的变量称为形式参数
var p = 100

func testSocpe() {
	// var p = 1 // 与全局变量名称相同时，局部变量优先生效
	fmt.Println("scope:", p)
}

// 数组
func testArray() {
	// var variable_name [SIZE] variable_type 数组声明

	var intArr [2] int
	// var intArr1 = [2] int{1,2}
	// intArr1 := [2] int{3, 4}
	// intArr1 := [3] int{1:1,2:6}//指定位置赋值
	// // 声明可变长度数组 ...
	// var intArr2 = [...] int {1,2,3,4}

	var i int
	// 数组初始化
	for i = 0; i<2; i++ {
		intArr[i] = i
	}
	// 遍历数组
	for i = 0; i< len(intArr); i++{
		fmt.Println("遍历数组:", intArr[i])
	}
}

// Go语言指针
func testPointor() {
	// 指针使用流程：
	// 定义指针变量。
	// 为指针变量赋值。
	// 访问指针变量中指向地址的值。
	var a int = 20
	var ip *int
	ip = &a

	fmt.Printf("a 变量的地址是: %x\n", &a  )
	/* 指针变量的存储地址 */
	fmt.Printf("ip 变量储存的指针地址: %x\n", ip )
	/* 使用指针访问值 */
	fmt.Printf("*ip 变量的值: %d\n", *ip )

	// nil 空指针
}

// Go语言结构体 
// 结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。类似java中的类class
/*
定义结构体
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}
一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：

variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}
*/
type User struct {
	name string
	age int
}
// 测试结构体
func testType() {
	var testUser = User{"张三", 18}
	fmt.Printf("testUser：", testUser )
	// 访问结构体的成员 结构体.成员名
	fmt.Printf("访问结构体的成员：", testUser.name )
	// fmt.Printf("访问结构体的成员：", User.name ) // 报错
	testFuncParam(testUser)
}

func testFuncParam(user User) {
	fmt.Printf("作为方法参数，访问结构体的成员：", user.name )
}


// Go语言切片（对数组的抽象）
func testSlice() {
	var tmpArr  = [] int{1,2,3,4,5}
	printSlice(tmpArr)
	s1 := make([]int, 2)
	printSlice(s1)
	var testNil []int
	printSlice(testNil)
	fmt.Println("变量切片是否是空的", testNil == nil)
	// 截取切片
	printSlice(tmpArr[:2])
	// 追加
	tmpArr = append(tmpArr, 6)// 追加一个
	printSlice(tmpArr)
	tmpArr = append(tmpArr, 7,8,9)// 追加多个
	printSlice(tmpArr)
	// 拷贝
	tmpArr1 := make([]int, len(tmpArr), (cap(tmpArr))*2)
	copy(tmpArr1, tmpArr)
	tmpArr1 = append(tmpArr1, 10)
	printSlice(tmpArr1)
}

func printSlice(x []int){
	for i := 0; i < len(x); i++ {
		fmt.Println("变量切片", x[i])
	}
}

// Go语言范围（range）用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。
func testRange() {
	var tmpArr  = [] int{1,2,3,4,5}
	for i, v := range tmpArr {
		fmt.Printf("range遍历数组，索引：%d ，值：%d\n", i, v)
	}

	tmpMap := make(map[int]int)
	tmpMap[1] = 1
	tmpMap[2] = 2
	tmpMap[3] = 3
	tmpMap[4] = 4
	// 读取key
	for key := range tmpMap {
		fmt.Printf("range遍历map key: %d\n", key)
	}
	// 读取value
	for _, value := range tmpMap {
		fmt.Printf("range遍历map value: %d\n", value)
	}
}

// Go语言map
func testMap() {
	/* 声明变量，默认 map 是 nil 
	var map_variable map[key_data_type]value_data_type
	*/

	/* 使用 make 函数 
	map_variable := make(map[key_data_type]value_data_type)
	*/
	var tmpMap1 map[string]string
	tmpMap1 = make(map[string]string)
	tmpMap1 [ "France" ] = "巴黎"
    tmpMap1 [ "Italy" ] = "罗马"
    tmpMap1 [ "Japan" ] = "东京"
    tmpMap1 [ "India " ] = "新德里"
	for key := range tmpMap1 {
		fmt.Println(key, "首都是", tmpMap1 [key])
	}
	// 查看元素在map中是否存在，
	v1, isExist := tmpMap1["Japan"]
	fmt.Println(v1, "在map中是否存在:", isExist)
	// 删除map中的元素
	delete(tmpMap1, "Japan")
	fmt.Println("删除map中的元素后")
	for key := range tmpMap1 {
		fmt.Println(key, "首都是", tmpMap1 [key])
	}

}

// Go 语言接口

// type TestInterface interface {
// 	testMethod1
// 	testMethod2 int
// }

// type TestImplInterface struct {

// }
// // 实现接口
// func (testImpl TestImplInterface) testMethod1() {
// 	fmt.Println("测试实现接口")
// }

// Go错误处理 error
// panic 与 recover 是 Go 的两个内置函数，这两个内置函数用于处理 Go 运行时的错误，panic 用于主动抛出错误，recover 用来捕获 panic 抛出的错误。

// Go 并发 通过 go 关键字来开启 goroutine 即可， go 函数名( 参数列表 ) 
func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}
// channel 可以理解为消息队列，用于协程之间的通信
func testChannel() {
	ch := make(chan int, 1)
	s := []int{7, 2, 8, -9, 4, 0}
	go sum(s[:len(s)/2], ch)
	go sum(s[len(s)/2:], ch)
	x, y := <-ch, <-ch
	fmt.Println(x, y, x+y)
}

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
			sum += v
	}
	c <- sum // 把 sum 发送到通道 c
}