4.Golang数据类型

野尘lxw · · 1072 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

Go 语言数据类型包含基础类型和复合类型两大类。
基础数据类型包括:布尔型、整型、浮点型、复数型、字符型、字符串型、错误类型。
复合数据类型包括:指针、数组、切片、字典、通道、结构体、接口。

Go 语言在声明变量时会默认给变量赋个当前类型的空值,声明变量的方式:

声明方式 说明
var 变量名 <变量类型> 声明单个变量
var 变量名1, 变量名2,... <变量类型> 声明多个同类型变量
变量名 := 值 声明变量,并赋值;Go 语言会根据所赋值推断变量的类型
变量名1, 变量名2,... := 值1, 值2,... 声明多个同类型变量并赋值,几个变量必须赋几个值

一、布尔类型 (bool)
值:true 和 false,默认值为 false

package main

import "fmt"

func main() {
    var v1, v2 bool         // 声明变量,默认值为 false
    v1 = true               // 赋值
    v3, v4 := false, true   // 声明并赋值

    fmt.Print("v1:", v1)   // v1 输出 true
    fmt.Print("\nv2:", v2) // v2 没有重新赋值,显示默认值:false
    fmt.Print("\nv3:", v3) // v3 false
    fmt.Print("\nv4:", v4) // v4 true
}

二、数字类型
数字类型比较多,默认值都是 0。定义int类型时,默认根据系统类型设置取值范围,32位系统与int32的值范围相同,64位系统与int64的值范围相同。见下表:

类型 名称 存储空间 值范围 数据级别
uint8 无符号8位整形 8-bit 0 ~ 255
uint16 无符号16位整形 16-bit 0 ~65535 6万多
uint32 无符号32位整形 32-bit 0 ~ 4294967295 40多亿
uint64 无符号64位整形 64-bit 0 ~ 18446744073709551615 死了都不会溢出
int8 8位整形 8-bit -128 ~ 127 正负百
int16 16位整形 16-bit -32768 ~ 32767 正负3万多
int32 32位整形 32-bit -2147483648 ~ 2147483647 正负20多亿
int64 64位整形 64-bit -9223372036854775808 ~ 9223372036854775807 正负大到没概念
int 系统决定 系统决定 32位系统为int32的值范围,64位系统为int64的值范围
-
float32 32位浮点数 32-bit IEEE-754 1.401298464324817070923729583289916131280e-45 ~ 3.402823466385288598117041834516925440e+38 精度6位小数
float64 64位浮点数 64-bit IEEE-754 4.940656458412465441765687928682213723651e-324 ~ 1.797693134862315708145274237317043567981e+308 精度15位小数
-
complex64 复数,含 float32 位实数和 float32 位虚数 64-bit 实数、虚数的取值范围对应 float32
complex128 复数,含 float64 位实数和 float64 位虚数 128-bit 实数、虚数的取值范围对应 float64
-
byte 字符型,unit8 别名 8-bit 表示 UTF-8 字符串的单个字节的值,对应 ASCII 码的字符值
rune 字符型,int32 别名 32-bit 表示 单个 Unicode 字符
uintptr 无符号整型 由系统决定 能存放指针地址即可
package main

import "fmt"

func main() {
    // 无符号整形,默认值都是0
    var u8 uint8
    var u16 uint16
    var u32 uint32
    var u64 uint64
    fmt.Printf("u8: %d, u16: %d, u32: %d, u64: %d\n", u8, u16, u32, u64) // 默认值都为0
    u8 = 255
    u16 = 65535
    u32 = 4294967295
    u64 = 18446744073709551615
    fmt.Printf("u8: %d, u16: %d, u32: %d, u64: %d\n", u8, u16, u32, u64)

    // 整型
    var i8 int8
    var i16 int16
    var i32 int32
    var i64 int64
    fmt.Printf("i8: %d, i16: %d, i32: %d, i64: %d\n", i8, i16, i32, i64) // 默认值都为0
    i8 = 127
    i16 = 32767
    i32 = 2147483647
    i64 = 9223372036854775807
    fmt.Printf("i8: %d, i16: %d, i32: %d, i64: %d\n", i8, i16, i32, i64)

    // int 型,取值范围32位系统为 int32,64位系统为 int64,取值相同但为不同类型
    var i int
    //i = i32 // 报错,编译不通过,类型不同
    //i = i64 // 报错,编译不通过,类型不同
    i = -9223372036854775808
    fmt.Println("i: ", i)

    // 浮点型,f32精度6位小数,f64位精度15位小数
    var f32 float32
    var f64 float64
    fmt.Printf("f32: %f, f64: %f\n", f32, f64) // 默认值都为 0.000000
    f32 = 1.12345678
    f64 = 1.12345678901234567
    fmt.Printf("f32: %v, f64: %v\n", f32, f64) // 末位四舍五入,输出:f32: 1.1234568, f64: 1.1234567890123457

    // 复数型
    var c64 complex64
    var c128 complex128
    fmt.Printf("c64: %v, c128: %v\n", c64, c128) // 实数、虚数的默认值都为0
    c64 = 1.12345678 + 1.12345678i
    c128 = 2.1234567890123456 + 2.1234567890123456i
    fmt.Printf("c64: %v, c128: %v\n", c64, c128) // 输出:c64: (1.1234568+1.1234568i), c128: (2.1234567890123457+2.1234567890123457i)

    // 字符型
    var b byte                                       // uint8 别名
    var r1, r2 rune                                  // uint16 别名
    fmt.Printf("b: %v, r1: %v, r2: %v\n", b, r1, r2) // 默认值为0
    b = 'a'
    r1 = 'b'
    r2 = '字'
    fmt.Printf("b: %v, r1: %v, r2: %v\n", b, r1, r2) // 输出:b: 97(ASCII表示的数), r1: 98(utf-8表示的数), r2: 23383 (utf-8表示的数)

    b = u8
    r1 = i32
    fmt.Printf("b: %v, r1: %v\n", b, r1) // 输出:b: 255, r1: 2147483647

    // 指针地址
    var p uintptr
    fmt.Printf("p: %v\n", p) // 默认值为0
    p = 18446744073709551615 // 64位系统最大值
    //p = 18446744073709551616 // 报错:超出最大值
    fmt.Printf("p: %v\n", p)

}

三、字符串 (string)
Go 语言默认编码都是 UTF-8。

package main

import "fmt"

func main() {
    var str1 string // 默认值为空字符串 ""
    str1 = `hello world`
    str2 := "你好世界"

    str := str1 + " " + str2 // 字符串连接
    fmt.Println(str1)
    fmt.Println(str2)
    fmt.Println(str) // 输出:hello world 你好世界

    // 遍历字符串
    l := len(str)
    for i := 0; i < l; i++ {
        chr := str[i]
        fmt.Println(i, chr) // 输出字符对应的编码数字
    }
}

四、指针(pointer)
指针其实就是指向一个对象(任何一种类型数据、包括指针本身)的地址值,对指针的操作都会映射到指针所指的对象上。

package main

import (
    "fmt"
)

func main() {
    var p *int // 定义指向int型的指针,默认值为空:nil

    // nil指针不指向任何有效存储地址,操作系统默认不能访问
    //fmt.Printf("%x\n", *p) // 编译报错

    var a int = 10
    p = &a        // 取地址
    add := a + *p // 取值

    fmt.Println(a)   // 输出:10
    fmt.Println(p)   // 输出:0xc0420080b8
    fmt.Println(add) // 输出:20
}

五、数组(array)
数组为一组相同数据类型数据的集合,数组定义后大小固定,不能更改,每个元素称为element,声明的数组元素默认值都是对应类型的0值。而且数组在Go语言中是一个值类型(value type),所有值类型变量在赋值和作为参数传递时都会产生一次复制动作,即对原值的拷贝。

package main

import "fmt"

func main() {
    // 1.声明后赋值
    // var <数组名称> [<数组长度>]<数组元素>
    var arr [2]int   // 数组元素的默认值都是 0
    fmt.Println(arr) // 输出:[0 0]
    arr[0] = 1
    arr[1] = 2
    fmt.Println(arr) // 输出:[1 2]

    // 2.声明并赋值
    // var <数组名称> = [<数组长度>]<数组元素>{元素1,元素2,...}
    var intArr = [2]int{1, 2}
    strArr := [3]string{`aa`, `bb`, `cc`}
    fmt.Println(intArr) // 输出:[1 2]
    fmt.Println(strArr) // 输出:[aa bb cc]

    // 3.声明时不设定大小,赋值后语言本身会计算数组大小
    // var <数组名称> [<数组长度>]<数组元素> = [...]<元素类型>{元素1,元素2,...}
    var arr1 = [...]int{1, 2}
    arr2 := [...]int{1, 2, 3}
    fmt.Println(arr1) // 输出:[1 2]
    fmt.Println(arr2) // 输出:[1 2 3]
    //arr1[2] = 3 // 编译报错,数组大小已设定为2

    // 4.声明时不设定大小,赋值时指定索引
    // var <数组名称> [<数组长度>]<数组元素> = [...]<元素类型>{索引1:元素1,索引2:元素2,...}
    var arr3 = [...]int{1: 22, 0: 11, 2: 33}
    arr4 := [...]string{2: "cc", 1: "bb", 0: "aa"}
    fmt.Println(arr3) // 输出:[11 22 33]
    fmt.Println(arr4) // 输出:[aa bb cc]

    // 遍历数组
    for i := 0; i < len(arr4); i++ {
        v := arr4[i]
        fmt.Printf("i:%d, value:%s\n", i, v)
    }
}

六、切片(slice)
因为数组的长度定义后不可修改,所以需要切片来处理可变长数组数据。切片可以看作是一个可变长的数组,是一个引用类型。它包含三个数据:1.指向数组的指针,2.切片中的元素,3.切片的大小
声明一个切片,或从数组中取一段作为切片数据:

package main

import "fmt"

func main() {
    var sl []int             // 声明一个切片
    sl = append(sl, 1, 2, 3) // 往切片中追加值
    fmt.Println(sl)          // 输出:[1 2 3]

    var arr = [5]int{1, 2, 3, 4, 5} // 初始化一个数组
    var sl1 = arr[0:2]              // 冒号:左边为起始位(包含起始位数据),右边为结束位(不包含结束位数据);不填则默认为头或尾
    var sl2 = arr[3:]
    var sl3 = arr[:5]

    fmt.Println(sl1) // 输出:[1 2]
    fmt.Println(sl2) // 输出:[4 5]
    fmt.Println(sl3) // 输出:[1 2 3 4 5]

    sl1 = append(sl1, 11, 22) // 追加元素
    fmt.Println(sl1)          // 输出:[1 2 11 22]
}

使用make直接创建切片,语法:make([]类型, 大小,预留空间大小)

package main

import "fmt"

func main() {
    var sl1 = make([]int, 5)          // 定义元素个数为5的切片
    sl2 := make([]int, 5, 10)         // 定义元素个数5的切片,并预留10个元素的存储空间(预留空间不知道有什么用?)
    sl3 := []string{`aa`, `bb`, `cc`} // 直接创建并初始化包含3个元素的数组切片

    fmt.Println(sl1, len(sl1)) // 输出:[0 0 0 0 0] 5
    fmt.Println(sl2, len(sl2)) // 输出:[0 0 0 0 0] 5
    fmt.Println(sl3, len(sl3)) // [aa bb cc] 3

    sl1[1] = 1 // 声明或初始化大小中的数据,可以指定赋值
    sl1[4] = 4
    //sl1[5] = 5 // 编译报错,超出定义大小
    sl1 = append(sl1, 5)       // 可以追加元素
    fmt.Println(sl1, len(sl1)) // 输出:[0 1 0 0 4 5] 6

    sl2[1] = 1
    sl2 = append(sl2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
    fmt.Println(sl2, len(sl2)) // 输出:[0 1 0 0 0 1 2 3 4 5 6 7 8 9 10 11] 16

    // 遍历切片
    for i := 0; i < len(sl2); i++ {
        v := sl2[i]
        fmt.Printf("i: %d, value:%d \n", i, v)
    }
}

七、字典(map)
map 是一种键值对的无序集合,与 slice 类似也是一个引用类型。map 本身其实是个指针,指向内存中的某个空间。
声明方式与数组类似,声明方式:var 变量名 map[key类型]值类型 或直接使用 make 函数初始化:make(map[key类型]值类型)
其中key值可以是任何可以用==判断的值类型,对应的值类型没有要求。

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // 声明后赋值
    var m map[int]string
    fmt.Println(m) // 输出空的map:map[]
    //m[1] = `aa`    // 向未初始化的map中赋值报错:panic: assignment to entry in nil map

    // 声明并初始化,初始化使用{} 或 make 函数(创建类型并分配空间)
    var m1 = map[string]int{}
    var m2 = make(map[string]int)
    m1[`a`] = 11
    m2[`b`] = 22
    fmt.Println(m1) // 输出:map[a:11]
    fmt.Println(m2) // 输出:map[b:22]

    // 初始化多个值
    var m3 = map[string]string{"a": "aaa", "b": "bbb"}
    m3["c"] = "ccc"
    fmt.Println(m3) // 输出:map[a:aaa b:bbb c:ccc]

    // 删除 map 中的值
    delete(m3, "a") // 删除键 a 对应的值
    fmt.Println(m3) // 输出:map[b:bbb c:ccc]

    // 查找 map 中的元素
    v, ok := m3["b"]
    if ok {
        fmt.Println(ok)
        fmt.Println("m3中b的值为:", v) // 输出:m3中b的值为: bbb
    }
    // 或者
    if v, ok := m3["b"]; ok { // 流程处理后面讲
        fmt.Println("m3中b的值为:", v) // 输出:m3中b的值为: bbb
    }

    fmt.Println(m3["c"]) // 直接取值,输出:ccc

    // map 中的值可以是任意类型
    m4 := make(map[string][5]int)
    m4["a"] = [5]int{1, 2, 3, 4, 5}
    m4["b"] = [5]int{11, 22, 33}
    fmt.Println(m4)                // 输出:map[a:[1 2 3 4 5] b:[11 22 33 0 0]]
    fmt.Println(unsafe.Sizeof(m4)) // 输出:8,为8个字节,map其实是个指针,指向某个内存空间
}

八、通道(channel)
说到通道 channel,则必须先了解下 Go 语言的 goroutine 协程(轻量级线程)。channel 就是为 goroutine 间通信提供通道。goroutine 是 Go 语言提供的语言级的协程,是对 CPU 线程和调度器的一套封装。
channel 也是类型相关的,一个 channel 只能传递一种类型的值。
声明:var 通道名 chan 通道传递值类型 或 make 函数初始化:make(chan 值类型, 存储空间大小)

package main

import (
    "fmt"
    "time"
)

func main() {
    var ch1 chan int            // 声明一个通道
    ch1 = make(chan int)        // 未初始化的通道不能存储数据,初始化一个通道
    ch2 := make(chan string, 2) // 声明并初始化一个带缓冲空间的通道

    // 通过匿名函数向通道中写入数据,通过 <- 方式写入
    go func() { ch1 <- 1 }()
    go func() { ch2 <- `a` }()

    v1 := <-ch1 // 从通道中读取数据
    v2 := <-ch2
    fmt.Println(v1) // 输出:1
    fmt.Println(v2) // 输出:a

    // 写入,读取通道数据
    ch3 := make(chan int, 1) // 初始化一个带缓冲空间的通道
    go readFromChannel(ch3)
    go writeToChannel(ch3)

    // 主线程休眠1秒,让出执行权限给子 Go 程,即通过 go 开启的 goroutine,不然主程序会直接结束
    time.Sleep(1 * time.Second)
}

func writeToChannel(ch chan int) {
    for i := 1; i < 10; i++ {
        fmt.Println("写入:", i)
        ch <- i
    }
}

func readFromChannel(ch chan int) {
    for i := 1; i < 10; i++ {
        v := <-ch
        fmt.Println("读取:", v)
    }
}

// ------  输出:--------
1
a
写入: 1
写入: 2
写入: 3
读取: 1
读取: 2
读取: 3
写入: 4
写入: 5
写入: 6
读取: 4
读取: 5
读取: 6
写入: 7
写入: 8
写入: 9
读取: 7
读取: 8
读取: 9

goroutine 和 channel 的详细讲解待补充。

九、结构体(struct)
结构体是一种聚合的数据类型,是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员。

package main

import "fmt"

// 定义一个结构体 person
type person struct {
    name string
    age  int
}

func main() {
    var p person   // 声明一个 person 类型变量 p
    p.name = "max" // 赋值
    p.age = 12
    fmt.Println(p) // 输出:{max 12}

    p1 := person{name: "mike", age: 10} // 直接初始化一个 person
    fmt.Println(p1.name)                // 输出:mike

    p2 := new(person) // new函数分配一个指针,指向 person 类型数据
    p2.name = `张三`
    p2.age = 15
    fmt.Println(*p2) // 输出:{张三 15}
}

十、接口(interface)

十一、错误


有疑问加站长微信联系(非本文作者)

本文来自:简书

感谢作者:野尘lxw

查看原文:4.Golang数据类型

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

1072 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传