跳到主要内容

简单数据类型

字符​

字符型指的是单个字符。在 Go 程序运行时, 字符型会按照 UTF-8 编码转换成数字。

字符型没有专门的关键字来定义, 直接用赋值即可。字符要用单引号。

var a = '中'
fmt.Println(a)  // 返回值 20013

字符的返回时一个数值, 而这个数值是字符'中'转换成UTF-8编码后的十进制数字。要想打印其原始内容, 应该使用打印格式化函数, 或者强制转换成字符串类型。

fmt.Printf("%c", a)   // %c表示格式参数,原始字符
fmt.Println(string(a)) // 将字符转换成字符串

字符串​

Go 语言里的字符串内部实现使用 UTF-8 编码, 其值为 双引号"" 中的内容。字符串内的特殊字符可以通过反斜杠进行转义。

var a1 string = "go"

Go 语言中多行字符串使用 反引号 字符。

反引号内的换行被作为字符串中的换行, 但是反引号表示的字符串会保留原始内容, 包括换行符和其他特殊字符, 不支持任何转义序列。所见及所得。

var a1 string = ` 第一行
第二行
第三行
`

字符串的常用操作

方法描述
len(string)求字符串长度
+ 或 fmt.Sprintf拼接字符串

字符串转义符

转义符描述
\r回车符
\n换行符
\t制表符

整型​

类型描述
uint8无符号8位整型( 0~255 )
uint16无符号16位整型( 0~65535 )
uint32无符号32位整型( 0~4294967295 )
uint64无符号64位整型( 0~18446744073709551615 )
int8有符号8位整型( -128~127 )
int16有符号16位整型( -32768~32767 )
int32有符号32位整型( -2147483648~2147483647 )
int64有符号64位整型( -9223372036854775808~9223372036854775807 )

特殊整型

类型描述
uint32位系统上是uint32, 64位系统上是uint64
int32位系统上是int32, 64位系统上是int64
uintptr无符号整型, 用于存放一个指针

浮点型​

两种浮点型: float32 和 float64

打印浮点数时, 可以使用 fmt 包配合 %f 输出

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Printf("%f\n", math.Pi)    // 3.141593
    fmt.Printf("%.2f\n", math.Pi)  // 3.14
}

复数​

complex64 和 complex128

布尔值​

类型为 bool, 布尔值只有 true(真), falase(假) 两个值。

布尔类型变量的默认值为 false。

布尔值不参与数值运算, 也无法与其他类型进行转换。

数组​

数组类型有三个显著特点: 一是数组中的所有元素存储于连续内存, 二是数组可以直接利用位置索引来访问其中的元素, 三是数组的大小不可变更。

数组的声明, 由于数组大小固定, 因此在声明时必须指定大小。

var 数组变量名 [元素数量]类型

// 定义一个长度为5元素的数组
var a [5]int

数组可以通过索引来访问数组元素, 数组的索引从0开始, 虽然数组的大小不能变更, 但可以通过索引引用元素或改变元素的值。

package main

import "fmt"

func main() {
    a := [5]int{1, 2, 3, 4, 5}
    // 索引位置2的元素
    fmt.Println(a[2])   // 3
    // 为索引位置2的元素重新赋值
    a[2] = 10
    fmt.Println(a)  // [1 2 10 4 5]
}

数组的初始化​

方法一​

初始化列表来设置数组元素的值

var aArray [2]int     // 数组会初始化为int类型的零值 [0, 0]
var bArray = [2]int{1, 2}    // 使用指定值完成初始化  [1, 2]
var cArray = [2]string{"go", "python"}   // ["go", "python"]

方法二​

上述初始化每次都要确保提供的初始值和数组长度一致, 也可以让编译器根据初始值的个数自行判断数组的长度。

var bArray = [...]int{1, 2}
var cArray = [...]string{"go", "python"}
fmt.Printf("类型为 %T\n", bArray)   // 类型为 [2]int
fmt.Printf("类型为 %T\n", cArray)   // 类型为 [2]string

方法三​

通过具体索引来指定元素值

var aArray = [...]int{1:1, 3:4} // 指定索引1的值为1, 索引3的值为4
fmt.Println(aArray)  // [0, 1, 0, 4]

数组的遍历​

用 for 进行遍历

a := [...]string{"go", "python", "java"}
for i := 0; i < len(a); i++ {
    fmt.Println(a[i])
}

用 for range 遍历

a := [...]string{"go", "python", "java"}
for i, v := range a {
    fmt.Println(i, v)
}

多维数组​

多维数组定义

// 以二维数组为例
a := [2][2]string{
    {"go", "python"},
    {"java", "rust"}
}
fmt.Println(a)   // [[go python] [java rust]]
fmt.Println(a[0][0])   // 索引取值 go

多维数组的遍历

a := [2][2]string{
    {"go", "python"},
    {"java", "rust"}
}
for _, v1 := range a {
    for _, v2 := range v1 {
        fmt.Printf("%s\t", v2)   // go python java rust
    }
}

多维数组只有第一层可以使用...来让编译器推导数组长度

a := [...][2]string{
    {"go", "python"},
    {"java", "rust"}
}
fmt.Printf("%T\n", a)   // [2][2]string

数组是值类型​

数组是值类型, 赋值和传参会复制整个数组。因此改变整个传参值并不会改变数组本身的值。

package main

import "fmt"

func modifyArray(a [3]int) {
    a[0] = 100
    fmt.Println(a) // [100 2 3]
}

func main() {
    a := [3]int{1, 2, 3}
    modifyArray(a)
    fmt.Println(a) // [1 2 3]
}