Go 语言入门指南：基础语法和常用特性解析 | 青训营

Sener2023-07-30 13:35

什么是 Go 语言 ？

Go 语言是一种由 Google 开发的开源编程语言，于2009年首次公开发布。Go 语言的设计目标是提供一种简单、高效、可靠的编程语言，适用于大规模并发和分布式系统的开发。

go语言具有什么特点和优势？

  • 简单易学：Go 语言的语法简洁、清晰，易于学习和阅读。这使得开发者可以更快地上手并编写高质量的代码
  • 高效性：Go 语言的编译速度非常快，而且生成的代码效率也非常高。此外，Go 语言支持并发编程，使得程序可以更加高效地利用多核CPU
  • 可靠性：Go 语言的类型系统非常严格，可以在编译时捕获许多常见的错误。此外，Go 语言还提供了内置的错误处理机制，使得程序可以更加健壮和可靠
  • 并发编程：Go 语言原生支持 goroutine 和 channel 两种并发编程机制，使得编写高效、安全的并发程序变得更加容易
  • 开发效率：Go 语言的标准库提供了许多常用的功能，例如字符串处理、加密、网络编程和图像处理等。此外，Go 语言还拥有一个活跃的社区，提供了许多有用的第三方库和工具，使得开发者可以更加便捷地开发各种应用程序
  • 跨平台性：Go 语言的编译器可以在多种操作系统上运行，包括 Windows、Linux、macOS 等。这使得开发者可以轻松地将程序移植到不同的平台上

Go的基础语法与常用特性解析

让我们以经典的" hello world" 开始

e.g Hello World！

go 复制代码 
package main  
  
import "fmt"  
 
func main() {  
fmt.Println("Hello World!")  
}

1. 注释

在Go中，可以使用两种类型的注释：

  • 单行注释：以//开头，可以在单行中使用。
  • 多行注释：使用/*作为起始，以*/作为结束。可以跨多行使用。
text 复制代码 
// 这是一个单行注释

/*
这是一个多行注释
它可以跨多行使用
*/

2. 包导入

在Go中，使用import关键字导入包。导入的包可以是标准库的包，也可以是自定义的包。

go 复制代码 
import "fmt"      // 导入标准库的fmt包
import "path/to/package"   // 导入自定义包

可以使用圆括号导入多个包：

go 复制代码 
import (
    "fmt"
    "math"
)

3. 变量声明

在Go中，需要先声明变量，然后才能使用。可以使用关键字var来声明变量。

go 复制代码 
var age int                // 声明一个整数类型的变量age
var name string            // 声明一个字符串类型的变量name
var pi float64 = 3.14      // 声明并初始化一个浮点数类型的变量pi

也可以使用短声明方式（仅限于函数内部）：

go 复制代码 
age := 25               // 短声明并初始化一个整数类型的变量age
name := "John"          // 短声明并初始化一个字符串类型的变量name

4. 常量声明

在Go中，使用const关键字来声明常量。常量在声明时必须进行初始化。

go 复制代码 
const pi float64 = 3.14      // 声明一个浮点数类型的常量pi
const daysOfWeek = 7         // 声明一个无类型整数类型的常量daysOfWeek

5. 数据类型

Go语言具有丰富的数据类型，包括基本类型和复合类型。

  • 基本类型 ：包括整数类型（如int、int8、int16等）、浮点数类型（如float32、float64）、布尔类型（bool）、字符串类型（string）等。
go 复制代码 
var age int             // 声明一个整数类型的变量
var pi float64          // 声明一个浮点数类型的变量
var isTrue bool         // 声明一个布尔类型的变量
var name string         // 声明一个字符串类型的变量
  • 复合类型：包括数组、切片、映射、结构体、指针、函数等。
go 复制代码 
var numbers [5]int                        // 声明一个包含5个整数的数组
var colors []string                       // 声明一个字符串切片
var person map[string]string              // 声明一个字符串到字符串的映射
var student struct {                      // 声明一个结构体
    name string
    age int
}
var ptr *int                              // 声明一个整数类型的指针变量
var add func(int, int) int                // 声明一个函数变量

6. 控制流语句

  • 条件语句 ：可以使用if、else if和else关键字进行条件判断。
go 复制代码 
if age >= 18 {                         // 如果age大于等于18
    fmt.Println("成年人")
} else if age >= 12 {                  // 如果age大于等于12
    fmt.Println("青少年")
} else {                               // 否则
    fmt.Println("儿童")
}
  • 循环语句 ：可以使用for关键字进行循环。
go 复制代码 
for i := 0; i < 5; i++ {                 // 执行5次循环
    fmt.Println(i)
}

names := []string{"Alice", "Bob", "Charlie"}
for index, name := range names {        // 迭代切片
    fmt.Println(index, name)
}
  • 选择语句 ：可以使用switch关键字进行多条件选择。
go 复制代码 
day := 3
switch day {
case 1:
    fmt.Println("星期一")
case 2:
    fmt.Println("星期二")
case 3:
    fmt.Println("星期三")
default:
    fmt.Println("其他")
}

7. 函数

在Go中，使用func关键字定义函数。

go 复制代码 
func sayHello() {
    fmt.Println("Hello")
}

func add(a, b int) int {
    return a + b
}

8. 结构体

结构体是一种用户自定义的复合类型，用于封装多个字段。

go 复制代码 
type Person struct {
    name string
    age int
}

func main() {
    p := Person{
        name: "Alice",
        age: 30,
    }
    fmt.Println(p.name, p.age)
}

9. 方法

可以为结构体定义方法，方法是一种与特定类型关联的函数。

go 复制代码 
type Rectangle struct {
    length, width float64
}

func (r Rectangle) area() float64 {
    return r.length * r.width
}

func main() {
    rect := Rectangle{length: 10, width: 5}
    fmt.Println(rect.area())
}

more about Golang ：

1. 数组和切片

  • 数组：数组是具有固定大小的相同类型元素的集合。
go 复制代码 
var numbers [5]int                        // 声明一个包含5个整数的数组
numbers := [5]int{1, 2, 3, 4, 5}           // 创建并初始化一个长度为5的整数数组
  • 切片：切片是一个动态大小的、灵活的视图，可以对数组或其他切片进行操作。
go 复制代码 
var colors []string                       // 声明一个字符串切片
colors := []string{"red", "blue", "green"} // 创建并初始化一个字符串切片

2. 映射

映射是一种无序的键值对集合。

go 复制代码 
var person map[string]string              // 声明一个字符串到字符串的映射
person := make(map[string]string)         // 创建一个空的映射
person["name"] = "Alice"                   // 添加键值对

3. 结构体

结构体是一种用户自定义的复合类型，用于封装多个字段。

go 复制代码 
type Person struct {
    name string
    age  int
}

func main() {
    p := Person{
        name: "Alice",
        age:  30,
    }
    fmt.Println(p.name, p.age)
}

4. 指针

指针是存储变量内存地址的变量。可以使用&操作符获取变量的地址，使用*操作符访问指针指向的值。

go 复制代码 
var age int = 30
var ptr *int = &age        // 声明一个整数类型的指针变量，并初始化为age的地址
fmt.Println(*ptr)          // 输出指针所指向的值

5. 包和可见性

Go中的包用于组织代码。首字母大写的标识符是可导出的，可以在其他包中使用。首字母小写的标识符是私有的，只能在当前包中使用。

go 复制代码 
package main

import (
    "fmt"
    "path/to/package"   // 导入自定义包
)

func main() {
    fmt.Println("Hello, world!")
}

6. defer语句

defer语句用于延迟函数的执行，它会在当前函数返回之前执行。

go 复制代码 
func main() {
    defer fmt.Println("World")
    fmt.Println("Hello")
}
// 输出结果:
// Hello
// World

7. 错误处理

Go中的错误通常显式地使用返回值来表示。可以使用error类型作为函数的最后一个返回值，通过约定将其与其他返回值相关联。而不是使用异常。这提供了一种确保错误得到处理的方法，因为调用者必须显式地检查错误。

go 复制代码 
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

8. 并发编程

Go具有内置的并发机制，可以轻松地编写并发程序。关键字go用于启动一个新的goroutine。

go 复制代码 
func sayHello() {
    fmt.Println("Hello")
}

func main() {
    go sayHello()   // 在新的goroutine中执行sayHello函数
    fmt.Println("World")
}

9. 包管理工具

Go语言使用Go模块作为包管理工具，可以轻松地管理项目中的依赖关系。

  • 初始化模块：
go 复制代码 
go mod init <module_name>
  • 添加依赖：
go 复制代码 
go get <package_name>

10.字符串格式化

Go 提供了强大的字符串格式化功能，主要通过 fmt 包实现。

go 复制代码 
name := "Eve"
age := 28
fmt.Printf("%s is %d years old.\n", name, age)

11.JSON 数据的处理

处理 JSON 是现代应用程序以及编码中的常见任务。Go 提供了简单的编码和解码机制。

go 复制代码 
type Car struct {
    Make  string `json:"make"`
    Model string `json:"model"`
}

myCar := Car{Make: "Toyota", Model: "Corolla"}
carJson, _ := json.Marshal(myCar)
fmt.Println(string(carJson))

12.时间处理

Go 的 time 包提供了日期和时间的表示以及操作。

css 复制代码 
current := time.Now()
fmt.Println(current.Format("Jan 2, 2006 at 3:04pm"))

13.数字解析

Go 可以轻松地将字符串与数字相互解析。

go 复制代码 
str := "12345"
value, err := strconv.Atoi(str)
if err == nil {
    fmt.Println(value + 100)
}

14.Final summary

  1. 简洁而强大的语言特性：Golang以简洁性为核心设计原则之一，它通过精心选择并整合其他语言的特性，使得代码更加清晰、易读、易维护。其中包括静态类型系统、自动垃圾回收、丰富的标准库等。
  2. 并发编程的易用性：Golang在语言级别支持并发编程，通过goroutine和channel的组合，使得编写高效且可扩展的并发程序变得非常容易。Goroutine可以轻松地创建和管理并发任务，而channel则提供了一种通信机制，用于安全地在不同的goroutine之间传递数据。
  3. 内置的错误处理和不一样的异常机制：Golang采用显式的错误处理方式，通过返回error类型来表示函数执行过程中可能出现的错误。这种设计有助于开发者更好地控制程序的流程，并减少意外的异常情况。
  4. 包管理和依赖解决方案：Go模块是Golang的包管理工具，为项目提供了依赖管理和版本控制的能力。它允许开发者明确指定项目所依赖的其他模块，并确保在构建应用程序时使用正确的版本。
  5. 高效的编译和执行效率：Golang的编译器将源代码直接编译为本地机器码，而非解释或虚拟机字节码，因此具有接近原生代码的执行效率。此外，Golang在内存管理、垃圾回收和并发处理方面进行了优化，使得它在高负载和并发环境下表现出色。

总而言之，Golang以其简洁性、并发性和高效性而闻名。它致力于通过提供简单但功能强大的语言特性和工具来改善开发者的生产力和代码可靠性。这使得Golang成为了构建高性能、可伸缩和可靠的应用程序的理想选择。（还是挺好的，就是不是很习惯这个类型后置捏）

  • 最后一条纯属凑数，因为我不喜欢辣个数字QWQ
  • 本文为个人见解，如有错误欢迎指正！
相关推荐
Find24 天前
MaxKB 集成langchain + Vue + PostgreSQL 的 本地大模型+本地知识库 构建私有大模型 | MarsCode AI刷题
青训营笔记
理tan王子24 天前
伴学笔记 AI刷题 14.数组元素之和最小化 | 豆包MarsCode AI刷题
青训营笔记
理tan王子24 天前
伴学笔记 AI刷题 25.DNA序列编辑距离 | 豆包MarsCode AI刷题
青训营笔记
理tan王子24 天前
伴学笔记 AI刷题 9.超市里的货物架调整 | 豆包MarsCode AI刷题
青训营笔记
夭要7夜宵1 个月前
分而治之，主题分片Partition | 豆包MarsCode AI刷题
青训营笔记
三六1 个月前
刷题漫漫路（二）| 豆包MarsCode AI刷题
青训营笔记
tabzzz1 个月前
突破Zustand的局限性：与React ContentAPI搭配使用
前端·青训营笔记
Serendipity5651 个月前
Go 语言入门指南——单元测试 | 豆包MarsCode AI刷题；
青训营笔记
wml1 个月前
前端实践-使用React实现简单代办事项列表 | 豆包MarsCode AI刷题
青训营笔记
用户44710308932421 个月前
详解前端框架中的设计模式 | 豆包MarsCode AI刷题
青训营笔记
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10ARM学习（31）编译器对overlay方式的支持