禅与计算机
sharkchili
2024-03-08
目录

一文带你速通Go语言基础语法

# 写在文章开头

笔者在很早以前就有通过协程并发编程的概念中了解到Go，自此对Go爱不释手，对于Go语言来说，它有着如下的优势:

  1. 上手快：笔者第一次接触的Go的时候，简单搭建一下环境就直接手撸了一个协程的小工具。
  2. 并发异步无痛点：相较于Java而言，Go的几个并发编程的工具简单易上手，并发编程可以说是轻而易举。
  3. 简单而强大：这一点是读耗子前辈的专栏得到的一个观点，它有着C语言的姿态和python的理念，可以说一门简单而强大的编程语言。
  4. 实用的lib库：很多人都说Go非常适合写一个追求性能的小工具，这一点笔者也是非常同意，在笔者日常写Go代码的时候就有这种感觉，Go语言自带的lib库有着很多实用的工具，基本上无需依靠第三方的轮子就可以简单的功能。

所以就想着要专门出一个系列介绍一下Go这门语言，在上一篇文章我们完成了最基础的环境搭建之后，我们就可以正式的开始写Go代码了。 这篇文章算是一篇基本的语法速通的扫盲，通过这篇文章你将会对Go的语法和一些编程习惯有一个初步的了解和掌握。

一文带你速通Go语言基础语法

Hi，我是sharkChili，是个不断在硬核技术上作死的java coder，是CSDN的博客专家，也是开源项目Java Guide的维护者之一，熟悉Java也会一点Go，偶尔也会在C源码边缘徘徊。写过很多有意思的技术博客，也还在研究并输出技术的路上，希望我的文章对你有帮助，非常欢迎你关注我的公众号：写代码的SharkChili。

# 第一行go代码

以下面这段代码为例，我们介绍以下Go语言的编码基本套路：

  1. 指明运行文件的包为main，只有main包下的文件才会被运行(这一点笔者会在后续的文章中介绍原因)。
  2. 导入需要用到的包，因为我们要输出语句，所以需要导入fmt包(即format包)。
  3. 在main函数里面Println一段话。
// 文件中所有其余代码都属于main包
package main

//导入包
import "fmt"

// main方法，程序运行的入口
func main() {
	//用fmt包的Println输出一段话
	fmt.Println("hello world")
}
1
2
3
4
5
6
7
8
9
10
11
12

完成上述编码之后，我们运行程序，即可在中断上得到打印的输出语句：

hello world
1
2

可以看到当我们需要用到相应的工具就得导入对应的包，然后通过包名.方法即完成方法的调用，与其他语言有所不同，Go语言要导入多个包时需要通过括号包围这些包名，一下面这段代码为例，我们希望打印出2.6向下取整和hello go首字母大写的字符串，那么我们就需要依次导入：

  1. fmt包。
  2. 数学相关的math包。
  3. 字符串操作的strings包。

所以我们的导入包的语法格式如下：

package main

import (
	"fmt"
	"math"
	"strings"
)

func main() {
	//向下取整
	fmt.Println(math.Floor(2.6))
	//首字母转大写
	fmt.Println(strings.Title("hello go"))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

完成后我们运行程序，得到下面这段输出：

2
Hello Go
1
2

# 变量扫盲

# 基本类型

任何一门对于变量都会通过类型来决定内存分配和编译优化，Go语言也一样，总的来说，Go语言大抵有以下几种类型：

  1. 数字类型： int、 int8、int16、int32、int64、uint、uint8、uint16、 uint32、uint64 等，其中int为整型，后面跟着的数字代表位数，例如int8即8位(1个字节)的整型，而uint则无符号整型后面数字的含义一样，默认情况下int的字节数由操作系统决定，例如笔者的操作系统为64位，那么int默认就是64/8即8个字节。
  2. 字符串类型：string
  3. 布尔类型：bool
  4. 复数类型： complex64 、 complex128，complex64即复数类型，这有一些数学的概念，例如下面这段complex64 即实部虚部都是32位浮点数，complex128即实部和虚部都是64位浮点数，左边为实部右边为虚部，这里我们就先简单介绍一下complex64：
	// 使用复数类型 complex64
	var z1 complex64 = 3 + 2i
	fmt.Println("Complex number:", z1)
	fmt.Println("Real part:", real(z1))
	fmt.Println("Imaginary part:", imag(z1))
1
2
3
4
5

输出结果如下，可以看到打印出来的实部为3，虚部为2：

Complex number: (3+2i)
Real part: 3     
Imaginary part: 2
1
2
3
4

再来看看complex128这个类型：

func main() {
	// 使用复数类型 complex128
	var z2 complex128 = 4 + 5i
	fmt.Println("Complex number:", z2)
	fmt.Println("Real part:", real(z2))
	fmt.Println("Imaginary part:", imag(z2))
}
1
2
3
4
5
6
7
8

对应打印结果是一致的，只不过complex128是64位浮点数，精度更高一些：

Complex number: (4+5i)
Real part: 4
Imaginary part: 5
1
2
3
4

# 字面量与字符串

对于Go语言来说，描述字符的有字符串和字面量，而两者的区别是:

  1. 字面量在Go语言中成为rune，是unicode编码，即用ASCII编码表示，所以在打印时会输出数字。
  2. 字符串声明时通过双引号包围，打印时直接输出字符串。

对此我们给出一段代码示例，分别打印字面量和字符串：

func main() {
	//打印字面量
	fmt.Println('A')
	//打印字符串
	fmt.Println("A")
}
1
2
3
4
5
6
7

输出结果如下，可以看到rune用数字表示，而字符串输出的就是字符串:

65
A
1
2
3

# 获取变量的类型

Go语言的reflect包下提供各种反射的操作，其中TypeOf方法可返回变量类型：

func main() {
	//获取变量类型
	fmt.Println(reflect.TypeOf(3))
	fmt.Println(reflect.TypeOf(3.14))
	fmt.Println(reflect.TypeOf('A'))
	fmt.Println(reflect.TypeOf("A"))
	fmt.Println(reflect.TypeOf(false))
}
1
2
3
4
5
6
7
8

输出结果如下：

int
float64
int32  
string 
bool
1
2
3
4
5

# 变量赋值

Go语言对于变量的赋值比较灵活，这里笔者介绍一下最基本的赋值语法，通过var声明变量后，再用等号对变量进行赋值：

import (
	"fmt"
)

func main() {
	//声明变量
	var num int
	//赋值
	num = 1
	//使用
	fmt.Println(num)
}
1
2
3
4
5
6
7
8
9
10
11
12

当然go也支持一次性声明多个变量再赋值:

import (
	"fmt"
)

func main() {
	//一次声明多变量
	var num, num2 int
	//赋值
	num = 1
	num2 = 2
	//使用
	fmt.Println(num, num2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

当然你也可以一次性声明多个变量在进行赋值操作：

import "fmt"

func main() {
	//声明变量并赋值
	var num = 1
	fmt.Println(num)
	var num2, num3 = 2, 3
	fmt.Println(num2, num3)
}
1
2
3
4
5
6
7
8
9

上文笔者说过，Go之所以灵活是因为变量赋值时可以直接通过:=进行变量赋值，让Go语言再编译时获取变量类型完成内存分配和优化的工作：

func main() {
	//短变量声明一个int类型
	num := 1
	//打印值
	fmt.Println(num)
	//打印类型
	fmt.Println(reflect.TypeOf(num))
}
1
2
3
4
5
6
7
8
9

对应的输出结果如下，可以看到对应类型打印是int，可以看出Go语言的短变量声明是非常简单且优雅的：

1
int
1
2

# 变量的默认值

go语言的变量默认有值的，例如数字默认为0，布尔默认为false，其他类型同理，这里笔者简单演示一下没有进行任何赋值操作的int和bool类型默认值的打印代码：

func main() {
	//声明变量并赋值
	var num int
	fmt.Println(num)
	var b1, b2 bool
	fmt.Println(b1, b2)
}
1
2
3
4
5
6
7

可以看到结果和笔者说的一样，整型默认输出0，而bool默认为false：

0
false false
1
2

# 类型强转

与其他的编程语言(Java)有所不同，Go语言对不同的精度数字类型计算时不会进行自动的类型升级，所以在进行整数和小数的运算时，我们需要进行一下强转，强转的语法如下即类型(变量):

func main() {
	//不同类型无法通过编译
	length := 2
	width := 3.2
	//将length强转为float
	lengtnFloat := float64(length)
	fmt.Println(lengtnFloat * width)
}
1
2
3
4
5
6
7
8
9

最终得到正确的计算输出结果:

6.4
1
2

当然如果带小数的类型转为int时，还是需要考虑精度丢失问题，这里笔者就不输出演示了：

import "fmt"

func main() {
	//强转精度丢失问题
	width := 3.6
	fmt.Println(int(width))

}
1
2
3
4
5
6
7
8

# 条件分支

# if语法

与Java和C这类编程语言不同，Go的if语句比较清爽没有括号，直接在if后面带上条件即可：

func main() {
	num := 8
	
	if num < 0 {
		fmt.Println("num < 0")
	} else if num < 5 {
		fmt.Println("num < 5")
	} else {
		fmt.Println("num > 5")
	}

}
1
2
3
4
5
6
7
8
9
10
11
12

# switch判断

和其他编程语言不同的是，Go语言中switch是非常常用的判断，它时常和channel进行配合控制协程调度，这一点笔者会在后续的实际案例中演示，这里先介绍一下switch的语法格式，可以看到go语言的switch也是很清爽的，无需添加break即可完成分支：

func main() {
	num := 3
	
	switch num {
	case 1:
		fmt.Println("num = 1")
	case 2:
		fmt.Println("num = 2")
	case 3:
		fmt.Println("num = 3")
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13

# 循环分支

与其他语言相比Go语言没有while和do-while这种循环，取而代之的都说for循环，下面这个例子我们可以同义转换为while(i<10)这种编程习惯：

func main() {

	i := 0
	sum := 0
	for i < 10 {
		sum += i
		i++
	}

	fmt.Println(sum)
}
1
2
3
4
5
6
7
8
9
10
11

对于那些习惯了Java或者C的开发来说，Go语言的无限循环语法可能会让你感到别扭，语言如下所示，即不带任何条件的for:

func main() {

	for {
		fmt.Println("无限循环")
	}
}
1
2
3
4
5
6
7

唯一让读者感到亲切的应该就是下面这种fori格式的有界循环了，这里笔者就不多做赘述了：

func main() {

	sum := 0
	for i := 0; i < 10; i++ {
		sum += i
	}

	fmt.Println(sum)
}
1
2
3
4
5
6
7
8
9
10

# 函数

# 基本语法

函数的基本语法如下，我们希望传入两个int的值得到一个返回int的函数，Go语言的语法格式如下：

func main() {
	fmt.Println(add(1, 2))
}

func add(num1 int, num2 int) int {
	c := num1 + num2
	return c
}
1
2
3
4
5
6
7
8

不过有时候也可以这样写，看起来没有精简到哪里去，对于笔者而言这种语法基本很少用，读者了解一下即可：

func main() {

	fmt.Println(add(1, 2))
}


func add(num1 int, num2 int) (c int) {
	c = num1 + num2
	return c
}
1
2
3
4
5
6
7
8
9
10

# 多返回值

多返回值算是Go语言让读者感到惊艳的地方了，很多编程语言为了得到多返回值，都会采用传入引用进行复制或者像C这种传入指针的操作，非常不优雅，与之相比，Go语言就比较方便了，只需用括号声明多返回值的列表，然后按需返回多个返回值即可：

func main() {
	sum, str := add(1, 2)
	fmt.Println(sum)
	fmt.Println(str)
}

// add 返回int和string类型的函数
func add(num1 int, num2 int) (int, string) {
	c := num1 + num2
	return c, "计算成功"
}
1
2
3
4
5
6
7
8
9
10
11
12

对应的输出结果如下：

3
计算成功
1
2
3

# Go语言常见命令

一般情况下，我们现在编写Go语言程序都会采用Goland，通过点击界面运行指令，所以对于下面这些常见命令我们需要简单了解一下，便于后续在Linux上操作以及了解Goland的各个界面中提供的指令的含义：

1. go build 将源代码文件编译为二进制文件
2. go run 编译并运行程序，而不保存可执行文件
3. go fmt 使用GO标准格式重新格式化源文件
4. go version 显示当前Go版本号
1
2
3
4

# 小结

这篇Go大基础扫盲的篇章到此为止，希望读者可以通过根据笔者的文章简单实用一下Go语言，笔者会在后续的系列中演示Go各个常用的包及其源码级的原理解析。

我是sharkchili，CSDN Java 领域博客专家，开源项目—JavaGuide contributor，我想写一些有意思的东西，希望对你有帮助，如果你想实时收到我写的硬核的文章也欢迎你关注我的公众号：写代码的SharkChili和笔者的交流群进行深入交流。

# 参考

Head First Go语言程序设计:https://book.douban.com/subject/35237045/ (opens new window) Go语言实战:https://book.douban.com/subject/27015617/ (opens new window)

编辑 (opens new window)
上次更新: 2026/03/26, 01:05:31
Go环境以及IDE安装配置简记
速通Go语言编译过程

← 速通Go语言编译过程→

最近更新
01
基于EasyExcel实现高效导出
03-25
02
从开源框架中学习那些实用的位运算技巧
03-25
03
浅谈分布式架构设计思想和常见优化手段
03-25
更多文章>
Theme by Vdoing | Copyright © 2025-2026 Evan Xu | MIT License | 桂ICP备2024034950号 | 桂公网安备45142202000030
×
×