第三章：基本语法 3.数据类型 --Go 语言轻松入门

Go语言（也称为Golang）提供了多种内置的数据类型，这些类型大致可以分为以下几类：基本数据类型、复合数据类型和其他一些特殊类型。下面将详细介绍每种类型：

基本数据类型

1.布尔型 (bool)

• 表示逻辑值，只有两个可能的值：true 和 false。
• 示例：var isActive bool = true

package main

import "fmt"

func main() {
    // 声明并初始化一个布尔变量
    var isActive bool = true
    fmt.Println("isActive:", isActive)

    // 直接声明并赋值
    isEnabled := false
    fmt.Println("isEnabled:", isEnabled)
}

2.数字类型

• 整数类型（int, int8, int16, int32, int64 以及无符号整数 uint, uint8, uint16, uint32, uint64）
  • int 和 uint 的大小取决于平台（通常是32位或64位）。
• 浮点数类型（float32, float64）
  • float32 是单精度浮点数，float64 是双精度浮点数。
• 复数类型（complex64, complex128）
  • 分别基于32位和64位浮点数。

package main

import (
    "fmt"
)

func main() {
    // 声明并初始化整数变量
    var a int = 10
    var b int8 = 127
    var c int16 = 32767
    var d int32 = 2147483647
    var e int64 = 9223372036854775807

    // 无符号整数
    var f uint = 10
    var g uint8 = 255
    var h uint16 = 65535
    var i uint32 = 4294967295
    var j uint64 = 18446744073709551615

    fmt.Println("a:", a)
    fmt.Println("b:", b)
    fmt.Println("c:", c)
    fmt.Println("d:", d)
    fmt.Println("e:", e)
    fmt.Println("f:", f)
    fmt.Println("g:", g)
    fmt.Println("h:", h)
    fmt.Println("i:", i)
    fmt.Println("j:", j)
}

3.字符串 (string)

• 用于存储文本数据。
• 字符串是不可变的字节序列。
• 示例：var greeting string = "Hello, World!"

package main

import (
    "fmt"
)

func main() {
    // 声明并初始化一个字符串
    var greeting string = "Hello, World!"
    fmt.Println(greeting)

    // 使用简短变量声明
    name := "Alice"
    fmt.Println(name)

    // 空字符串
    emptyString := ""
    fmt.Println("Empty String:", emptyString)
}

复合数据类型

1.数组 ([n]T)

• 固定长度的同类型元素集合。
• 示例：var numbers [5]int

package main

import "fmt"

func main() {
    // 声明一个包含5个整数的数组，并初始化为0
    var numbers [5]int
    fmt.Println("Default initialized array:", numbers)

    // 使用字面量初始化数组
    primes := [5]int{2, 3, 5, 7, 11}
    fmt.Println("Array with literal values:", primes)

    // 可以省略长度，编译器会自动推断
    digits := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("Array with inferred length:", digits)
}

2.切片 ([]T)

• 动态数组，可以增长或缩小。
• 实际上是一个指向底层数组的描述符。
• 示例：var list []int

package main

import "fmt"

func main() {
    scores := []int{90, 85, 95, 88, 92}  // 直接用字面量初始化切片
    fmt.Println("Slice with literal values:", scores)
}

3.映射 (map[K]V)

• 无序键值对集合。
• 键必须是可比较的类型。
• 示例：var m map[string]int

package main

import "fmt"

func main() {
    ages := map[string]int{
        "Alice":   30,
        "Bob":     25,
        "Charlie": 35,
    }
    fmt.Println("Map with literal values:", ages)
}

4.结构体 (struct)

• 用户定义的数据类型，包含一个或多个命名字段。

• 可以用来表示更复杂的实体。

• 示例：

  package main
  
  import "fmt"
  
  // 定义一个结构体
  type Person struct {
  	Name string
  	Age  int
  }
  
  func main() {
  	// 使用字面量创建并初始化一个Person实例
  	p1 := Person{Name: "Alice", Age: 30}
  	fmt.Println("Person 1:", p1)
  }

其他类型

1.指针 (*T)

• 存储变量地址。
• 通过 & 获取地址，使用 * 解引用。
• 示例：var p *int = &a

package main

import "fmt"

func main() {
    i := 42
    p := &i  // p 指向 i 的地址
    fmt.Println("Original value of i:", i)

    *p = 20  // 通过指针修改 i 的值
    fmt.Println("Modified value of i:", i)
}

2.接口 (interface{})

• 定义了一组方法签名，任何实现了这些方法的具体类型都可被视为该接口类型的实例。

• 用于实现多态性。

• 示例：

  package main
  
  import (
  	"fmt"
  )
  
  // Writer 接口声明了一个 Write 方法
  type Writer interface {
  	Write(data []byte) (n int, err error)
  }
  
  // MyWriter 是一个实现了 Writer 接口的具体类型
  type MyWriter struct{}
  
  // Write 方法实现了 Writer 接口
  func (mw MyWriter) Write(data []byte) (n int, err error) {
  	fmt.Println("Writing data:", string(data))
  	return len(data), nil // 返回写入的数据长度和错误
  }
  
  func main() {
  	var w Writer = MyWriter{} // MyWriter 实现了 Writer 接口
  	data := []byte("Hello, World!")
  
  	n, err := w.Write(data)
  	if err != nil {
  		fmt.Println("Error writing data:", err)
  	} else {
  		fmt.Printf("Wrote %d bytes\n", n)
  	}
  }

3.函数 (func)

• 函数本身也是一种类型。
• 可以作为参数传递给其他函数，也可以从函数中返回。

package main

import "fmt"

// 定义一个带有两个整数参数但没有返回值的函数
func addNumbers(a int, b int) {
    fmt.Printf("%d + %d = %d\n", a, b, a+b)
}

func main() {
    addNumbers(5, 3)  // 调用函数并传递参数
}

了解这些数据类型对于编写有效的Go程序至关重要。它们为处理各种数据需求提供了灵活而强大的工具集。