一文带你入门go语言

一文带你入门go语言

go/golang是一门google开发的编程语言，其代码简洁易读，天生支持并发，完美契合当今互联网生态。
目前Go语言已经⼴泛应用于人工智能、云计算开发、容器虚拟化、⼤数据开发、数据分析及科学计算、运维开发、爬虫开发、游戏开发等领域。
相信大家都听说过大名鼎鼎Docker就是用go语言所开发的。
接下来让我带你光速入门go语言！

go希望你把所有的项目都放到一个文件夹下，这个文件夹是GOPATH，这个文件夹下包含src（存放你所有的代码），bin（存放编译后二进制文件），pkg（存放编译后的库文件）。个人开发者直接在src下创建个人文件夹即可。

PS D:\go\src> mkdir project_one
PS D:\go\src> cd project_one
PS D:\go\src\project_one> touch main.go

上面的操作创建了一个文件夹以及go文件。
我们用任意文本编辑器打开main.go即可。

//这行代码来声明你的文件属于哪一个package,任何一个文件想build的话，必须是main package
package main

//如果你想引用其他package，用import "包名" 来引用package
import "fmt"

//go运行时会首选执行main函数，这个函数既不接受参数，也没有返回值
func main() {
	fmt.Println("Hello,world!")

}

我们可以使用go run 文件名来运行，或者用go bulid生成可执行文件

PS D:\go\src\project_one> go run .\main.go
Hello,world!

---

下面我们来介绍变量

package main

import "fmt"

func main() {
	//用var 变量名 变量类型 来声明一个变量
	var i int
	var s string
	//给变量赋值
	i = 7
	s = "Hello,world!"
	//打印变量
	fmt.Println(i)
	fmt.Println(s)
}

PS D:\go\src\project_one> go run .\main.go
7
Hello,world!

package main

import "fmt"

func main() {
	//还可以使用 变量名:=值 的形式来赋值，但仅限于函数内,go会根据值自动推导类型
	a := "你好，世界！"
	fmt.Println(a)
}

PS D:\go\src\project_one> go run .\main.go
你好，世界！

---

下面介绍go语言的元祖/数组

package main

import "fmt"

func main() {
	//go语言的元祖定义形式 var [元素数量]变量名 类型
	var a [5]int
	fmt.Println(a)
	//使用方式与其他语言的数组类似
	a[0] = 1
	a[1] = 3
	fmt.Println(a)
}

PS D:\go\src\project_one> go run .\main.go
[0 0 0 0 0]
[1 3 0 0 0]

---

数组使用在某些场景下不太方便是不是？go语言在数组的基础上进一步封装，叫做切片。

package main

import "fmt"

func main() {
	s := []string{"北京", "上海"}
	fmt.Println(s)
	//使用append()函数，为切片增加元素
	s = append(s, "广州")
	fmt.Println(s)
	s = append(s, "鄂尔多斯")
	//既然叫切片，那么它当然可以"切"数据
	fmt.Println(s[2:4]) //它是左闭右开区间
}

PS D:\go\src\project_one> go run .\main.go
[北京 上海]
[北京 上海 广州]
[广州 鄂尔多斯]

---

接下来介绍一种键值对形式的数据类型，叫做map

package main

import "fmt"

func main() {
	//使用make()函数来为map分配空间
	info := make(map[string]string)
	//为map添加新项目
	info["name"] = "ekko"
	info["age"] = "18"
	info["gender"] = "male"
	info["class"] = "火箭101"
	//你可以使用delete()函数来删除项目
	delete(info, "class")
	fmt.Println(info)
}

PS D:\go\src\project_one> go run .\main.go
map[age:18 gender:male name:ekko]

---

拥有这些数据，想必大家也想到了遍历

package main

import "fmt"

func main() {
	//使用make()函数来为map分配空间
	info := make(map[string]string)
	//为map添加新项目
	info["name"] = "ekko"
	info["age"] = "18"
	info["gender"] = "male"
	info["class"] = "火箭101"
	//你可以使用delete()函数来删除项目
	delete(info, "class")
	fmt.Println(info)

	//在go语言中，没有while循环
	/*
		for 遍历变量:=初始值;循环条件;迭代变化 {
			循环体...
		}

		可以用这种方式来实现while(两个分号可省略)

		for ;循环条件; {
			循环体...
		}
		还有一种循环
		for k,v := range info {
			循环体...
		}
		下面我们使用第三种循环来遍历map
	*/

	for k, v := range info {
		fmt.Printf("%s-->%s\n", k, v)
	}
	//如果只想要键或值，我们可以将另一个用匿名变量(_)来接收
	for _, v := range info {
		fmt.Println(v)
	}
}

PS D:\go\src\project_one> go run .\main.go
map[age:18 gender:male name:ekko]
age-->18
gender-->male
name-->ekko
ekko
18
male

---

go语言中的函数

package main

import "fmt"

/*
函数的定义形式：func 函数名(参数列表) 返回值 {
	函数体
}
*/
func add(x int, y int) int {
	return x + y
}

func main() {
	x := 11
	y := 55
	result := add(x,y)
	fmt.Println(result)
}

PS D:\go\src\project_one> go run .\main.go
66

---

下面介绍一个非常重要的东西：指针

package main

import "fmt"

//有一定编程经验的小伙伴肯定知道，n自加了一，但是调用者的变量并不会自加
func it(n int) {
	n++
}

//这里我们用一个交换两变量值的小例子来介绍指针
func swap(x, y *int) {
	//交换两变量的值，注意！
	//这里我们用到了指针操作，意味着我们直接操作了内存地址
	//如果不用指针，传进来的值只是副本，所以并不会改变调用者的变量
	t := *x
	*x = *y
	*y = t
}

func main() {
	n := 0
	it(n)
	//这里输出n以后，n的变量依然为0
	fmt.Println(n)

	x := 11
	y := 55
	fmt.Printf("交换前--> x:%d y:%d \n", x, y)
	//&符号用于取变量的地址
	swap(&x, &y)
	fmt.Printf("交换后--> x:%d y:%d \n", x, y)
}

PS D:\go\src\project_one> go run .\main.go
0
交换前--> x:11 y:55
交换后--> x:55 y:11

---

下面我们介绍自定义数据类型以及结构体

package main

import "fmt"

//用 type 关键字可以自定义数据类型
type myFloat float64

/*
用如下形式来定义结构体
结构体是一种复合数据类型，可以把许多类型复合到一起
type 结构体名 struct{

}*/

//下面我们创建一个 person 类型的结构体
type person struct {
	name string
	age  int
}

//用自定义类型的好处就是，可以给自定义类型创建方法
/*
func (变量名 类型名)方法名()[返回值]{
	方法体...
}
*/
func (p person) showInfo() {
	fmt.Printf("%s的年龄是:%d\n", p.name, p.age)
}

func main() {
	//当然，自定义数据类型并不仅仅于此
	var f myFloat
	f = 777.77
	fmt.Println(f)

	//声明一个结构体变量
	p1 := person{
		name: "ekko",
		age:  18,
	}
	fmt.Printf("%#v\n", p1)

	p2 := person{
		name: "fengnoi",
		age:  19,
	}
	//直接用对应方法来打印信息
	p2.showInfo()
}

PS D:\go\src\project_one> go run .\main.go
777.77
main.person{name:"ekko", age:18}
fengnoi的年龄是:19

---

结语：当然，go语言的精髓在于并发处理，但我相信这些基础知识足够读者用来刷题或者写一些简单的小项目了。

最后送大家一句话：