一文带你速通Go语言基础语法-阿里云开发者社区

写在文章开头

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

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

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

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

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

第一行go代码

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

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

// 文件中所有其余代码都属于main包
package main

//导入包
import "fmt"

// main方法，程序运行的入口
func main() {
   
   
    //用fmt包的Println输出一段话
    fmt.Println("hello world")
}

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

hello world

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

fmt包。
数学相关的math包。
字符串操作的strings包。

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

package main

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

func main() {
   
   
    //向下取整
    fmt.Println(math.Floor(2.6))
    //首字母转大写
    fmt.Println(strings.Title("hello go"))
}

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

2
Hello Go

变量扫盲

基本类型

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

数字类型： int、 int8、int16、int32、int64、uint、uint8、uint16、 uint32、uint64 等，其中int为整型，后面跟着的数字代表位数，例如int8即8位(1个字节)的整型，而uint则无符号整型后面数字的含义一样，默认情况下int的字节数由操作系统决定，例如笔者的操作系统为64位，那么int默认就是64/8即8个字节。
字符串类型：string
布尔类型：bool
复数类型： 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))

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

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

再来看看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))
}

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

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

字面量与字符串

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

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

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

func main() {
   
   
    //打印字面量
    fmt.Println('A')
    //打印字符串
    fmt.Println("A")
}

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

65
A

获取变量的类型

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))
}

输出结果如下：

int
float64
int32  
string 
bool

变量赋值

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

import (
    "fmt"
)

func main() {
   
   
    //声明变量
    var num int
    //赋值
    num = 1
    //使用
    fmt.Println(num)
}

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

import (
    "fmt"
)

func main() {
   
   
    //一次声明多变量
    var num, num2 int
    //赋值
    num = 1
    num2 = 2
    //使用
    fmt.Println(num, num2)
}

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

import "fmt"

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

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

func main() {
   
   
    //短变量声明一个int类型
    num := 1
    //打印值
    fmt.Println(num)
    //打印类型
    fmt.Println(reflect.TypeOf(num))
}

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

1
int

变量的默认值

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

func main() {
   
   
    //声明变量并赋值
    var num int
    fmt.Println(num)
    var b1, b2 bool
    fmt.Println(b1, b2)
}

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

0
false false

类型强转

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

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

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

6.4

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

import "fmt"

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

}

条件分支

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")
    }

}

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")
    }

}

循环分支

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

func main() {
   
   

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

    fmt.Println(sum)
}

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

func main() {
   
   

    for {
   
   
        fmt.Println("无限循环")
    }
}

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

func main() {
   
   

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

    fmt.Println(sum)
}

函数

基本语法

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

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

func add(num1 int, num2 int) int {
   
   
    c := num1 + num2
    return c
}

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

func main() {
   
   

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


func add(num1 int, num2 int) (c int) {
   
   
    c = num1 + num2
    return c
}

多返回值

多返回值算是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, "计算成功"
}

对应的输出结果如下：

3
计算成功

Go语言常见命令

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

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

小结

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

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

参考

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

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

写在文章开头

第一行go代码

变量扫盲

基本类型

字面量与字符串

获取变量的类型

变量赋值

变量的默认值

类型强转

条件分支

if语法

switch判断

循环分支

函数

基本语法

多返回值

Go语言常见命令

小结

参考

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

写在文章开头

第一行go代码

变量扫盲

基本类型

字面量与字符串

获取变量的类型

变量赋值

变量的默认值

类型强转

条件分支

if语法

switch判断

循环分支

函数

基本语法

多返回值

Go语言常见命令

小结

参考

热门文章

最新文章

相关课程

相关电子书

相关实验场景