Go语言教程

📚 教程目录

查看完整目录 →

2.2 数据类型

2.2 数据类型

Go语言是静态类型语言,每个变量都有明确的类型。本节将详细介绍Go语言的基本数据类型。

基本数据类型概览

Go语言的基本数据类型分为以下几类:

  • 布尔型: bool

  • 整数型: int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64

  • 浮点型: float32, float64

  • 复数型: complex64, complex128

  • 字符串: string

  • 字符型: byte, rune

布尔型 (bool)

布尔型只有两个值:true和false。

package main

import "fmt"

func main() {
    var isActive bool = true
    var isDeleted bool = false
    
    fmt.Println("isActive:", isActive)   // true
    fmt.Println("isDeleted:", isDeleted) // false
    
    // 布尔运算
    fmt.Println("与运算:", isActive && isDeleted)  // false
    fmt.Println("或运算:", isActive || isDeleted)  // true
    fmt.Println("非运算:", !isActive)              // false
}

注意:

  • 布尔型不能与整数类型相互转换

  • 布尔型的零值是false

整数类型

有符号整数

类型 大小 范围
int8 8位 -128 到 127
int16 16位 -32768 到 32767
int32 32位 -2147483648 到 2147483647
int64 64位 -9223372036854775808 到 9223372036854775807
int 32或64位 取决于平台

无符号整数

类型 大小 范围
uint8 8位 0 到 255
uint16 16位 0 到 65535
uint32 32位 0 到 4294967295
uint64 64位 0 到 18446744073709551615
uint 32或64位 取决于平台

特殊整数类型

  • byte: uint8的别名,用于表示字节

  • rune: int32的别名,用于表示Unicode码点

示例

package main

import "fmt"

func main() {
    // 不同类型的整数
    var a int8 = 127
    var b int16 = 32767
    var c int32 = 2147483647
    var d int64 = 9223372036854775807
    
    fmt.Printf("int8: %d\n", a)
    fmt.Printf("int16: %d\n", b)
    fmt.Printf("int32: %d\n", c)
    fmt.Printf("int64: %d\n", d)
    
    // 无符号整数
    var u uint8 = 255
    var v uint16 = 65535
    
    fmt.Printf("uint8: %d\n", u)
    fmt.Printf("uint16: %d\n", v)
    
    // byte和rune
    var ch byte = 'A'
    var r rune = '中'
    
    fmt.Printf("byte: %c (%d)\n", ch, ch)
    fmt.Printf("rune: %c (%d)\n", r, r)
}

浮点类型

Go语言支持两种浮点类型:

  • float32: 32位浮点数,精度约6-7位小数

  • float64: 64位浮点数,精度约15位小数(推荐使用)

package main

import "fmt"

func main() {
    var f32 float32 = 3.14159
    var f64 float64 = 3.141592653589793
    
    fmt.Printf("float32: %.5f\n", f32)
    fmt.Printf("float64: %.15f\n", f64)
    
    // 科学计数法
    var e1 = 1.23e5  // 123000
    var e2 = 1.23e-5 // 0.0000123
    
    fmt.Printf("科学计数法: %f, %f\n", e1, e2)
    
    // 浮点运算
    var a float64 = 10.5
    var b float64 = 3.2
    
    fmt.Printf("加法: %.2f\n", a+b)
    fmt.Printf("减法: %.2f\n", a-b)
    fmt.Printf("乘法: %.2f\n", a*b)
    fmt.Printf("除法: %.2f\n", a/b)
}

复数类型

Go语言原生支持复数:

  • complex64: 实部和虚部都是float32

  • complex128: 实部和虚部都是float64

package main

import "fmt"

func main() {
    // 创建复数
    var c1 complex64 = 1 + 2i
    var c2 complex128 = 3 + 4i
    
    fmt.Println("c1:", c1)
    fmt.Println("c2:", c2)
    
    // 使用complex函数创建
    c3 := complex(5, 6)
    fmt.Println("c3:", c3)
    
    // 获取实部和虚部
    fmt.Println("实部:", real(c3))
    fmt.Println("虚部:", imag(c3))
    
    // 复数运算
    c4 := c2 + complex(1, 1)
    fmt.Println("加法:", c4)
}

字符串类型

字符串是不可变的字节序列。

package main

import "fmt"

func main() {
    // 字符串声明
    var s1 string = "Hello, Go!"
    s2 := "你好，世界！"
    
    fmt.Println(s1)
    fmt.Println(s2)
    
    // 字符串长度
    fmt.Println("s1长度:", len(s1))
    fmt.Println("s2长度:", len(s2)) // 注意：len返回字节数
    
    // 字符串拼接
    s3 := s1 + " " + s2
    fmt.Println(s3)
    
    // 多行字符串
    s4 := `这是一个
多行
字符串`
    fmt.Println(s4)
    
    // 字符串索引
    fmt.Printf("第一个字符: %c\n", s1[0])
    
    // 字符串切片
    fmt.Println("子字符串:", s1[0:5])
}

类型转换

Go语言不支持隐式类型转换,必须显式转换。

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 数值类型转换
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)
    
    fmt.Printf("int: %d, float64: %f, uint: %d\n", i, f, u)
    
    // 整数转字符串
    str1 := strconv.Itoa(i)
    fmt.Println("整数转字符串:", str1)
    
    // 字符串转整数
    str2 := "123"
    num, err := strconv.Atoi(str2)
    if err == nil {
        fmt.Println("字符串转整数:", num)
    }
    
    // 字符串转浮点数
    str3 := "3.14"
    fnum, err := strconv.ParseFloat(str3, 64)
    if err == nil {
        fmt.Println("字符串转浮点数:", fnum)
    }
    
    // 浮点数转字符串
    str4 := strconv.FormatFloat(3.14159, 'f', 2, 64)
    fmt.Println("浮点数转字符串:", str4)
}

类型别名

可以使用type关键字定义类型别名。

package main

import "fmt"

// 定义类型别名
type Age int
type Name string

func main() {
    var age Age = 25
    var name Name = "张三"
    
    fmt.Printf("姓名: %s, 年龄: %d\n", name, age)
}

零值

每种类型都有默认的零值:

package main

import "fmt"

func main() {
    var i int
    var f float64
    var b bool
    var s string
    
    fmt.Printf("int零值: %d\n", i)       // 0
    fmt.Printf("float64零值: %f\n", f)   // 0.000000
    fmt.Printf("bool零值: %t\n", b)      // false
    fmt.Printf("string零值: %q\n", s)    // ""
}

类型推导

使用:=时,Go会自动推导类型。

package main

import "fmt"

func main() {
    // 自动推导为int
    a := 42
    fmt.Printf("a的类型: %T, 值: %d\n", a, a)
    
    // 自动推导为float64
    b := 3.14
    fmt.Printf("b的类型: %T, 值: %f\n", b, b)
    
    // 自动推导为string
    c := "Hello"
    fmt.Printf("c的类型: %T, 值: %s\n", c, c)
    
    // 自动推导为bool
    d := true
    fmt.Printf("d的类型: %T, 值: %t\n", d, d)
}

练习

练习1: 类型转换

编写程序,将整数转换为浮点数,再转换为字符串。

练习2: 温度转换

编写程序,实现摄氏度和华氏度之间的转换。

练习3: 字符串操作

编写程序,统计字符串中的字符数(不是字节数)。

练习4: 复数计算

编写程序,计算两个复数的和、差、积、商。

小结

本节我们学习了:

  • Go语言的基本数据类型

  • 整数、浮点数、复数、布尔型和字符串

  • 类型转换的方法

  • 类型别名的定义

  • 零值的概念

掌握数据类型是编程的基础。下一节,我们将学习运算符。

上一节: 2.1 变量与常量 | 下一节: 2.3 运算符

返回目录 | 返回首页

顶部导航