Go语言增量式学习3

2024-01-08 13:00:44

Go语言增量式学习3, 又名:Go企业级应用到底层开发(第2天)

PS:这个系列是准备做从go在Web开发,系统编程,云原生应用, 网络编程, 工具和脚本开发, 机器学习,Cgo编程, 还有最后的编译器层级底层的分析, 无盈利模式,所以一键三连是我最大的动力。谢谢~~

目录:

  • Go语言变量作用域
  • Go语言数组
  • Go语言指针
  • Go语言结构体
  • Go语言切片(Slice)
  • Go语言范围(Range)
  • Go语言Map(集合)
  • Go语言递归函数
  • Go语言没有类的定义
  • Go语言接口

1. Go语言变量作用域:

概念:

  • 变量作用域:变量作用域是指变量在程序中可访问的范围。Go语言中有三种变量作用域:局部变量、函数参数、全局变量。

使用场景:

  • 局部变量通常在函数内部声明,只在函数内部可见。
  • 函数参数作用域为整个函数体,参数在函数内部可直接使用。
  • 全局变量作用域为整个程序,可在不同函数中访问,但需要注意避免全局变量滥用。

示例代码(带注释):

package main

import "fmt"

// 全局变量,作用域为整个程序
var globalVar int = 10

func main() {
    // 局部变量,作用域为main函数内部
    localVar := 5
    fmt.Println("局部变量 localVar:", localVar)

    // 函数参数,参数x的作用域为整个函数体
    multiplyByTwo(localVar)
}

func multiplyByTwo(x int) {
    // 可以直接访问函数参数x和全局变量globalVar
    result := x * 2
    fmt.Println("函数内部 result:", result)
    fmt.Println("全局变量 globalVar:", globalVar)
}

2. Go语言数组:

概念:

  • 数组:数组是一种固定长度的数据结构,用于存储相同类型的元素。在Go中,数组的长度是固定的,不能动态增加或减少。

使用场景:

  • 数组适用于需要存储固定数量元素的情况,例如存储一组整数或字符串。
  • 可以通过索引访问数组元素,用于数据的随机访问。

示例代码(带注释):

package main

import "fmt"

func main() {
    // 声明一个包含5个整数的数组
    var numbers [5]int

    // 初始化数组元素
    numbers[0] = 1
    numbers[1] = 2
    numbers[2] = 3
    numbers[3] = 4
    numbers[4] = 5

    // 访问数组元素
    fmt.Println("数组元素:", numbers[2])
}

3. Go语言指针:

概念:

  • 指针:指针是一个存储变量内存地址的变量。通过指针,可以间接访问和修改变量的值。

使用场景:

  • 指针通常用于传递变量的引用,以避免传递变量的副本。
  • 指针可用于动态分配内存、处理数据结构、优化性能等。

示例代码(带注释):

package main

import "fmt"

func main() {
    // 声明一个整数变量
    var x int = 42

    // 声明一个指向整数的指针
    var ptr *int

    // 将x的地址分配给指针ptr
    ptr = &x

    // 通过指针访问变量值
    fmt.Println("x的值:", *ptr)

    // 通过指针修改变量值
    *ptr = 100
    fmt.Println("修改后的x的值:", x)
}

4. Go语言结构体:

概念:

  • 结构体:结构体是一种自定义的数据类型,用于组合多个不同类型的字段。结构体中的字段可以有不同的数据类型。

使用场景:

  • 结构体常用于表示复杂的数据结构,如用户信息、商品信息等。
  • 可以通过创建结构体变量来存储和操作多个字段。

示例代码(带注释):

package main

import "fmt"

// 声明一个名为Person的结构体类型
type Person struct {
    FirstName string
    LastName  string
    Age       int
}

func main() {
    // 创建一个Person类型的结构体变量
    person := Person{
        FirstName: "John",
        LastName:  "Doe",
        Age:       30,
    }

    // 访问结构体字段
    fmt.Println("姓名:", person.FirstName, person.LastName)
    fmt.Println("年龄:", person.Age)
}

5. Go语言切片(Slice):

概念:

  • 切片:切片是一种动态数组,它可以根据需要自动扩展或缩小。切片是对数组的一种抽象,不需要指定固定长度。

使用场景:

  • 切片用于管理可变数量的元素集合,通常用于动态增加或减少数据。
  • 切片提供了强大的操作方法,如追加元素、截取子切片等。

示例代码(带注释):

package main

import "fmt"

func main() {
    // 声明一个整数切片
    var numbers []int

    // 添加元素到切片
    numbers = append(numbers, 1)
    numbers = append(numbers, 2, 3, 4)

    // 访问切片元素
    fmt.Println("切片元素:", numbers)

    // 截取子切片
    subset := numbers[1:3] // 包括索引1,但不包括索引3
    fmt.Println("子切片:", subset)
}

6. Go语言范围(Range):

概念:

  • 范围(Range):范围是Go语言中的一种迭代方式,用于遍历数组、切片、通道、映射和字符串等数据结构。

使用场景:

  • 范围通常用于遍历集合类型的数据,以便对每个元素执行操作。
  • 范围提供了更简洁的迭代语法,避免了手动管理索引。

示例代码(带注释):

package main

import "fmt"

func main() {
    // 使用范围遍历切片
    numbers := []int{1, 2, 3, 4, 5}
    for index, value := range numbers {
        fmt.Printf("索引 %d 的值是 %d\\n", index, value)
    }

    // 使用范围遍历映射
    person := map[string]string{
        "Name":    "John",
        "Country": "USA",
    }
    for key, value := range person {
        fmt.Printf("%s: %s\\n", key, value)
    }
}

7. Go语言Map(集合):

概念:

  • 映射(Map):映射是Go语言中的一种数据结构,用于存储键值对。每个键关联一个值,键必须是唯一的。

使用场景:

  • 映射常用于存储关联性数据,例如存储用户名和密码的键值对。
  • 通过键快速查找值,而不需要遍历整个集合。

示例代码(带注释):

package main

import "fmt"

func main() {
    // 创建一个映射
    scores := make(map[string]int)

    // 添加键值对到映射
    scores["Alice"] = 90
    scores["Bob"] = 85

    // 获取映射的值
    aliceScore := scores["Alice"]
    fmt.Println("Alice的分数:", aliceScore)

    // 删除映射中的键值对
    delete(scores, "Bob")
    fmt.Println("Bob的分数:", scores["Bob"]) // 不存在,返回零值
}

8. Go语言递归函数:

概念:

  • 递归函数:递归函数是一种函数,它可以在函数内部调用自身,通常用于解决可以分解为相似子问题的问题。

使用场景:

  • 递归函数通常用于解决树结构、图形、分治算法等问题。
  • 它们可以将复杂的问题分解为更简单的子问题,以简化解决方案。

示例代码(带注释):

package main

import "fmt"

// 递归函数计算阶乘
func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial(n-1)
}

func main() {
    result := factorial(5)
    fmt.Println("5的阶乘:", result)
}

9. Go语言没有类的定义

Go语言没有传统的类和继承的概念,而是通过结构体(struct)和接口(interface)来实现面向对象编程的特性。

在Go语言中,可以创建结构体来定义自定义类型,然后在结构体中定义字段(属性)和方法(函数)。这些方法可以与结构体关联,实现对结构体的操作。但请注意,Go中的方法并不是与特定的实例相关联的,而是与类型相关联的。

例如,以下是一个简单的结构体定义和方法定义:

package main

import "fmt"

// 定义一个结构体
type Person struct {
    Name string
    Age  int
}

// 定义一个方法,与Person类型相关联
func (p Person) SayHello() {
    fmt.Printf("Hello, my name is %s and I'm %d years old.\\n", p.Name, p.Age)
}

func main() {
    // 创建一个Person对象
    person := Person{Name: "Alice", Age: 30}

    // 调用Person对象的方法
    person.SayHello()
}

虽然Go语言中没有类的概念,但可以使用结构体和方法来实现面向对象编程的思想。另外,Go语言还提供了接口,允许对象通过实现接口来定义其行为,从而实现多态。这种方式使得Go语言能够实现面向对象编程的一些特性,同时保持了简洁性和效率。

10. Go语言接口:

概念:

  • 接口:接口是一种抽象类型,它定义了一组方法的集合,但没有提供方法的具体实现。其他类型可以实现接口的方法集合。

使用场景:

  • 接口用于实现多态和代码复用,允许不同类型的对象执行相同的操作。
  • 可以将接口用于函数参数,以接受不同类型的对象。

示例代码(带注释):

package main

import "fmt"

// 定义一个接口
type Shape interface {
    Area() float64
}

// 实现接口的结构体
type Circle struct {
    Radius float64
}

// Circle类型实现接口方法
func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

// 计算形状的面积
func CalculateArea(s Shape) {
    fmt.Printf("形状的面积是 %.2f\\n", s.Area())
}

func main() {
    // 创建一个Circle对象并计算面积
    circle := Circle{Radius: 5.0}
    CalculateArea(circle)
}

文章来源:https://blog.csdn.net/lixiemang8887/article/details/135344445
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。