Go语言学习笔记一

本文最后更新于：2021-11-10 晚上

Go语言的结构

Go语言的基础组成有以下几部分

  • 包声明
  • 引入包
  • 函数
  • 变量
  • 语句&表达式
  • 注释

写一个简单的代码，来看下大致的组成

1
2
3
4
5
6
7
8
package main
//定义了包名，每个程序都包含一个名为main的包
import "fmt"
//告诉GO编译器，这个程序使用了fmt的包
func main() {//程序开始执行的函数
	fmt.Printf("hello world !!!")
    //将字符串输出到控制台
}

执行Go程序

打开编辑器，将上述代码写进去，保存为.go结尾的文件。

然后使用命令行，输入命令

go run hello.go

也可以将其编译成为可执行文件，使用命令

go build hello.go

Go基础语法

Go标记

Go程序可以由多个标记组成，可以是关键字、标识符、常量、字符串、符号。

行分隔符

在Go程序中，一行代表一个语句结束。每个语句不用像C那样以分号结尾，但是如果要将多个语句写在同一行，则必须使用分号，实际开发中，并不建议使用这种方法。

1
2
fmt.print("hello world\n")
fmt.println("i am b1ackie")

注释

注释是不会被编译的，可以使用单行注释和多行注释

1
2
3
4
//这是单行注释
/*
多行注释
*/

标识符

标识符用来命名变量、类型等程序实体。一个标识符可以是一个或多个字母，数字，下划线组成的序列，但是第一个字符必须是字母或者下划线而不可以是数字。

以下这些是有效的标识符：

bLackie B1_ackie _b1ackie

这些是无效的标识符：

  • 1b1ackie（以数字开头）
  • case（GO语言的关键字）
  • a+b（运算符不允许）

字符串连接

Go语言的字符串可以通过+来实现

1
2
3
4
5
package main
import "fmt"
func main() {
	fmt.Println("hello" + "golang")
}

空格

声明变量必须使用空格隔开

var age int

在变量与运算之间也加入空格，使得程序看起来更加的美观

x = a + b

格式化字符串

go字符串格式化符号

格式 描述
%v 按值的本来值输出
%+v 在%v的基础上，对结构体字段名和值进行展开
%#v 输出go语言语法格式的值
%T 输出go语言语法格式的类型和值
%% 输出%本体
%b 整型以二进制方式显示
%o 整型以八进制方式显示
%d 整型以十进制方式显示
%x 整型以十六进制方式显示
%X 整型以十六进制、字母大写方式显示
%U Unicode字符
%f 浮点数
%p 指针、十六进制方式显示 
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package main

import (
	"fmt"
)

type point struct {
	x, y int
}

func main() {
	p := point{1, 2}

	//输出结构体的对象值
	fmt.Printf("%v\n", p)

	fmt.Printf("%+v\n", p)
	fmt.Printf("%#v\n", p)

	//输出一个值得数据类型
	fmt.Printf("%T\n", p)

	//输出布尔类型
	fmt.Printf("%t\n", false)

	//格式化整型，十进制来输出，%ld,%Ld长整型数据；%hd输出短整型
	fmt.Printf("%d\n", 10)

	//二进制方式输出
	fmt.Printf("%b\n", 10)

	//输出数值所对应的ascii字符
	fmt.Printf("%c\n", 0x39)

	//十六进制方式输出
	fmt.Printf("%x\n", 10)

	//输出浮点型数值
	fmt.Printf("%f\n", 10.123)

	//科学计数法
	fmt.Printf("%e\n", 123400000.0)
	fmt.Printf("%E\n", 123400000.0)

	//输出基本的字符串
	fmt.Printf("%s\n", "\"string\"")

	//输出带双引号的字符串
	fmt.Printf("%q\n", "\"string\"")

	fmt.Printf("%x\n", "b1ackie")

	//输出一个指针的值
	fmt.Printf("%p\n", &p)

	//使用%后面的数字来控制输出的宽度，默认输出是右对齐，左边加上空格
	fmt.Printf("|%6d|%6d|\n", 123, 456789)

	//输出宽度，同时指定浮点数
	fmt.Printf("|%5.2f|%5.2f|\n", 1.2, 3.456)
	fmt.Printf("|%4s|%4s|\n", "go", "good")
}

注意

在go中不允许这样写

func main

{

}

只可以这样写

func main{

}

Go数据类型

Go语言按照类别有以下几种数据类型：

类型 描述
布尔型 布尔型的值只可以是常量true或者false。var b bool = true
数字类型 整型int和浮点型float32、float64，go支持整型和浮点型数字，并且支持复数，其中位的运算采用补码
字符串类型 字符串是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本
派生类型 指针类型
数组类型
结构化类型
Channel类型
函数类型
切片类型
接口类型
Map类型

数字类型

类型 描述
uint8 无符号8位整型（0到255）
uint16 无符号16位整型（0到65535）
uint32 无符号32位整型（0到4294967295）
uint64 无符号 64 位整型 (0 到 18446744073709551615)
int8 有符号 8 位整型 (-128 到 127)
int16 有符号 16 位整型 (-32768 到 32767)
int32 有符号 32 位整型 (-2147483648 到 2147483647)
int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

浮点型

类型 描述
float32 IEEE-754 32位浮点型数
float64 IEEE-754 64位浮点型数
complex64 32 位实数和虚数
complex128 64 位实数和虚数

其他数字类型

类型 描述
byte 类似uint8
rune 类似int32
uint 32或64位
int 与int一样大小
uintptr 无符号整型，用于存放一个指针

Go语言变量

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

声明变量是使用var关键字：

var identifier type

可以一次性声明多个变量：

var identifier1, identifier2 type

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func main() {
	var a string = "b1ackie"
	fmt.Println(a)
	var b, c int = 1, 2
	fmt.Println(b, c)
}

变量声明

声明变量有几种方式

1

第一种，指定变量类型，如果没有初始化，则变量默认为零值。

var v_name v_type

v_name = value

零值就是变量没有做初始化时系统默认设置的值

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

import "fmt"

func main() {
	//声明一个变量并初始化
	var a string = "b1ackie"
	fmt.Println(a)

	//声明一个变量，没有初始化，为0值
	var b int
	fmt.Println(b)

	//bool 的0值为false
	var c bool
	fmt.Println(c)
}

  • 数值类型是0
  • 布尔类型为false
  • 字符串为空

2

第二种，根据值自行判断变量类型

var v_name = value

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
	var str = "string"
	fmt.Println(str)

	var num = 1
	fmt.Println(num)

	var flag = true
	fmt.Println(flag)
}

3

第三种，使用:=声明变量

v_name := value

intValue := 1相当于

1
2
var intValue int
intValue = 1

var str string = "b1ackie"可以简写为str := "b1ackie"

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
	str := "b1ackie"
	fmt.Println(str)
}

多变量声明

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

import "fmt"

//这种方式写法一般用于声明全局变量
var (
	a float32
	b bool
)

func main() {
	//类型相同多个变量，非全局变量
	var num1, num2, num3 int

	//自动判断变量类型
	var int1, int2, int3 = 1, 2, 3
	//这种不带声明格式的只能在函数中出现
	c, d := 123, "hello"
	fmt.Println(a, b, c, d)
}

Go语言常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：

const identifier [type] = value

也可以省略type，编译器可以根据变量的值来推断其类型

  • 显示类型定义：const a string = “b1ackie”
  • 隐式类型定义：const a = “b1ackie”

多个相同类型声明可以简写为：

const num1, num2 = value1, value2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func main() {
	const length int = 10
	const width int = 20
	var area int
	area = length * width
	fmt.Printf("the area is %d\n", area)
	const a, b, c = 1, true, "b1ackie"
	fmt.Println(a, b, c)
}

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota在const关键字出现时将被重置为0，const中每新增一行常量声明将使iota计数一次。

iota可以被用作枚举值：

const(

​ a = iota

​ b = iota

​ c = iota

)

第一个iota等于0，每当iota在新的一行被使用时，它的值都会自动加1，所以a=0,b=1,c=2。

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

func main() {
	const (
		a = iota		
		b
		c
		d = "b1ackie"	
		e
		f = 10
		g
		h = iota
		i
	)
	println(a, b, c, d, e, f, g, h, i)
}