Golang入门简介与基本语法学习

  • 开发
  • 21

简介

Golang的出现背景

Go语言，或我们通常称之为Golang，它的设计哲学深受其创造者的软件开发经验影响，它旨在实现快速编译、高性能、静态类型检查以及简洁明了的代码风格。

是由Google开发的一个开源编程语言，它首次公布于2009年11月，由Robert Griesemer, Rob Pike, 和 Ken Thompson联合设计。
这三位在计算机科学领域有着不俗的成就，Ken Thompson特别以其对UNIX操作系统和C语言的贡献闻名。
Go语言的诞生是为了解决当时Google内部面临的巨大软件工程问题，主要包括提升软件开发效率、简化大规模的软件系统开发及维护，并且优化多核处理器的并发处理能力。

Go语言摒弃了传统语言的冗余和复杂性，取而代之的是一种更加简单直接的方式来管理依赖和并发，这使得Go语言在现代软件开发中特别受欢迎。
Go以其并发编程模型、内存安全和垃圾回收等特性，为开发者提供了一个既强大又灵活的开发环境。

环境搭建

可以参考我的另一篇文章：Windows环境下Golang开发环境的安装

安装Go语言环境

要开始使用Golang，首先得在你的机器上安装Go编译器和工具链。
Go的官方网站提供了适用于Windows、Mac和Linux系统的安装包。
只需下载对应系统的安装程序，一般而言安装过程中会自动配置好Go的环境变量，安装完成后，你可以在命令行中运行go version来验证安装是否成功。

&nbsp

配置Go环境变量

Go语言的环境变量配置是其工作流的重要部分，GOPATH是最关键的环境变量之一，它定义了你的工作空间位置，是你所有Go语言项目的存放地。
此外，GOROOT环境变量则指向Go语言安装的位置。通常，你需要将$GOPATH/bin添加到PATH环境变量中，这样你就可以从任意位置运行编译后的Go程序了。
（你也可以将安装目录下的bin的文件路径直接添加到PATH环境变量中）

&nbsp

Go开发工具介绍

对于刚入门的Go开发者来说，选择一个合适的开发环境非常重要。
你可以选用文本编辑器如Visual Studio Code或Sublime Text，并配置相应的Go语言插件。

对于需要更全面功能的开发者，JetBrains的GoLand更不错的IDE，它具有代码补全、调试、性能分析等高级功能，不过这是一个收费软件，并且不便宜，你可能需要一些其他方式才能免费使用。

Go的基础结构

Go程序的基本结构

每个Go程序都是由包（package）组成的。最基本的Go程序是由一个名为main的包组成，它包含一个同名的main函数。这个函数是程序开始执行的入口点。所有的Go文件都应该在第一行声明它们所属的包。

包的概念和导入方式

包是Go语言的基本组织单位，每个Go文件开头通过package关键字来声明其包名。当你需要使用其他包中的函数或类型时，可以通过import语句来导入这些包。Go的工具链自带依赖管理，能自动获取远程包。

可执行程序和库文件的区别

在Go语言中，可执行程序和库文件是通过包的类型来区分的。
如果一个包声明为main，编译后将生成一个可执行文件；如果包名不是main，则编译后为库文件，其他程序可以导入并使用其中的代码。

变量与数据类型

变量的声明和初始化

在Go语言中，变量必须先声明再使用。Go提供了多种声明变量的方法，可以使用var关键字进行声明，也可以使用:=进行短变量声明（同时进行声明和初始化）。

package main

import "fmt"

func main() {
    var a int    // 声明一个int型变量a
    a = 10       // 给变量a赋值为10
    var b = 20   // 声明一个int型变量b，并初始化为20
    c := 30      // 短变量声明，同时声明和初始化变量c为30

    fmt.Println(a, b, c) // 输出变量的值
}

Go的基本数据类型

Go语言中有许多内建的数据类型，包括但不限于：

  • 整型（int, int8, int16, int32, int64, uint, uintptr等）
  • 浮点型（float32, float64）
  • 复数类型（complex64, complex128）
  • 布尔型（bool）
  • 字符串（string）
  • 错误类型（error）

这些数据类型支持Go语言强大的系统编程能力，为操作系统级的底层编程提供了支持。

类型转换和别名

在Go语言中，类型之间不会自动转换，必须显式进行类型转换：

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)

    fmt.Println(i, f, u) // 输出：42 42 42

    // 字符串转换为整型
    if intValue, err := strconv.Atoi("42"); err == nil {
        fmt.Println(intValue) // 输出：42
    }
}

Go语言也允许用户通过类型别名来给已存在的数据类型指定一个新名字，增加代码的可读性。

package main

import "fmt"

type Celsius float64    // 为float64起一个别名Celsius，表示摄氏温度
type Fahrenheit float64 // 为float64起一个别名Fahrenheit，表示华氏温度

// CToF 将摄氏温度转换为华氏温度
func CToF(c Celsius) Fahrenheit {
    return Fahrenheit(c*9/5 + 32)
}

func main() {
    var c Celsius = 100
    var f Fahrenheit = CToF(c)

    fmt.Println(c, "C is", f, "F") // 输出：100 C is 212 F
}

接下来，我们来探讨Go中的控制结构。

控制结构

条件判断：if-else, switch-case

在Go语言中，条件判断是通过if-else语句实现的。Go的if语句可以包含一个初始化语句，其作用域被限定在if语句中。

package main

import "fmt"

func main() {
    // 使用if-else进行条件判断
    if num := 9; num < 0 {
        fmt.Println(num, "is negative")
    } else if num < 10 {
        fmt.Println(num, "has 1 digit")
    } else {
        fmt.Println(num, "has multiple digits")
    }

    // 使用switch进行条件判断
    switch num := 7; num {
    case 1:
        fmt.Println("One")
    case 7:
        fmt.Println("Seven")
    default:
        fmt.Println("Unknown Number")
    }
}

循环：for

在Go语言中，所有的循环类型都可以使用for关键字来实现，包括传统的for循环以及类似其他语言中的while和until循环。

package main

import "fmt"

func main() {
    // 像while一样使用for
    sum := 1
    for sum < 1000 {
        sum += sum
    }
    fmt.Println(sum) // 输出: 1024

    // 传统的for循环
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }
}

跳转：break, continue, goto

Go支持在循环中使用break和continue来控制循环的执行。break用来退出循环体，而continue用来跳过当前循环迭代。Go也支持goto语句，但其使用并不被推荐，因为它会使得代码难以理解和维护。

package main

import "fmt"

func main() {
    // 使用break跳出循环
    for i := 0; i < 10; i++ {
        if i > 5 {
            break
        }
        fmt.Println(i)
    }

    // 使用continue跳过某次循环迭代
    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Println(i)
    }

    // 使用goto跳转
    i := 0
loop: // 标签
    if i < 5 {
        fmt.Println(i)
        i++
        goto loop // 跳转到标签位置
    }
}

函数

函数的定义和调用

在Go语言中，函数是一等公民。函数的定义形式为func关键字后跟函数名、参数列表、返回类型和函数体。

package main

import "fmt"

// 定义一个加法函数
func add(x, y int) int {
    return x + y
}

func main() {
    fmt.Println(add(42, 13)) // 调用函数并输出结果
}

参数传递：值传递与引用传递

Go语言中的所有参数传递都是值传递。这意味着在调用函数时，实际上是传递了参数值的一个副本。如果想要在函数内部改变参数的值，必须使用指针。

来来来，接着往下看，看看用指针怎么偷梁换柱，把两个数字给掉个儿：

package main

import "fmt"

// 定义一个交换两个数的函数，这里使用指针来直接修改变量的值
func swap(x *int, y *int) {
    temp := *x
    *x = *y
    *y = temp
}

func main() {
    a := 20
    b := 30
    fmt.Println("交换前 a 和 b 的值：", a, b) // 交换前 a 和 b 的值： 20 30
    swap(&a, &b) // 这里传递的是变量的地址，也就是指向这些变量的指针
    fmt.Println("交换后 a 和 b 的值：", a, b) // 交换后 a 和 b 的值： 30 20
}

我们通过传递变量地址给swap函数，然后在swap函数内部通过指针去改变这些变量的值，这样改动就能在函数外部看到了。这种方式在Go中获取和修改外部变量的常用手法，就是典型的引用传递。

返回值和命名返回值

Go函数不仅可以返回单个值，还可以返回多个值。当你想从函数返回更多的信息时，这个特性就显得非常有用了。此外，Go还支持命名返回值，也就是在函数声明返回值时给它们命名，这样可以增加代码的清晰度。

package main

import "fmt"

// 定义一个分割整数的函数，返回商和余数
func divmod(a, b int) (int, int) {
    quo := a / b // 商
    rem := a % b // 余数
    return quo, rem
}

// 使用命名返回值的方式来返回多个值
func divmodNamed(a, b int) (quo, rem int) {
    quo = a / b // 商
    rem = a % b // 余数
    return // 不需要明确指定返回值，因为已经在函数签名中命名
}

func main() {
    quo, rem := divmod(7, 3)
    fmt.Println("分割7和3得到：商 =", quo, "余数 =", rem) // 分割7和3得到：商 = 2 余数 = 1

    quoNamed, remNamed := divmodNamed(7, 3)
    fmt.Println("命名返回值分割7和3得到：商 =", quoNamed, "余数 =", remNamed) // 命名返回值分割7和3得到：商 = 2 余数 = 1
}

在divmodNamed这个函数里，我们就用到了命名返回值。它在返回的时候，就不用再写返回值的名字了，直接一个return搞定，简洁清晰。

复合类型

这些类型可以把简单的类型组合成复杂的数据结构，主要包括数组、切片、映射（map）、结构体（struct）以及它们的方法。

数组和切片

数组是一个固定长度的序列，而切片则是一个可以动态改变大小的序列。切片比数组更常用，因为它们更灵活。

package main

import "fmt"

func main() {
    // 数组的定义和初始化
    var arr [5]int
    arr[0] = 1
    arr[1] = 2
    // 省略的部分为零值
    
    // 切片的定义和初始化
    slice := []int{1, 2, 3, 4, 5} // 切片字面量
    
    // 切片操作
    fmt.Println(slice[1:3]) // 输出切片的第2个到第4个元素，不包括索引为3的元素
}

映射（map）

映射是一种无序的键值对的集合。Map是使用哈希表实现的。

package main

import "fmt"

func main() {
    // 映射的定义和初始化
    m := make(map[string]int)
    m["k1"] = 7
    m["k2"] = 13
    
    // 访问映射
    fmt.Println("map:", m)
    
    // 删除操作
    delete(m, "k2")
    fmt.Println("map:", m)
}

结构体（struct）和方法

结构体是一种聚合数据类型，它用于将不同或相同类型的数据组织成一个有意义的单元。

package main

import "fmt"

// 定义结构体
type person struct {
    name string
    age  int
}

// 定义结构体的方法
func (p person) sayHello() {
    fmt.Printf("Hi, I'm %s, %d years old.\n", p.name, p.age)
}

func main() {
    // 初始化结构体
    p := person{name: "Jack", age: 23}
    
    // 调用方法
    p.sayHello() // 输出: Hi, I'm Jack, 23 years old.
}

结构体的方法就是那些能够使用该结构体类型的变量或者实例来调用的函数。方法的声明和普通函数类似，只是在方法名前面增加了一个额外的参数，这个参数叫做接收器（receiver），它的类型就是结构体类型。

这些复合类型是Go数据组织的基石，特别是切片和映射，它们在实际开发中运用广泛，可以灵活高效地处理数据集合。结构体通过方法为Go语言提供了面向对象的能力，使得Go能够以更加结构化的方式来处理复杂的数据。

接口

接口在Go中扮演着超级重要的角色，它们让我们的代码更加灵活和模块化。

接口的定义
接口定义了一套方法签名，任何具有这些方法的类型都可以说实现了该接口。

package main

import "fmt"

// 定义一个接口
type Greeter interface {
    greet() string
}

// 实现接口的具体类型
type English struct{}

func (e English) greet() string {
    return "Hello!"
}

// 实现接口的具体类型
type Chinese struct{}

func (c Chinese) greet() string {
    return "你好！"
}

func greetSomeone(g Greeter) {
    fmt.Println(g.greet())
}

func main() {
    var e English
    var c Chinese

    greetSomeone(e) // 输出：Hello!
    greetSomeone(c) // 输出：你好！
}

转换和实现

一个类型可以实现多个接口，而一个接口也可以被多个类型实现。类型转换可以在不同的接口和类型之间进行。

package main

import "fmt"

type Walker interface {
    walk() string
}

type Talker interface {
    talk() string
}

type Human struct{}

func (h Human) walk() string {
    return "I'm walking."
}

func (h Human) talk() string {
    return "I'm talking."
}

func main() {
    var h Human
    
    // Human实现了Walker接口
    var w Walker = h
    fmt.Println(w.walk())

    // Human实现了Talker接口
    var t Talker = h
    fmt.Println(t.talk())
}

接口的组合

接口可以组合其他接口，这样可以很容易地创建出拥有多个方法的新接口。

package main

import "fmt"

type Mover interface {
    move() string
}

type Shaker interface {
    shake() string
}

// Combiner接口组合了Mover和Shaker接口
type Combiner interface {
    Mover
    Shaker
}

type Animal struct{}

func (a Animal) move() string {
    return "Animal is moving."
}

func (a Animal) shake() string {
    return "Animal is shaking."
}

func main() {
    var a Animal

    // Animal实现了Combiner接口
    var c Combiner = a
    fmt.Println(c.move())
    fmt.Println(c.shake())
}

并发编程

Go语言在并发编程方面有着天然的优势，它的设计使得并发变得简单易用。

Go协程（goroutines）

Go协程是轻量级的线程，由Go运行时管理。

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    // 启动一个新的协程
    go say("world")
    // 主协程
    say("hello")
}

通道（channels）

通道是Go语言中的一种类型，专门用来传递数据，以实现不同的协程之间的通信。

package main

import "fmt"

func main() {
    // 创建一个通道
    messages := make(chan string)
    
    // 启动一个新的协程
    go func() { messages <- "ping" }()
    
    // 从通道接收数据
    msg := <-messages
    fmt.Println(msg)
}

sync包的使用

sync包提供了基本的同步原语，如互斥锁。

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup // 用于等待一组协程完成
var counter int

func main() {
    const grs = 2
    
    var mu sync.Mutex // 互斥锁保护计数器
    
    for i := 0; i < grs; i++ {
        wg.Add(1)
        go func() {
            mu.Lock() // 在修改变量之前锁定
            {
                counter++
            }
            mu.Unlock() // 修改后解锁
            wg.Done()
        }()
    }
    
    wg.Wait()
    fmt.Printf("Final Counter: %d\n", counter)
}

错误处理和测试

Go有其独特的错误处理机制。

错误处理机制

在Go中，错误被看作是一种可以预期的结果，而不是异常。

package main

import (
    "errors"
    "fmt"
)

// 错误处理
func doSomething(flag bool) error {
    if !flag {
        // 返回一个错误
        return errors.New("something went wrong")
    }
    return nil
}

func main() {
    err := doSomething(false)
    if err != nil {
        fmt.Println(err)
    }
}

defer、panic和recover

defer用于确保调用在函数结束时发生，panic用于处理不可恢复的错误，recover用于从panic或错误情况中恢复。

package main

import "fmt"

func mayPanic() {
    panic("a problem")
}

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from", r)
        }
    }()
    
    mayPanic()
    
    fmt.Println("After mayPanic()")
}

编写测试用例

Go的测试框架通过编写_test.go文件来实现。

// 文件名：something_test.go
package main

import "testing"

func TestDoSomething(t *testing.T) {
    if err := doSomething(true); err != nil {
        t.Errorf("doSomething(true) should not return error")
    }

    if err := doSomething(false); err == nil {
        t.Errorf("doSomething(false) should return error")
    }
}

推荐几个 Golang 学习的文章

Go项目实践

在实际的项目开发中，有一些最佳实践需要遵守。

项目结构规范

遵守一定的目录结构和命名规范，比如使用cmd/和pkg/目录来区分命令行应用和库代码。

依赖管理

使用go mod来管理项目依赖。

go mod init github.com/my/repo
go build
go test

实战Demo

创建一个小的应用或者库来练习上述的概念和工具的使用。

package main

import "fmt"

func main() {
    fmt.Println("This is a simple Go project demo.")
}

这里只是简单介绍了Go项目实践的一些基础，但实际上，项目会涉及到更多的内容，比如代码审查、持续集成（CI）、文档编写等等。这些整合起来，才能够保证一个项目的质量和维护性。

最后说一句(求关注，求赞，别白嫖我)

最近无意间获得一份阿里大佬写的刷题笔记和面经，一下子打通了我的任督二脉，进大厂原来没那么难。

这是大佬写的，7701页的阿里大佬写的刷题笔记，让我offer拿到手软

求一键三连：点赞、分享、收藏

点赞对我真的非常重要！在线求赞，加个关注我会非常感激！@小郑说编程

阅读全部

相关推荐

  2. Golang学习之路一二基础语法与变量

    2024-03-11 18:48:03       38 阅读

  5. Spring Cloud Alibaba Gateway 入门：简介与基本配置教程

    2024-03-11 18:48:03       12 阅读

  7. Python语言基础（简单入门）

    2024-03-11 18:48:03       14 阅读

  9. Python基础入门：语法与数据类型

    2024-03-11 18:48:03       41 阅读

最近更新

  4. TCP协议是安全的吗?

    2024-03-11 18:48:03       18 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2024-03-11 18:48:03       19 阅读

  13. 【Python教程】压缩PDF文件大小

    2024-03-11 18:48:03       19 阅读

  18. 通过文章id递归查询所有评论（xml）

    2024-03-11 18:48:03       20 阅读

热门阅读

  3. Spring Cloud Gateway核心之Filter、自定义全局Filter、自定义局部Filter介绍

    2024-03-11 18:48:03       22 阅读

  4. OrangePiLinux连接小米手机使用adb显示“List of devices attached”的问题解决

    2024-03-11 18:48:03       24 阅读
  6. HAproxy

    HAproxy

    2024-03-11 18:48:03      22 阅读

  12. uniapp聊天页面之消息滚动

    2024-03-11 18:48:03       20 阅读

  13. 大数据开发（Hadoop面试真题-卷九）

    2024-03-11 18:48:03       22 阅读

  16. LeetCode104 二叉树的最大深度

    2024-03-11 18:48:03       21 阅读

  19. 01.AJAX 概念和 axios 使用

    2024-03-11 18:48:03       22 阅读

  20. Spring中SmartInitializingSingleton、SmartLifecycle和Lifecycle的作用和区别

    2024-03-11 18:48:03       20 阅读

  25. K8S Service

    2024-03-11 18:48:03       26 阅读

  26. Linux进程初步理解

    2024-03-11 18:48:03       26 阅读

  27. SpringBoot中事务

    2024-03-11 18:48:03       26 阅读

  29. Android10禁用wifi随机mac地址，固定mac地址

    2024-03-11 18:48:03       22 阅读

  30. 小蓝的钥匙（蓝桥杯错排）

    2024-03-11 18:48:03       24 阅读