Go语言学习：01-基本语法

目录

• 基本语法
  • 源文件构成
  • 数据类型
    • 基本类型变量
    • 数组
    • 切片
      • 创建切片
      • 调整容量
      • 字符串与切片
    • 常量
    • String
    • Map
  • 控制
    • 条件语句
      • if
      • switch
    • 循环语句
  • 函数
    • 函数定义
    • 函数变量
    • 闭包
    • 多值返回
    • defer

基本语法

源文件构成

最简单的一个go程序：

package main

import "fmt"

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

Go源程序由几部分构成：

1. package用于包声明：package main表示一个可独立执行的程序，** Go应用程序必须包含名为main的包**，如果无main包，那么编译器会提示"cannot run non-main package"；
2. import用于导入需要引用的外部包， import "fmt"告诉 Go 编译器这个程序需要使用 fmt 包；
3. func main()是程序的主函数，一般来说都是在启动后第一个执行的函数（如果有init() 函数则会先执行init函数）；
4. 标识符由字母、数字和下划线构成，首字符必须是字母或者下划线，Go语言通过标识符的首字母标识是否可以导出到外部：

• 当标识符以大写字母开头，那么这个标识符就可以被外部包引用，也称为导出，类似于面向对象语言中的public；
• 当标识符以小写字母开头，则对包外是不可见的，类似于面向对象语言中的protected；

数据类型

变量分为值类型和引用类型：

• 值类型：int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向内存中的值；
• 引用类型：引用类型的变量保存的是被引用对象的地址，也就是C语言中的指针。

基本类型变量

Go语言中的变量类型基本涵盖了C语言的基本类型，同时增加指定长度的类型，例如：int8、uint8、int16、uint16、int32、uint32等。

Go语言中有多种定义变量的方法，分别介绍：

1. 定义变量时指定数据类型，格式var v_name v_type，范例：

var varInPackage1 int			// 本地变量，没有赋初始值
var varInPackage2 int = 10		// 本地变量赋初始值为10
var VarInPackage int = 20		// 全局变量赋初始值为20

1. 省略类型，让编译器根据右值推测数据类型：

var intVar = 10
var stringVar = "String"

1. 省略var关键字，通过:=进行赋值，这种定义只能位于函数体内，用于创建局部变量，所以必须确保变量没有被定义过：

intVar := 10
intVar1, strVar = 20, "StrValue"	// 同时定义两个变量
a, _ = 10, 20						// 忽略第二个参数

1. 因式分解方式，一般用于声明全局变量：

var (
    a int
    b bool
)

go语言中变量的作用域与C语言相同。

数组

数组的定义：

var variable_name [SIZE] variable_type

创建数组格式：

var balance1 [10] int32 // 创建一个容量为10的数组
var balance2 = [5]float32{1.0, 2.0, 3.4, 7.0, 5.1}	// 创建一个容量为5的数组，并且赋初始值
var balance3 = [...]float32{1.0, 2.1, 3.4, 7.5, 5.0} // 创建一个数组容量由后面定义的数据决定

切片

切片（slice）是对数组一个连续片段的引用（该数组我们称之为相关数组，通常是匿名的），所以切片是一个引用类型，切记不可用指针指向切片！！

和数组不同的是，切片的长度可以在运行时修改，最小为 0 最大为相关数组的长度：切片是一个 长度可变的数组。

切片的声明格式：

var identifier []type 	// 注意方括号为空

创建切片

切片有几种创建方法：

1. 与特定数组绑定，创建方法为：

var slice1 []type = arr1[start:end]  // arr1为已经创建的数组或者切片

1. 直接创建切片：

var x = []int{2, 3, 5, 7, 11}	// 创建一个长度为5的切片

1. 使用make创建切片：

slice1 := make([]type, len)			// len为切片的初始长度
slice1 := make([]type, len, cap)	// cap为切片初始容量

调整容量

切片可以调整容量，下面的代码用于将sl的容量增加1：

sl = sl[0:len(sl)+1]

下面的将去掉切片的第一个元素：

sl = sl[1:len(sl)]

字符串与切片

Go语言中字符串是常量，不可变。

如果需要修改字符串中的某个数字，则需要将字符串转化成切片后再进行修改。

例如，将字符串 "hello" 转换为 "cello"：

s := "hello"
c := []byte(s)
c[0] = 'c'
s2 := string(c) // s2 == "cello"

常量

通过const关键字创建常量，常量的定义方法与变量类似，差异在于将var替换为const，范例：

const a string = "abc"
const b = "abc"

下面介绍一个特殊的常量iota，可以认为这个是在编译前进由编译器修改的常量。

在一个const组中，首次使用iota时值为0，每使用一次，iota自动加一，这种用法一般作为enum类型使用：

const (
    a = iota	// 首次调用，所以a=0
    b			// 不赋任何值时，就是使用与上一个变量相同的方式赋值，所以这个等价于 b = iota，即使不写iota，编译器默认就是自动调用
    c			// 等价于 c = iota
)

const (
	a1 = iota	// 这是一个新的const组，iota初始值为0，所以a1=0
	a2			// 等价于 a2 = iota
)

String

Go语言提供了strings包，专门处理string类型的数据。

例如：

• strings.Contains()判断字符串中是否包含特定字符串；
• strings.Index()返回特定字符串在指定字符串中的位置；
• ...

文档可以参考：https://studygolang.com/pkgdoc

Map

Map 是一种无序的键值对的集合，Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它，但是Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

map声明方式：

var map_variable map[key_data_type]value_data_type

map 是 引用类型 的： 内存用 make 方法来分配，最简单的初始化：

var map1 = make(map[keytype]valuetype)
var map1 = make(map[keytype]valuetype, cap)	// 指定容量

也可以带初始值方式创建，例如：

mapCreated := map[string]float32{"C0": 16.35, "D0": 18.35}

范例：

var kvs = make(map[string]string)	// 创建一个Map

kvs["AAA"] = "aaa";
kvs["BBB"] = "bbb";

for k,v := range kvs {				// 遍历Map
	fmt.Printf("\tK=%s, V=%s\n", k, v)
}

v,ret := kvs["CCC"]					// 查找map，第一个返回值是key对应的value，第二个返回值是结果
fmt.Printf("\tfind CCC, ret=%d, v=%s\n", ret, v)

控制

条件语句

if

if语句格式与C语言相比，只不过测试表达式不带括号（也可以带括号），其他与C语言相同：

if 测试表达式 {
	/* 在布尔表达式为 true 时执行 */
} else {
	/* 在布尔表达式为 false 时执行 */
}

switch

Go的switch与C的类似，与C的差异在于默认每个case后面自带break语句，如果不需要break，则需要通过fallthrough关键字指明。

范例：

switch marks {
  case 90:
	grade = "A"
  case 80:
  	grade = "B"
  case 50,60,70 :
  	grade = "C"
  	fallthrough		// 表示没有break，相当于接着执行default里面的语句
  default:
  	grade = "D"
}

if和switch还有另外一种写法，支持接受一个初始化参数，格式如下：

if initstatement; condition {}
switch initstatement; condition {}

例如：

if err := file.Chmod(0664); err != nil

循环语句

循环控制：

for init; condition; post { }	// 与C语言相同
for condition { }				// 等同于 while(condition)
for { }							// 等同于 for(;;)

for循环的init/post段不支持通过,分隔多个表达式，如果您需要初始化多个变量时，可以通过下面的方式：

sum := 0
for i,j := 0,100; i<=j; i++ {
	sum += i
}

循环遍历array、slice、string、map时，可以使用range关键字进行控制，range第一个参数返回的是索引，第二个参数返回的是该索引位置的值：

strings := [] string{"string1", "string2", "string last"}
for i,s :=range strings {
	fmt.Printf("\t%d = %s\n", i, s)
}

函数

函数定义

标准函数定义如下：

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

函数的参数同C语言一样，存在值传递和引用传递，引用传递的方式与C语言的指针格式相同：

func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保持 x 地址上的值 */
   *x = *y      /* 将 y 值赋给 x */
   *y = temp    /* 将 temp 值赋给 y */
}

而实际上如果进行swap，还有更简单的方式，例如下面是调换a、b两个变量的值：

a, b = b, a

函数变量

C语言中一般使用函数指针来指向一个函数，Go中可以直接将将函数赋值给变量，该变量就是函数：

// 创建一个函数变量 getSquareRoot
getSquareRoot := func(x float64) float64 {
	return math.Sqrt(x)
}

fmt.Println(getSquareRoot(9))	/* 使用函数 */

闭包

所谓闭包，就是将函数自身使用的数据封装到包中，对外不可见。

参考下面的函数，getSequence函数返回一个函数，被返回的函数中引用了getSequence函数的一个局部变量，所以只要被返回的函数存在，那么getSequence函中的局部变量i就会存在，这个就是相当于将i变量封到了包中，即闭包。

func getSequence() func() int {
   i:=0
   return func() int {
      i+=1		// 这里可以引用getSequence函数中定义的局部变量
     return i
   }
}

nextNumber := getSequence()		// 创建闭包

多值返回

Go语言中一个函数可以返回一个或者多个值，多值返回函数范例：

func swap(x, y string) (string, string) {
   return y, x
}

也可以对返回值参数进行命名，这样就可以在函数体中对返回值参数进行赋值，这个赋值就是相当于设置返回值，范例：

func f(x, y int) (sum int, sub int) {
   sum = x+y
   sub = x-y
   return
}

defer

关键字defer允许我们推迟到函数返回之前执行，如果一个函数存在多个defer语句，那么按照后进先出的顺序执行，即栈的顺序。

例如，下面的代码指定了2个Defer：

func deferFunc() {
	fmt.Printf("Hello here is defer funtion\n");
}

func testDeferFunc() {
	fmt.Printf("print 1\n")
	defer deferFunc()
	defer func() {		// 创建一个匿名函数，并defer执行
		fmt.Printf("Hello here is defer function, inner\n")
	}()
	fmt.Printf("print 2\n")
}

输出结果为：

print 1
print 2
Hello here is defer function, inner
Hello here is defer funtion