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

简介: 本文是关于Go语言的入门介绍,作者因其简洁高效的特性对Go语言情有独钟。文章首先概述了Go语言的优势,包括快速上手、并发编程简单、设计简洁且功能强大,以及丰富的标准库。接着,文章通过示例展示了如何编写和运行Go代码,包括声明包、导入包和输出语句。此外,还介绍了Go的语法基础,如变量类型(数字、字符串、布尔和复数)、变量赋值、类型转换和默认值。文章还涉及条件分支(if和switch)和循环结构(for)。最后,简要提到了Go函数的定义和多返回值特性,以及一些常见的Go命令。作者计划在后续文章中进一步探讨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")
}

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

hello world

可以看到当我们需要用到相应的工具就得导入对应的包,然后通过包名.方法即完成方法的调用,与其他语言有所不同,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"))
}

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

2
Hello Go

变量扫盲

基本类型

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

  1. 数字类型: intint8int16int32int64uintuint8uint16uint32uint64 等,其中int为整型,后面跟着的数字代表位数,例如int8即8位(1个字节)的整型,而uint则无符号整型后面数字的含义一样,默认情况下int的字节数由操作系统决定,例如笔者的操作系统为64位,那么int默认就是64/88个字节
  2. 字符串类型:string
  3. 布尔类型:bool
  4. 复数类型: complex64complex128complex64即复数类型,这有一些数学的概念,例如下面这段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))
}

对应打印结果是一致的,只不过complex12864位浮点数,精度更高一些:

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

字面量与字符串

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

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

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

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语法

JavaC这类编程语言不同,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各个常用的包及其源码级的原理解析。

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

参考

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

目录
相关文章
|
4天前
|
存储 安全 算法
Go语言是如何支持多线程的
【10月更文挑战第21】Go语言是如何支持多线程的
101 72
|
5天前
|
安全 大数据 Go
介绍一下Go语言的并发模型
【10月更文挑战第21】介绍一下Go语言的并发模型
24 14
|
4天前
|
安全 Go 开发者
go语言并发模型
【10月更文挑战第16天】
18 8
|
4天前
|
Java 大数据 Go
Go语言:高效并发的编程新星
【10月更文挑战第21】Go语言:高效并发的编程新星
19 7
|
4天前
|
安全 Java Go
go语言高效切换
【10月更文挑战第16天】
12 5
|
4天前
|
运维 监控 Go
go语言轻量化
【10月更文挑战第16天】
11 3
|
4天前
|
安全 Go 调度
Go语言中的并发编程:解锁高性能程序设计之门####
探索Go语言如何以简洁高效的并发模型,重新定义现代软件开发的边界。本文将深入剖析Goroutines与Channels的工作原理,揭秘它们为何成为实现高并发、高性能应用的关键。跟随我们的旅程,从基础概念到实战技巧,一步步揭开Go并发编程的神秘面纱,让您的代码在多核时代翩翩起舞。 ####
|
5天前
|
Go 调度 开发者
Go语言多线程的优势
【10月更文挑战第15天】
10 4
|
6天前
|
存储 Go 开发者
Go语言中的并发编程与通道机制
本文将探讨Go语言中并发编程的核心概念——goroutine和通道(channel)。我们将从基础开始,解释什么是goroutine以及如何创建和使用它们。然后,我们将深入探讨通道的概念、类型以及如何使用通道在goroutine之间进行通信。最后,我们将通过一个示例来展示如何在实际应用中使用goroutine和通道来实现并发编程。
|
5天前
|
存储 Go 调度
深入理解Go语言的并发模型:goroutine与channel
在这个快速变化的技术世界中,Go语言以其简洁的并发模型脱颖而出。本文将带你穿越Go语言的并发世界,探索goroutine的轻量级特性和channel的同步机制。摘要部分,我们将用一段对话来揭示Go并发模型的魔力,而不是传统的介绍性文字。