Go学习笔记

前言

仅记录学习笔记，如有错误欢迎指正。

开发环境

idea plugins 下载

下载go sdk

直接new go项目就ok了

基本语法

package main

import (
	"fmt"
	"unsafe"
)
/**
当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，
那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），
这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的
，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
 */
var x,y,z int
const (
	one = "abc"
	two = 999

)


func main(){
	//输出
	fmt.Println("hello GO!!!!" + "say hi")
	//常量的定义
	const PI float64 = 3.1415926
	if PI != 3{
		fmt.Println("not equals")
	}
	var stockCode=123
	// %d 表示整型数字，%s 表示字符串
	var endDate="2020-12-31"
	var url="Code=%d&endDate=%s"
	var target_url=fmt.Sprintf(url,stockCode,endDate)
	fmt.Println(target_url)
	//p := testRes()
	//声明式定义 让编译器自己去管理类型 无需定义类型
	num1 := 1
	num2 := 9
	println(num1+num2)

	x=2
	y=2
	println(x*y)
	res := testRes(x,y)
	println(res)

	testIota()
	getSize()
}
//先写接受 再写返回的类型
func  testRes( x1 ,x2 int) int{
  //var x1 ,x2 int = 1,2
  fmt.Println(x1+x2)
   res := x1+x2
  return res

}

//iota 后面的变量会自动跟随第一个变量的赋值 ++
const (
	i int = 2<<iota
	j
	k
)

func testIota(){
	println(i,j,k)

}
func getSize(){
	s := "hello"
	println(unsafe.Sizeof(s))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

类型转换、指针、递归

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var nums [5]int
	var nums1 = [3]int{1,2,3}
	//var p *[]int 指针和引用
	p := &nums1
	fmt.Println(nums1,nums,*p)

	num2 := nums1[1:3]
	fmt.Println(num2,len(num2),cap(num2))

	//切片为引用传递 数组为值传递
	num3 := []int{1,2,3}
	changeData(nums1)
	changeData1(num3)
	fmt.Println("after change")
	fmt.Println(nums1,num3)

	//类似java的foreach
	s :="abcdef"
	for _,str := range s{
		fmt.Printf("%c", str)
	}
	fmt.Println(fibonacci(6))
	//str 转数字
	var stri string = "12"
	var number int
	number,_=strconv.Atoi(stri)
	strconv.Itoa(number)
	fmt.Println(number)

}

//递归 斐波那契
func fibonacci(n int) int{
	if n < 2 {
		return n
	}
	return fibonacci(n-1) + fibonacci(n-2)

}

func changeData(arr [3]int )  {
	arr[0] = 999
}
func changeData1(arr []int )  {
	arr[0] = 999
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

接口 并发 通道

package main

import (
	"fmt"
	"time"
)

//interface

type Animal interface {
	run()
}

type Tiger struct {
	leg string
}
func (tiger Tiger) run(){
	fmt.Println("i am tiger,i have " + tiger.leg+ " legs,run fast")
}
type Human struct {
	leg string
}
func (human Human) run(){
	fmt.Println("i am human,i have " + human.leg+ " legs,run slow")
}

func say(s string){
	 for i:=0;i<5;i++{
	 	time.Sleep(100*time.Millisecond)
	 	fmt.Println(s)
	 }
}
//c channel
func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // 把 sum 发送到通道 c
}


func main() {
	//"继承"和“多态”
	var tiger Animal = Tiger{"5"}
	var human Animal = Human{leg: "2"}
	tiger.run()
	human.run()
	//并发处理
	//Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。
	//goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。
	//goroutine 语法格式：
	go say("1111")
	 say("222")

	s := []int{7, 2, 8, -9, 4, 0}

	//通道（channel）是用来传递数据的一个数据结构。
	//通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。
	//操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。
	//通道缓冲区
	//通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：
	c := make(chan int)
	go sum(s[:len(s)/2], c)
	go sum(s[len(s)/2:], c)
	x, y := <-c, <-c // 从通道 c 中接收

	fmt.Println(x, y, x+y)

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71