Go语言基础语法 ｜ 青训营

痞老板大仙
52 阅读4分钟

Go语言基础语法

Go语言，也被称为Golang，是一种由Google开发的开源编程语言，它具有简洁、高效、并发安全的特点，非常适合用于构建现代化的软件应用。本文将介绍Go语言的基础语法，让您快速入门这门令人愉快的编程语言。

1. Hello, World!

让我们从传统的“Hello, World!”开始，这是学习任何编程语言的第一步。在Go语言中，打印一条消息非常简单：

package main

import "fmt"

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

在这段代码中，package main 表示当前文件属于 main 包，import "fmt" 引入了 fmt 包，该包提供了格式化输入输出的功能。func main() 是程序的入口函数，在程序执行时首先被调用。

2. 变量与数据类型

在Go语言中，声明变量需要指定变量名和类型。例如：

package main

import "fmt"

func main() {
    var message string
    message = "Hello, Go!"

    var num int = 42

    fmt.Println(message)
    fmt.Println(num)
}

上述代码中，我们声明了一个名为 message 的字符串变量，以及一个名为 num 的整数变量。可以看到，Go语言支持在声明变量的同时进行初始化。

3. 控制结构

Go语言支持常见的控制结构，如条件语句和循环语句。

条件语句：

package main

import "fmt"

func main() {
    age := 18

    if age >= 18 {
        fmt.Println("You are an adult.")
    } else {
        fmt.Println("You are a minor.")
    }
}

循环语句：

Go语言中只有一种循环结构——for 循环，但可以通过变换实现不同类型的循环。

package main

import "fmt"

func main() {
    // 基本的for循环
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }

    // 类似于其他语言的while循环
    j := 1
    for j <= 5 {
        fmt.Println(j)
        j++
    }

    // 无限循环
    for {
        fmt.Println("Infinite loop")
        break
    }
}

4. 数组和切片

Go语言中的数组是固定长度的，而切片则是动态长度的。切片在Go语言中非常常用，可以方便地处理集合数据。

数组：

package main

import "fmt"

func main() {
    var numbers [5]int
    numbers[0] = 1
    numbers[1] = 2
    // ...

    fmt.Println(numbers)
}

切片：

package main

import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}
    fmt.Println(nums)

    // 对切片进行切割
    slice := nums[1:3]
    fmt.Println(slice)
}

5. 函数

函数是Go语言中的重要组成部分，可以帮助我们模块化代码并实现可重用性。

package main

import "fmt"

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

func main() {
    result := add(3, 5)
    fmt.Println(result)
}

6. 结构体和方法

结构体允许您定义自己的数据类型，而方法则允许您为这些数据类型添加行为。

package main

import "fmt"

type Rectangle struct {
    width  int
    height int
}

func (r Rectangle) area() int {
    return r.width * r.height
}

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

7. 并发与 Goroutines

Go语言的并发模型基于Goroutines和Channels。Goroutines是轻量级的线程，允许并行执行代码块。

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        time.Sleep(time.Second)
    }
}

func printLetters() {
    for char := 'a'; char <= 'e'; char++ {
        fmt.Println(string(char))
        time.Sleep(time.Second)
    }
}

func main() {
    go printNumbers()
    go printLetters()

    time.Sleep(5 * time.Second)
}

8. 包管理与导入

在Go语言中，代码的组织非常重要，可以将相关的功能模块放在不同的包中，以便于管理和维护。

// math.go
package math

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

// main.go
package main

import (
    "fmt"
    "yourmodule/math"
)

func main() {
    result := math.Add(3, 5)
    fmt.Println(result)
}

9. 错误处理

Go语言鼓励显式处理错误，以确保程序的健壮性和稳定性。

package main

import (
    "fmt"
    "errors"
)

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

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println(result)
}

10. 接口与多态

Go语言中的接口允许您定义方法的契约，然后在不同的类型上实现这些方法，实现多态性。

package main

import "fmt"

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

type Rectangle struct {
    Width  float64
    Height float64
}

func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func PrintArea(s Shape) {
    fmt.Println("Area:", s.Area())
}

func main() {
    circle := Circle{Radius: 5}
    rectangle := Rectangle{Width: 4, Height: 3}

    PrintArea(circle)
    PrintArea(rectangle)
}

11. defer 和 panic/recover

Go语言提供了defer关键字，用于在函数结束时执行一些清理操作，如关闭文件、释放资源等。

package main

import "fmt"

func main() {
    defer fmt.Println("This will be printed last.")
    defer fmt.Println("This will be printed second.")

    fmt.Println("This will be printed first.")
}

此外，Go语言还支持panic和recover，用于处理程序的异常情况。

12. JSON 序列化与反序列化

Go语言内置了对JSON的支持，可以轻松地将结构体序列化为JSON字符串，以及将JSON字符串反序列化为结构体。

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name   string `json:"name"`
    Age    int    `json:"age"`
    Email  string `json:"email,omitempty"`
}

func main() {
    // 序列化为JSON
    p := Person{Name: "Alice", Age: 25}
    data, _ := json.Marshal(p)
    fmt.Println(string(data))

    // 反序列化为结构体
    jsonStr := `{"name":"Bob","age":30}`
    var p2 Person
    json.Unmarshal([]byte(jsonStr), &p2)
    fmt.Println(p2)
}

总结

本文介绍了Go语言的基础语法，包括变量与数据类型、控制结构、数组与切片、函数、结构体与方法、并发、包管理、错误处理、接口与多态、defer和panic/recover、JSON序列化与反序列化等。本文可能还有很多错误，以后会继续修正。

avatar
文章
阅读
粉丝