一文带你速通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/

目录
相关文章
|
8天前
|
存储 JSON 监控
Viper,一个Go语言配置管理神器!
Viper 是一个功能强大的 Go 语言配置管理库,支持从多种来源读取配置,包括文件、环境变量、远程配置中心等。本文详细介绍了 Viper 的核心特性和使用方法,包括从本地 YAML 文件和 Consul 远程配置中心读取配置的示例。Viper 的多来源配置、动态配置和轻松集成特性使其成为管理复杂应用配置的理想选择。
28 2
|
6天前
|
Go 索引
go语言中的循环语句
【11月更文挑战第4天】
16 2
|
6天前
|
Go C++
go语言中的条件语句
【11月更文挑战第4天】
19 2
|
10天前
|
程序员 Go
go语言中的控制结构
【11月更文挑战第3天】
87 58
|
9天前
|
监控 Go API
Go语言在微服务架构中的应用实践
在微服务架构的浪潮中,Go语言以其简洁、高效和并发处理能力脱颖而出,成为构建微服务的理想选择。本文将探讨Go语言在微服务架构中的应用实践,包括Go语言的特性如何适应微服务架构的需求,以及在实际开发中如何利用Go语言的特性来提高服务的性能和可维护性。我们将通过一个具体的案例分析,展示Go语言在微服务开发中的优势,并讨论在实际应用中可能遇到的挑战和解决方案。
|
6天前
|
Go
go语言中的 跳转语句
【11月更文挑战第4天】
15 4
|
6天前
|
JSON 安全 Go
Go语言中使用JWT鉴权、Token刷新完整示例,拿去直接用!
本文介绍了如何在 Go 语言中使用 Gin 框架实现 JWT 用户认证和安全保护。JWT(JSON Web Token)是一种轻量、高效的认证与授权解决方案,特别适合微服务架构。文章详细讲解了 JWT 的基本概念、结构以及如何在 Gin 中生成、解析和刷新 JWT。通过示例代码,展示了如何在实际项目中应用 JWT,确保用户身份验证和数据安全。完整代码可在 GitHub 仓库中查看。
29 1
|
10天前
|
Go 数据处理 API
Go语言在微服务架构中的应用与优势
本文摘要采用问答形式,以期提供更直接的信息获取方式。 Q1: 为什么选择Go语言进行微服务开发? A1: Go语言的并发模型、简洁的语法和高效的编译速度使其成为微服务架构的理想选择。 Q2: Go语言在微服务架构中有哪些优势? A2: 主要优势包括高性能、高并发处理能力、简洁的代码和强大的标准库。 Q3: 文章将如何展示Go语言在微服务中的应用? A3: 通过对比其他语言和展示Go语言在实际项目中的应用案例,来说明其在微服务架构中的优势。
|
10天前
|
Go 数据处理 调度
探索Go语言的并发模型:Goroutines与Channels的协同工作
在现代编程语言中,Go语言以其独特的并发模型脱颖而出。本文将深入探讨Go语言中的Goroutines和Channels,这两种机制如何协同工作以实现高效的并发处理。我们将通过实际代码示例,展示如何在Go程序中创建和管理Goroutines,以及如何使用Channels进行Goroutines之间的通信。此外,本文还将讨论在使用这些并发工具时可能遇到的常见问题及其解决方案,旨在为Go语言开发者提供一个全面的并发编程指南。
|
8天前
|
Go 调度 开发者
探索Go语言中的并发模式:goroutine与channel
在本文中,我们将深入探讨Go语言中的核心并发特性——goroutine和channel。不同于传统的并发模型,Go语言的并发机制以其简洁性和高效性著称。本文将通过实际代码示例,展示如何利用goroutine实现轻量级的并发执行,以及如何通过channel安全地在goroutine之间传递数据。摘要部分将概述这些概念,并提示读者本文将提供哪些具体的技术洞见。