硬核Go语言学习万字长文之上篇（两篇文章学会Go语言）

1.Go语言介绍

Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。

Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。

Go语言被设计成一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。在高性能分布式系统领域，Go 语言比大多数语言有着更高的开发效率，在云计算时代，它被各大厂商广泛使用。

2.Go运行环境安装

根据自己的系统环境下载相应的版本安装就行，我的是Windows10，就下载go1.19.2.windows-amd64.msi即可。

https://golang.google.cn/dl/

下载之后根据提示安装完成，运行go version可查看版本。

使用Notepad++新建test.go，写入如下代码运行。

package main

import "fmt"

func main() {
   fmt.Println("Hello!")
}

编译运行：go run test.go

生成二进制文件：go build test.go

 

到这里，我们已经成功运行第一个Go程序。为了后续方便，我下载安装了Go语言的代码编辑器GoLand，不像PyCharm有一个社区版，GoLand是收费的，我们只能免费使用一个月。

3.Go语言结构

一个Go程序由包声明、引入包、函数、变量、语句、注释等构成。

package main

import "fmt"

func main() {
   fmt.Println("Hello!")
}

（1）第一行代码 package main 定义了包名，指明这个文件属于哪个包。

（2）第三行代码 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包，这就和Python有点像。

（3）第五行代码 func main() 是程序开始执行的函数。

（4）第六行代码 fmt.Println("Hello!")是将字符串输出到控制台，并自动换行。

4.Go语法

（1）行分隔符

在Go程序中，一行代码代码一个语句结束，它不像Java那样需要分号，也不像Python那样需要缩进。

（2）注释

在Go语言中，单行注释使用//，多行注释使用/*代码块*/。

	//注释
	/*多行注释
	1
	2
	3*/

（3）标识符

标识符用来命名常量、变量、类型、函数名、结构字段等等。它可以由大小写字母、数字、下划线组成，但是需要注意标识符的第一个字符必须是字母或下划线而不能是数字。

（4）字符串连接

Go 语言的字符串连接可以通过 + 实现。

	fmt.Println("aaaa" + "mmm")

（5）数据类型

和其它语言一样，Go也有数据类型，数据类型的出现把数据分成所需内存大小的不同数据，这样我们编程的时候就可以根据需要来选择不同的数据类型，从而申请不同的内存大小，这样就可以充分利用内存，避免浪费。

Go语言常见的数据类型包括：布尔型（值只可以是 true 或 false）、数字类型（整型 int 和浮点型 float32、float64）、字符串类型、派生类型（数组、函数、接口等）。

（6）变量声明

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。

package main

import "fmt"

func main() {
	//第一种，声明一个或多个变量,指定变量类型,不初始化
	var a int
	var b, c string

	a = 100
	b = "aaa"
	c = "ccc"
	fmt.Println(a)
	fmt.Println(b + c)

	//第二种，声明变量,指定变量类型,初始化
	var d string= "ddd"
	fmt.Println(d)

	//第三种，声明变量并初始化，不指定变量类型（根据值自行判定变量类型）
	var e = "ccc"
	fmt.Println(e)

	//第四种，声明变量并初始化，不指定变量类型（根据值自行判定变量类型）,不使用var
	f := "fff"
	fmt.Println(f)
}

（7）常量声明

常量是在程序运行时不会被修改的量，它可以是字符串型、数字型等。

在Go语言中常量声明使用const关键字。

	const defaultPass = "qwer1234"
	const key = "www.key.com123"
	fmt.Println("key=" + key + "defaultPass=" + defaultPass)

（8）运算符

运算符用于在程序运行时执行数学或逻辑运算。

Go语言运算符包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符等。

A.算术运算符：包括加、减、乘、除、求余、自增、自减。

package main

import "fmt"

func main() {
	a,b := 20,3
	fmt.Println(a + b)
	fmt.Println(a - b)
	fmt.Println(a * b)
	fmt.Println(a / b)
	fmt.Println(a % b)
	a++
	fmt.Println(a)
	a--
	fmt.Println(a)
}

B.关系运算符：包括==、!=、>、<、>=、<=。

C.逻辑运算符：

&&：逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。

||：逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。

!：逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。

D.位运算符：包括&、|、 ^ ，对二进制位进行操作。

（9）条件语句

条件语句可以给定一个判断条件，并在程序执行过程中判断该条件是否成立，根据判断结果执行不同的操作，从而改变代码的执行顺序，实现更多的功能。

Go语言中的条件语句主要包括：if 语句、if...else 语句、switch 语句、select 语句等。

package main

import "fmt"

func main() {
	a := 88
	if a > 80 {
		fmt.Println("优秀")
	} else {
		fmt.Println("一般")
	}

	b := 10
	switch b {
	case 5:
		fmt.Println("b进来了，case b=5")
	case 10:
		fmt.Println("b进来了，case b=10")
	case 15:
		fmt.Println("b进来了，case b=15")
	}
}

（10）循环语句

循环语句就是根据循环条件反复执行相同的语句，直到循环条件不成立。

for 循环是一个循环控制结构，可以执行指定次数的循环。

break 语句：经常用于中断当前 for 循环或跳出 switch 语句
continue 语句：跳过当前循环的剩余语句，然后继续进行下一轮循环。

package main

import "fmt"

func main() {
	sum := 0
	for i:=1 ;i <= 10; i++ {
		if i == 5{
			//跳过当前循环执行下一次循环语句
			continue
		}
		if i == 9 {
			//中断当前for循环
			break
		}
		sum = sum + i
		str := fmt.Sprintf("sum=%d,i=%d",sum,i)
		fmt.Println(str)
	}
	fmt.Println(sum)
}

运行结果：

（11）函数

函数是一个代码块，通过它可以划分不同的功能，不仅让代码更加清晰，另外还有利于复用。

Go语言函数声明格式如下：

func function_name( [parameter list] ) [return_types] {
   函数体
}

func：函数由 func 开始声明。
function_name：函数名称。
parameter list：参数列表，参数是可选的，函数可以不包含参数。
return_types：返回类型，返回类型也是可选的，因为有的函数不需要返回值。
函数体：函数定义的代码集合。

package main

import "fmt"

func main() {
	//计算sum = 1+2+3+...+100
	sum := total(100)
	fmt.Println(sum)
}

func total(a int)  int{
	sum := 0
	for i:=1 ;i <= a; i++ {
		sum = sum + i
	}
	return sum
}

（12）变量的作用域

变量的作用域指的是变量的作用范围，可以分为全局变量、局部变量、形式参数。

全局变量：在函数体外声明，作用域是整个包甚至外部包。

局部变量：在函数体内声明，作用域是函数体内。

形式参数：作为函数的局部变量使用。

package main

import "fmt"

//声明全局变量b
var b int =10
func main() {
	//声明局部变量a
	a := 100
	test(a)
}

func test(a int)  {
	fmt.Println(b)
	fmt.Println(a)
}

（13）数组

数组是在程序设计中，为了处理方便把具有相同类型的若干元素按有序的形式组织起来的一种形式，这种类型可以是任意的原始类型如整型、字符串或自定义类型。数组元素可以通过索引（位置）来读取或修改，索引从 0 开始，以此类推。

package main

import "fmt"

func main() {
	//声明了数组arr,长度为3,类型为int
	var arr [3] int
	arr[0] = 11
	arr[1] = 15
	arr[2] = 18
	fmt.Println(arr[1])

	//声明数组,并初始化
	var arr1 = [3]int{88,98,100}
	fmt.Println(arr1[1])

	//声明数组,并初始化,省略var
	arr2 := [3]int{23,41,56}
	fmt.Println(arr2[1])

	//如果数组长度不确定，可以使用...来替代数组的长度，编译器会自行推断
	arr3 := [...]int{11,22,33,44,55}
	fmt.Println(arr3[1])
}