Go语言入门基础语法和常用特性 | 青训营

zoezoe

2024-03-20 帮助5人

Go语言学习

Go（也称为 Golang）是一种开源编程语言，由Google开发并在2009年首次发布。它被设计为一种简单、高效、可靠和并发的系统级编程语言。

以下是一些关于Go语言的主要特点和优势：

简洁易读: Go语言采用简洁的语法和规范，具有较少的关键字和注重可读性的设计风格。它强调代码的清晰性和简洁性，使得代码更易于阅读、理解和维护。
高效编译: Go语言的编译速度非常快，可以在几秒钟内完成大型项目的编译。它采用静态链接，生成独立的可执行文件，无需依赖额外的运行时环境。
并发支持: Go语言内置了并发编程的原语，如goroutine和channel。这使得编写高效、可扩展和并发安全的程序变得容易。Go语言的并发模型是基于CSP（Communication Sequential Processes）的，它简化了并发编程，并提供了轻量级线程（goroutine）和通信机制（channel）。
内存管理: Go语言具有自动垃圾回收机制（Garbage Collection），可以自动管理内存的分配和释放，减轻了开发人员的负担，并提供了更安全的内存管理。
强大的标准库: Go语言拥有丰富而强大的标准库，其中包含了许多常用的功能和工具，如网络编程、并发编程、文件操作、加密等。这些标准库的设计非常简洁并易于使用。
跨平台: Go语言的编译器可以将Go代码编译为机器码，支持多种操作系统和体系结构，如Windows、Linux、macOS、ARM等，从而实现了跨平台的能力。
开发效率: Go语言通过提供简单而强大的工具和语言特性，提高了开发效率。它具有良好的代码组织和结构，支持快速编译、测试和部署。

变量与常量

变量

变量（Variables）是用于存储和操作数据的占位符。在Go语言中，变量需要先声明，然后才能被使用。变量的声明包括变量的名称和类型。

// 声明一个整数类型的变量 
var age int 
// 声明并初始化一个字符串类型的变量 
var name string = "John" 
// 声明多个变量 
var x, y, z int

Go语言还提供了更简洁的声明方式，可以使用 := 运算符进行简单的变量声明和初始化。

// 简化的变量声明与初始化 
age := 25 
name := "John" 
x, y, z := 1, 2, 3

常量

常量（Constants）是程序中固定不变的值。在Go语言中，常量的值在声明时就确定，并且无法被修改。与变量不同，常量在声明时必须进行初始化。

// 声明一个整数类型的常量
const daysInWeek int = 7

// 声明多个常量
const (
	Monday = 1
	Tuesday = 2
	Wednesday = 3
)

Go语言还支持自动推导常量类型的简洁声明方式。

// 简化的常量声明与初始化
const pi = 3.14159
const (
	Monday = 1
	Tuesday = 2
	Wednesday = 3
)

数据类型

1.整数类型（Integer Types） :

int: 有符号整数类型，根据编译器的目标平台可以是 32 位或 64 位。
```
var age int = 25
```

2.浮点数类型（Floating-Point Types）:

float32, float64: 单精度和双精度浮点数类型。
```
   var pi float64 = 3.14159
```

3. 布尔类型（Boolean Type） :

bool: 布尔类型，表示逻辑值，只能是 true 或 false。
```
var isTrue bool = true
```

4. 字符串类型（String Type） :

string: 字符串类型，由一串字符组成。
```
var name string = "John"
```

5. 字符类型（Character Type） :

rune: 代表一个 Unicode 字符。
```
var char rune = 'A'
```

6. 复数类型（Complex Types） :

complex64, complex128: 分别代表 64 位和 128 位复数类型。
```
var c complex128 = 2   3i
```

7. 数组类型（Array Type）:

array: 固定长度的连续元素序列。

var numbers [5]int = [5]int{1, 2, 3, 4, 5}

8. 切片类型（Slice Type） :

slice: 动态长度的元素序列。

var numbers []int = []int{1, 2, 3, 4, 5}

9. 映射类型（Map Type） :

map: 由一组 key-value 对组成的集合。

var person map[string]string = map[string]string{
    "name": "John",
    "age": "25",
}

10. 结构体类型（Struct Type） :

struct: 自定义的复合数据类型，由一组字段组成。

type Person struct {
    Name string
    Age  int
}
var p Person

11. 指针类型（Pointer Type） :

ptr: 存储变量内存地址的数据类型。
```
var x int = 10
var ptr *int = &x
```

基础语法

1. 变量声明

var age int = 25
var name string = "John"

或使用简化的声明方式：

age := 25
name := "John"

2. 条件语句

if语句：

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

switch语句：

switch day {
case "Monday":
    fmt.Println("It's Monday.")
case "Tuesday":
    fmt.Println("It's Tuesday.")
default:
    fmt.Println("It's another day.")
}

3. 循环语句

for循环：

for i := 0; i < 5; i   {
    fmt.Println(i)
}

while循环（使用for循环实现）：

i := 0
for i < 5 {
    fmt.Println(i)
    i  
}

循环的break和continue语句：

for i := 0; i < 5; i   {
    if i == 2 {
        continue  // 跳过当前循环迭代
    }
    if i == 4 {
        break  // 终止整个循环
    }
    fmt.Println(i)
}

4. 函数定义

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

result := add(3, 5)
fmt.Println(result)

5. 数组和切片

数组：

var numbers [5]int = [5]int{1, 2, 3, 4, 5}

切片：

var numbers []int = []int{1, 2, 3, 4, 5}

6. 结构体

type Person struct {
    Name string
    Age  int
}

var p Person
p.Name = "John"
p.Age = 25
fmt.Println(p.Name, p.Age)

7. 包（Package）

package main

import "fmt"

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

上述代码中，package main定义了一个名为main的包。import "fmt"导入了fmt包，用于打印输出。func main()是程序的入口函数，其中fmt.Println("Hello, world!")用于打印输出字符串"Hello, world!"。

8. 指针（Pointer）

package main

import "fmt"

func main() {
    x := 10
    ptr := &x
    fmt.Println("Value of x:", x)
    fmt.Println("Address of x:", ptr)
    fmt.Println("Value stored at ptr:", *ptr)
}

上述代码中，x是一个整数变量，ptr是指向x的指针。通过&操作符获取x的地址，通过*操作符访问指针指向的值。最终打印输出了x的值、地址以及指针指向的值。

9. 结构体（Struct）和方法（Method）

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func (p Person) SayHello() {
    fmt.Println("Hello, my name is", p.Name)
}

func main() {
    p := Person{Name: "Alice", Age: 25}
    p.SayHello()
}

上述代码定义了一个名为Person的结构体，包含了Name和Age两个字段。通过定义一个SayHello的方法，可以在Person类型的实例上调用该方法进行打印输出。在main函数中创建一个Person的实例，并调用SayHello方法进行输出。

10. 接口（Interface）

package main

import "fmt"

type Shape interface {
    Area() float64
}

type Rectangle struct {
    Width  float64
    Height float64
}

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

type Circle struct {
    Radius float64
}

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

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

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

上述代码中，定义了一个Shape接口，包含了一个Area方法。Rectangle和Circle分别实现了该接口的Area方法。PrintArea函数接受一个Shape类型的参数，并调用其Area方法进行输出。在main函数中创建了一个Rectangle和一个Circle的实例，并分别传递给PrintArea函数进行输出。

11. 错误处理（Error Handling）

package main

import (
    "fmt"
    "errors"
)

func Dividend(x, y float64) (float64, error) {
    if y == 0 {
        return 0, errors.New("division by zero")
    }
    return x / y, nil
}

func main() {
    result, err := Dividend(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

上述代码中，定义了一个Dividend函数，用于进行除法运算。如果除数y为零，函数返回一个错误；否则返回计算结果和nil。在main函数中调用Dividend函数，并通过判断错误值来处理可能的错误情况。

常用特性解析

并发编程：Go语言从设计之初就致力于简化并发编程。它内置了goroutine和channel这两个关键概念，使并发编程变得非常简单。goroutine是一种轻量级的执行单元，可以并发执行函数或方法。通过channel实现的通信机制可以安全地在多个goroutine之间传递数据。这些特性使得编写并发程序变得更容易，并且能够充分利用现代计算机的多核性能。
垃圾回收：Go语言使用了自动垃圾回收机制，开发者不需要显式地管理内存分配和回收。垃圾回收器会自动跟踪不再使用的内存，并进行回收，从而减轻了开发者的负担，并且避免了内存泄漏和悬垂指针等问题。
强类型系统：Go语言是一种静态类型的语言，编译器在编译时会进行类型检查，并在运行时对类型进行严格的控制。这有助于提前捕获许多常见的编程错误，并提高代码的健壮性和可维护性。
快速编译：Go语言的编译速度非常快，可以在几秒钟内完成大部分代码的编译。这使得开发者能够快速迭代和测试其代码，加快开发效率。
内置工具：Go语言提供了许多内置工具，例如go build、go test和go fmt等，来帮助开发者进行代码构建、测试和格式化。这些工具的集成简化了开发流程，提高了开发效率。
微服务支持：Go语言在构建微服务架构方面非常流行。轻量级的goroutine和高效的网络库使得开发者可以轻松构建可扩展、高并发的分布式系统。
简洁的语法和标准库：Go语言的语法非常简洁清晰，易于学习和阅读。它的标准库也非常强大，涵盖了许多常见的任务和功能，如文件操作、网络编程、加密解密等。这使得开发者可以快速构建应用程序，而无需依赖第三方库。

这篇好文章是转载于：学新通技术网