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

目录

基本语法

源文件构成

最简单的一个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"  
}

ifswitch还有另外一种写法,支持接受一个初始化参数,格式如下:

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
发表评论

相关文章