go基本语法

跟Java比力学习。
hello word

示例代码

1. test1.go文件：
2. // 包路径
3. package main
5. // 导入模块，下面两种都行
6. import (
7.     "fmt"
8. )
9. import "log"
11. //  main方法
12. func main() {
13.     log.Print("hello word !!!")
14.     fmt.Print("hello word 222")
15. }

复制代码

运行命令

go run .\test1.go

打包二进制

> go build .\test1.go
./test1.exe

变量可见性

首字母大写就是public
首字母小写就是private
{不能单独一行

在Java和C中都可以，go中就不行

正确的应该这样：

行结束不需要分号;

加上后IDE会自动给删除
如果你就是要将两行代码放在一行，则需要在结尾加上;分号，但IDEA会在生存的时间自动给你拆分为两行。
字符串

字符串毗连+

格式化

1. // 格式化String.format
2. value := fmt.Sprintf("%s - %s", ">>", "<<")
3. // 打印到console上
4. fmt.Print(value)
6. // 合并：格式化并打印出
7. fmt.Printf("%s - %s\n", ">>", "<<")

复制代码

变量

变量申明和赋值

1. // 只声明一个变量i
2. var i int
3. // 给i变量赋值2
4. i = 2
5. // 创建变量并赋值3
6. ii := 3
7. // 声明常量
8. const pi float64 = 3.14
10. var bo bool = false
11. bo1 := false
12. var f1 float32 = 1.1
13. var f2 = 1.2
14. f3 := 1.3

复制代码

平凡变量范例

uint8 unsiged int 8位
int8 有符号8位int
int16，int32，int64 类似，没有long
float32、float64 轻易明白，没有double

这两个不清晰：
complex64 32 位实数和虚数
complex128 64 位实数和虚数

不一样的：
uintptr 无符号整型，用于存放一个指针
rune 类似 int32
byte 类似 uint8  0到255
变量作用域

全局变量和局部变量可以名称一致，但使用时会优先使用局部变量。
数组

一维数组

1. var strs = [3]string{"111", "222", "333"}
2. // 初始化数组中 {} 中的元素个数不能大于 [] 中的数字。 多出就会报错
3. var strs = [3]string{"111", "222", "333","444"}
4. // 只初始化了前两个元素
5. var strs = [3]string{"111", "222"}
6. // 数组长度根据后边初始化数据的个数来确定为2
7. var strs = [...]string{"111", "222"}
8. // 初始化指定元素下表元素的数据
9. var strs = [...]string{1: "111", 4: "222"}
10. // 数组的长度
11. var length int = len(strs)
12. fmt.Println("数组长度：", length)
13. for i := 0; i < length; i++ {
14.     // 访问和给数组赋值
15.     fmt.Println(len(strs[i]))
16.     strs[i] = "ab"
17. }

复制代码

二维数组 

1. // 定义二位数组，并初始化
2. var rows = [][]int{
3.     {1, 2, 3}, {4, 5, 6}, {7, 8, 9},
4. }
5. fmt.Println(rows)
7. // 二位数组一行一行添加
8. // [3][3]int{} 错误,行列取悦于append了多少次
9. var rows1 = [][]int{}
10. var row1 = []int{1, 2, 3}
11. var row2 = []int{4, 5, 6}
12. // 各行可以一样，也可不一样长
13. var row3 = []int{7, 8, 9, 10}
14. rows1 = append(rows1, row1)
15. rows1 = append(rows1, row2)
16. rows1 = append(rows1, row3)
17. fmt.Println(rows1)
18. fmt.Println("row count:", len(rows1))
19. fmt.Println("col count:", len(row1))
20. fmt.Println("row1 :", rows[0])
21. fmt.Println("row2 :", rows[1])
22. // 不允许访问列 rows[][1]   syntax error: unexpected ], expected operand
23. // fmt.Println("col1 :", rows[][1])
24. fmt.Println("cell[1][1] :", rows[1][1])
26. // 遍历二维数组
27. for i := 0; i < len(rows1); i++ {
28.     for j := 0; j < len(rows1[i]); j++ {
29.         fmt.Println("cell[", i, "][", j, "] : ", rows1[i][j])
30.     }
31. }

复制代码

方法参数传数组和传指针

1. // 包路径
2. package main
4. import "fmt"
6. //  main方法
7. func main() {
8.    
9.     // 定义二位数组，并初始化
10.     var rows = [][]int{
11.         {1, 2, 3}, {4, 5, 6}, {7, 8, 9},
12.     }
13.     fmt.Println(rows)
14.     addRow(rows)
15.     fmt.Println(rows)
16.    
17.     // 传递二维数组的指针 &rows
18.     addRow1(&rows)
19.     fmt.Println(rows)
20.    
21.     // 调用固定元素数组参数，必须是固定元素个数数组
22.     // 数量不一致直接报错
23.     row1 := [5]int{1, 2, 3, 4, 5}
24.     printRow(row1)
25.    
26.     // 将二维数组的第一行当做一维数组也不行
27.     // printRow(rows[0])
28. }
30. // 数组是值类型，这么传实际传的是值而非引用
31. func addRow(rows [][]int) {
32.     row := []int{11, 22}
33.     rows = append(rows, row)
34. }
36. // 接受一个二位数组的指针，就是地址
37. func addRow1(rows *[][]int) {
38.     row := []int{11, 22}
39.     *rows = append(*rows, row)
40. }
42. //  必须这么调用：row1 := [5]int{1, 2, 3, 4, 5};    printRow(row1)
43. func printRow(row [5]int) {
44.     fmt.Println(row)
45. }

复制代码

指针数组

1. // 定义指向数组的指针数组
2. ptr := []*int{&rows[0], &rows[1], &rows[2]}

复制代码

指向指针的指针

1. var pptr **int
2. 已经很熟悉了，不用再说了。

复制代码

 结构体

基本语法

1. // 包路径
2. package main
4. import "fmt"
6. // Book 全局可以使用
7. type Book struct {
8.     title string
9.     auth  string
10. }
12. //  main方法
13. func main() {
14.     // 定义结构体,只能在方法里边用
15.     /*type Book struct {
16.         title string
17.         auth  string
18.     }*/
19.    
20.     var book1 Book
21.     book1 = Book{"title1", "auth2"}
22.     book1 = Book{title: "title2"}
23.     // book2 获取book1的值，最后那个也添加了个逗号，恶心不
24.     book2 := Book{
25.         title: book1.title,
26.         auth:  book1.auth,
27.     }
28.     book1.auth = "1000"
29.    
30.     // 传值：不会修改值
31.     setAuth200(book2)
32.    
33.     // 传地址：会修改值
34.     setAuth200Point(&book2)
35.    
36.     var book3 Book
37.     // 没有book3 == nil 和 book3 == null这么一说
38.     // 是空对象相当于java中：book3 = new Book(); 不给里边赋值，所以直接访问不报错
39.     fmt.Println(book3)
40.     book3.auth = "2000"
41. }
43. // 真NM耐造，book为null 不会报错
44. func setAuth200(book Book) {
45.     book.auth = "2000"
46. }
48. func setAuth200Point(bookPtr *Book) {
49.     (*bookPtr).auth = "2000"
50. }

复制代码

 继承和匿名字段

1. type Person struct {
2.     name string
3.     sex  string
4.     age  int
5. }
7. func (p *Person) say() {
8.     fmt.Println("person fun11")
9. }
11. type Student struct {
12.     // 将Person中的属性继承过来 s1.sex
13.     Person
14.     // 创建person属性 s1.person.sex
15.     person Person
16.     id     int
17.     addr   string
18.     // 如果出现重名情况
19.     age int
20.     // 匿名字段
21.     string
22. }
24. // 继承和匿名字段
25. func main() {
26.     fmt.Println("main ...")
28.     s1 := Student{Person{"5lmh", "man", 20}, Person{"5lmh", "man", 20}, 1, "bj", 20, "匿名字段"}
29.     fmt.Println(s1)
30.     // 获取person属性的sex值
31.     fmt.Println(s1.person.sex)
32.     // 获取继承过来的person属性sex
33.     fmt.Println(s1.sex)
34.     fmt.Println(s1.Person.sex)
36.     // 如果父子类中的属性重复
37.     // 给父类Person中赋值
38.     s1.Person.age = 100
39.     // 给子类属性age赋值
40.     s1.age = 200
41.     fmt.Println(s1)
43.     // 继承还可以继承方法
44.     s1.say()
46.     fmt.Println("success ...")
47. }

复制代码

切片Slice

类似java的ArrayList 

1. var arr = []int{1, 2, 3, 4, 5}
2. fmt.Println(arr)
4. // 切片类似：数组的 substring,前后是包含关系
5. sp := arr[0:]
6. fmt.Println(sp)
7. fmt.Println(len(sp))
8. fmt.Println(cap(sp))
10. // 使用mark创建
11. var number = make([]int, 3, 5)
12. fmt.Println(number, len(number), cap(number))
13. // 在3个元素后边添加
14. number = append(number, 5)
15. // out: [0 0 0 5] 4 5
16. fmt.Println(number, len(number), cap(number))
17. number = append(number, 6)
18. number = append(number, 7)
19. number = append(number, 8)
20. // 长度超过容量后会自动扩容,二倍扩容
21. number = append(number, 9)
22. number = append(number, 10)
23. //out:[0 0 0 5 6 7 8 9 10] 9 10
24. fmt.Println(number, len(number), cap(number))
26. var number1 = make([]int, len(number)*2, cap(number)*2)
27. copy(number1, number)
28. // out:[0 0 0 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0] 18 20
29. // len内的数据会默认给0
30. fmt.Println(number1, len(number1), cap(number1))
32. // 将里边的数据全部清理为0
33. clear(number1)
34. // out：[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 18 20
35. fmt.Println(number1, len(number1), cap(number1))

复制代码

语言范围Rang

 rang 类似 java中的 迭代器 foreach
数组

1. // 遍历数组,index是下标
2. intArr := []int{1, 2, 3, 4, 5}
3. for index := range intArr {
4.     fmt.Print(index, "=", intArr[index], " ")
5. }
6. fmt.Println("")
7. // 可以直接将value遍历出来
8. for index, value := range intArr {
9.     fmt.Print(index, "=", value, " ")
10. }
11. fmt.Println("")
12. // 如果不需要index则可以用_替代，否则由会给你报错，这个变量没用
13. for _, value := range intArr {
14.     fmt.Print(value, " ")
15. }

复制代码

 Map

1. // map的遍历
2. fmt.Println("")
3. map1 := make(map[int]string, 3)
4. fmt.Println(map1)
5. map1[10] = "aa"
6. map1[11] = "bb"
7. fmt.Println(map1)
8. // 遍历map,当前key和value如果不用，可以用_替代
9. for key, value := range map1 {
10.     fmt.Println(key, ":", value)
11. }
12. // 如果只有一个同样，遍历的是key，类似数组的index
13. for key := range map1 {
14.     fmt.Println(key)
15. }

复制代码

切片 

1. fmt.Println("")
2. // 切片也可以类似
3. spArr := make([]int, 2, 50)
4. copy(spArr, intArr[3:])
5. // out:[4 5]
6. fmt.Println(spArr)
7. for index := range spArr {
8.     fmt.Print(index, "=", intArr[index], " ")
9. }

复制代码

channel 

1. // channel 看样子类似java中的MQ，但不用那么复杂的实现机制
2. // chan int : 首先这个是一个通道channel, 然后是一个装int的channel
3. // 类似：LinkedQuery<Integer>
4. ch := make(chan int, 10)
5. ch <- 11
6. ch <- 12
7. ch <- 1000
9. for val := range ch {
10.     fmt.Print(val, " ")
11.     // 一边遍历，一边可以添加数据，比ArrayList的强多了
12.     // 但这么搞就死循环了，逻辑上注意
13.     // ch <- 1000
14. }
15. // 最后需要关闭
16. close(ch)

复制代码

Map聚集 

1. // 创建 <int,string> 初始容量为2
2. mapCap := 2
3. map1 := make(map[int]string, mapCap)
4. fmt.Println(map1)
6. // 添加元素,可相同会覆盖
7. map1[11] = "bb"
8. fmt.Println(map1)
9. map1[11] = "bbb"
10. map1[22] = "ccc"
11. map1[33] = "ddd"
12. fmt.Println(map1)
14. // 根据Key删除元素
15. fmt.Println(len(map1))
16. delete(map1, 22)
17. fmt.Println(map1)
18. fmt.Println(len(map1))
20. // 获取元素,如果没有则为空
21. fmt.Println("key:", 11, ",value:", map1[11])
22. fmt.Println("key:", 66, ",value:", map1[66])
23. // 如果有值则 value就是值，hasBollen为true，如果没有值 hasBollen = false
24. value, hasBollen := map1[66]
25. if hasBollen {
26.     fmt.Println("数据存在,value:", value)
27. } else {
28.     fmt.Println("数据不存在,key:", 66)
29. }
31. // 遍历map
32. fmt.Println(map1)
33. for key, value := range map1 {
34.     fmt.Println("key:", key, ",value:", value)
35. }

复制代码

方法

匿名方法 

1. func(i int, wg *sync.WaitGroup)为形参
2. (i, &wg) 为实际参数
3. var wg sync.WaitGroup
4. for i := 0; i < 10; i++ {
5.     wg.Add(1)
6.     go func(i int, wg *sync.WaitGroup) {
7.        fmt.Println(i)
8.        time.Sleep(20 * time.Microsecond)
9.        wg.Done()
10.     }(i, &wg)
11. }
12. wg.Wait()

复制代码

接口Interface

差别点：
1. struct 实现 interface，并没有显着的实现写法，各写各的
2. struct 可以实现部分interface的方法，而不必要全部实现。直接用没问题，用interface举行引用就报错：
 

1. // 包路径
2. package main
4. import "fmt"
6. // 接口有两个方法
7. type Animal interface {
8.     call()
9.     getName() string
10. }
12. // 创建类Market，有一个name熟悉
13. type Market struct {
14.     name string
15. }
17. /**
18.   实现方法：
19.   1. (m Market)： 标识 这个是Market类的方法
20.   2. call() 接口的方法
21. */
22. func (m Market) call() {
23.     fmt.Println("market call,", "name:", m.name)
24. }
26. func (m Market) getName() string {
27.     return m.name
28. }
30. type Tiger struct {
31.     name string
32. }
34. func (t Tiger) call() {
35.     fmt.Println("tiger call,", "name:", t.name)
36. }
38. func (t Tiger) getName() string {
39.     return t.name
40. }
42. func animalCall(a Animal) {
43.     a.call()
44. }
46. // 空接口，可以接受任何类型的对象，并根据类型判断
47. func print(v interface{}) {
48.     switch t := v.(type) {
49.     case int:
50.         fmt.Println("integer", t)
51.     case string:
52.         fmt.Println("string", t)
53.     }
54. }
56. //  main方法
57. func main() {
58.    
59.     // 接口 interface
60.     m1 := Market{name: "m111"}
61.     fmt.Println(m1.getName())
62.     m1.call()
63.    
64.     m2 := new(Market)
65.     m2.name = "m222"
66.     m2.call()
67.    
68.     t1 := Tiger{name: "t1111"}
69.     fmt.Println(t1.getName())
70.     t1.call()
71.    
72.     // 根据传值的不同
73.     animalCall(m1)
74.     animalCall(t1)
75.    
76.     // 定义一个接口，然后复制类对象，按照接口调用就可以
77.     var a1 Animal
78.     a1 = m1
79.     a1.call()
80.    
81.     // 将m1转换为 Market类型
82.     m11 := a1.(Market)
83.     fmt.Println(m11.name)
84.    
85.     // 空接口接受人任何对象
86.     print(11)
87.     print("str11")
88.    
89. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。