前言

什么是go

Go（又称 Golang）是 Google 的 Robert Griesemer，Rob Pike 及 Ken Thompson 开发的一种静态强类型、编译型语言。Go 语言语法与 C 相近，但功能上有：内存安全，GC（垃圾回收），结构形态及 CSP-style 并发计算。

为什么要使用go

Go是富有表现力的，简洁的，干净的，高效的。其并发机制使其可以轻松编写程序，以充分利用多核和联网机器，而其新颖的类型系统可实现灵活和模块化的程序构建。
个人感觉go在未来几年应该会有一个不错的位置（仅仅只是个人感觉），但现在用的最多肯定还是使用较为主流的语言。

go基础语法

这里说一下，本人使用的编译器是vscode，然后通过下载插件和配置环境，然后才可使用。

go的第一个程序

和我们刚开始学习一门语言一样，我们都是从打印输出一个hello，world开始。
我现在用的是C/C++语言，所以的话对于学go还是多多少少感觉有点相似，感觉语法这个东西都是差不多。

首先呢我创建了一个go项目的文件夹，然后在vscode中打开，再里面再创建一个基础语法的文件夹，然后再文件夹里创建了helloworld.go的文件，go文件后面的后缀是go。

我们在go中定义的变量必须要使用，不然编译器会报错,程序也会编译通过不了

然后在文件内编写以下代码

//package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
package main

//import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。
import "fmt"

//func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的
//一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
func main() {	//{ 不能单独放在一行 不然会报错

	//使用的语法和c一样，可以使用%d %s
	fmt.Printf("hello, world\n")

	//输出之后自动换行
	fmt.Println("hello, world")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

我们可以看到我们在写完一行的代码之后，后面不用写 ; 符号，这就是go语言的一种语法特性
编写完之后，我们通过使用命令的方式执行该程序，命令为：go run 文件名
例如go run helloworld.go 注意，一定得是go文件才可以。

不过我在vscode中 在输入 go run h 然后按Tab键之后 它直接帮我们补全，就会是 go run .\helloworld.go，不过都是一样的。

以上就是我们go的第一个程序了。

go变量用法

这里我又创建了一个新的go文件
第一种先定义变量，然后再进行赋值的操作

package main

import "fmt"

func main() {
	//先定义变量 再赋值
	var name string
	var age int

	name = "rainbow"
	age = 22
	fmt.Printf("name: %s, age: %d\n", name, age)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

然后执行该文件得到结果

第二种是直接定义然后赋值的操作

var work = "it"	//也可以写成var work string = "it"
fmt.Printf("work: %s\n", work)
1
2

执行可得

第三种就是直接赋值 并自动推导，这种是比较常用的

a := "hello"
fmt.Println(a)
1
2

执行可得

还有一种是平行赋值

//平行赋值	可以同时给多个变量进行赋值
i, j := 10, 20
fmt.Printf("交换前i：%d， j：%d\n", i, j)

i, j = j, i
fmt.Printf("交换后i：%d， j：%d\n", i, j)
1
2
3
4
5
6

执行可得

go的变量自增

package main

import "fmt"

func main() {
	//只有 i++ i--

	i := 100
	i++
	//fmt.Println(i++)	在输出语法里进行自增操作也会错误
	fmt.Println(i)

	//在go语法中 for 和 if 这样的 都是可以不用写()的
	//我们可以在for循环中 进行j++
	for j := 0; j < 10; j++ {
		fmt.Printf("%d ", j)
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

执行可得

go指针用法

在go语言中，go也有指针，但是go中的指针和c/c++中的指针不一样，例如在一个结构体中，c/c++是会通过箭头->去获取该值,而go中是用.去获取该值。
go语言在使用指针时，会使用内部的垃圾回收机制(gc : garbage collector)，开发人员不需要手动释放内存。

package main

import "fmt"

func main() {
	num := 100
	ptr := &num //ptr是一个指针指向该num的地址

	fmt.Println("ptr 地址: ", ptr)
	fmt.Println("ptr : ", *ptr)
}
1
2
3
4
5
6
7
8
9
10
11

执行可得

也可以使用new 关键字来进行指针的操作

//使用new关键字
str := new(string)
*str = "rainbow"

fmt.Println("str: ", str)
fmt.Println("*str: ", *str)
1
2
3
4
5
6

执行可得

在go中判断是否为空的字符是nil，if判断可以不用()，一行都必须得加{}

if str == nil {
	fmt.Println("str 为空")
} else { //else必须在{}上
	fmt.Println("str 非空")
}
1
2
3
4
5

因为str前面以及进行操作指针赋值操作，所以str为非空

在这里我们在main函数外写一个指针函数

//定义一个函数，返回一个string函数的指针，go语言返回写在参数列表后面
func test() *string {
	ans := "海南"
	ptr := &ans

	return ptr
}
1
2
3
4
5
6
7

然后再main函数中调用该函数，并且拿到它返回的值

//可以返回栈上指针，编译器在编译程序时，会自动判断这段代码，将变量分配到堆上
	res := test()

	fmt.Println("*res: ", *res)
1
2
3
4

这样也可以得到该函数变量的地址

go string的用法

在go中，string没有length()的用法，以及size()的用法，所以我们不能在go中使用这两个方法，但是go里面提供了一个自由函数 就是len(),它可以处理字符串的长度，以及数组的长度等。这是一个会经常用到的函数。

还有就是我们在c/c++中要想使用字符串换到另一行，得再" "里后面使用\，但是在go中要使用反引号。

package main

import "fmt"

func main() {
	name := "rainbow"

	//需要换行，原生输出字符串时，使用反引号``
	usage := `./out 
		-a	txt
		-b	count`

	fmt.Println("name: ", name)
	fmt.Println("usage: ", usage)

	//用自由函数 len处理字符串长度
	//len()函数会经常用
	l := len(name)
	fmt.Println("name len: ", l)

	for i := 0; i < len(name); i++ {
		fmt.Printf("c:%c ", name[i])
	}

	println()

	//字符串可以拼接打印
	str1, str2 := "你好", "深圳"

	fmt.Println("str1 + str2: ", str1+str2)
}
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

执行该代码可得以下结果

go 定长数组

定义一个数组最常见的语法是nums := [10]int{1, 2, 3, 4, 5} 这是定义了一个具有10个数字的数组。

nums := [10]int{1, 2, 3, 4, 5}
1

而定义完之后，我们有几种可以遍历数组里元素的方法。
第一种是获取数组里的大小，然后通过下标去获取对应下标里数组的值。

	//遍历数组方式1
	for i := 0; i < len(nums); i++ {
		fmt.Printf("%d ", nums[i])
	}
1
2
3
4

输出结果如下

第二种是使用range
第一个元素对应的是该数组的下标，第二个元素对应的是该下标对应的值，这个有点和C++ 的那个 for（auto& c : nums)遍历数组相似

for key, value := range nums {
		fmt.Println("key:", key, " value: ", value)
	}
}
1
2
3
4

也可以不用输出下标的值，我们可以该为

for _, value := range nums {
		fmt.Println(" value: ", value)
	}
}
1
2
3
4

当然也可以只输出下标的值

for key, _ := range nums {
		fmt.Println("key:", key)
	}
}
1
2
3
4

未完待续~~