Golang | 基本数据类型

基本类型

虽然从底层而言,所有的数据都是由比特组成,但计算机一般操作的是固定大小的数,如整数、浮点数、比特数组、内存地址等。进一步将这些数组织在一起,就可表达更多的对象,例如数据包、像素点、诗歌,甚至其他任何对象。Go语言提供了丰富的数据组织形式,这依赖于Go语言内置的数据类型。这些内置的数据类型,兼顾了硬件的特性和表达复杂数据结构的便捷性。

基本类型汇总

基本数据类型 长度(字节) 默认值 说明
bool 1 false
byte 1 0 uint8
rune 4 0 Unicode Code Point, int32
int, uint 4或8 0 32 或 64 位
int8, uint8 1 0 -128 ~ 127, 0 ~ 255,byte是uint8 的别名
int16, uint16 2 0 -32768 ~ 32767, 0 ~ 65535
int32, uint32 4 0 -21亿~ 21亿, 0 ~ 42亿,rune是int32 的别名
int64, uint64 8 0
float32 4 0.0
float64 8 0.0
complex64 8
complex128 16
uintptr 4或8 以存储指针的 uint32 或 uint64 整数
复杂数据类型 长度(字节) 默认值 说明
array 值类型
struct 值类型
string "" UTF-8 字符串
slice nil 引用类型
map nil 引用类型
channel nil 引用类型
interface nil 接口
function nil 函数

布尔类型

布尔型的值只可以是常量 true 或者 false
简单定义:

    var b bool = true

两个相同类型的值可以通过 == 或者 != 等比较运算符号来获得一个布尔类型的值。

布尔值并不会隐式转换为数字值0或1,反之亦然。必须使用一个显式的if语句辅助转换:

// 布尔类型转换为0或者1
func btoi(b bool) int{
    if b {
        return 1
    }
    return 0
}
// 数字转换为布尔类型
func itob(i int) bool { return i != 0 }

整形

Go语言中整形被分为三大类:intuintuintptr
这三种类型的长度是跟据程序所在的操作系统来决定长度的:

  • intuint 在32位操作系统上,它们使用32位,4个字节,在64拉操作系统上,它们使用64位,8个字节。
  • uintptr 的长度被设定为存储指针的 uint32 或 uint64 整数

intuint又被称为有符号整形和无符号整形
有符号整形:

  • int8(-128 -> 127)
  • int16(-32768 -> 32767)
  • int32(-2,147,483,648 -> 2,147,483,647)
  • int64(-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807)

无符号整形:

  • uint8(0 -> 255)
  • uint16(0 -> 65,535)
  • uint32(0 -> 4,294,967,295)
  • uint64(0 -> 18,446,744,073,709,551,615)

用不同的进制来表示整数:
十进制:

    var Decimal int = 12

二进制:

    var Binary int = 0b1100

八进制:

    var Octal int = 0o14

十六进制:

    var Hexadecimal int = 0xc

fmt.printf()函数进行输出:


    func main() {
        var Decimal int = 12
        var Binary int = 0b1100
        var Octal int = 0o14
        var Hexadecimal int = 0xCvar

        fmt.Printf("10进制数 %d 表示的是: %d \n", Decimal, Decimal)     //12
        fmt.Printf("2进制数 %b 表示的是: %d \n", Binary, Binary)           //12
        fmt.Printf("8进制数 %o 表示的是: %d \n", Octal, Octal)             //12
        fmt.Printf("16进制数 %X 表示的是: %d \n", Hexadecimal, Hexadecimal)    //12
    }

跟据上面的输出可以发现,在Go语言中使用二进制、八进制、十六进制 非常的方便,只需要在数字前面加上:0b0o0x 就可以使用。


补充:

fmt.Printf() 函数据的格式化功能:

%b 表示为二进制
%c 该值对应的unicode码值
%d 表示为十进制
%o 表示为八进制
%q 该值对应的单引号括起来的go语法字符字面值,必要时会采用安全的转义表示
%x 表示为十六进制,使用a-f
%X 表示为十六进制,使用A-F
%U 表示为Unicode格式:U+1234,等价于"U+%04X"
%E 用科学计数法表示
%f 用浮点数表示

浮点型

Go语言支持两种浮点型数:float32float64。这两种浮点型数据格式遵循 IEEE 754标准

  • float32(+- 1e-45 -> +- 3.4 * 1e38),可以使用常量定义:math.MaxFloat32
  • float64(+- 5 1e-324 -> 107 1e308),可以使用一个常量定义:math.MaxFloat64

浮点型的零值为 0.0 ,在进行除法运算的时候,浮点型的零值可以为分母并且不会报错,而整形的就会报错。

float32 精确到小数点后 7 位,float64 精确到小数点后 15 位。由于精确度的缘故,你在使用 == 或者 != 来比较浮点数时应当非常小心。你最好在正式使用前测试对于精确度要求较高的运算。也可以使用第三方包来完成这个操作。`go get github.com/shopspring/decimal

package main

func main() {
    var f float64 = 3.1415926
    fmt.Printf("保留两个位小数:%.2f",f)    //3.14
    fmt.Printf("保留两个位小数:%.3f",f)    //3.142
}

在日常使用中,我们经常通常都使用 float64 来来定义浮点类型,因为 math 包里面,几乎所有的方法,都支持 float64
float64 转换为 int 类型:

func IntFromFloat64(x float64) int {
    if math.MinInt32 <= x && x <= math.MaxInt32 { 
        whole, fraction := math.Modf(x)
        if fraction >= 0.5 {
            whole++
        }
        return int(whole)
    }
    panic(fmt.Sprintf("%g is out of the int32 range", x))
}

复数

复数分为:

    complex64 的实部和虚部为32位,
    complex128 的实部和虚部为64位。

复数的简单使用:

    var c1 complex64 = 5 + 10i
    fmt.Printf("The complex64 is: %v", c1)
    // 输出: 5 + 10i

函数 real(c) 和 imag(c) 可以分别获得相应的实数和虚数部分。

byte 和 rune 类型

组成每个字符串的元素叫做字符,通过遍厉字符串或者定义单个字符可以获取,定义字符时用 ' 包裹起来。

    var testRune := '国'
    var testByte := 'a'
    fmt.Printf("字符的类型为:%T",testRune)    //rune
    fmt.Printf("字符的类型为:%T",testRune)    //byte

使用中文或者一些特殊字符和Unicode编码的时候,一般都推荐定义为 rune 类型。

rune 类型为 int32 的别名
byte 类型为 uint8 的别名范围为 (0~255)

字符串

Go语言中的字符串以原生数据类型出现,使用字符串就像使用其他原生数据类型(intboolfloat32float64 等)一样。 Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容,可以在Go语言的源码中直接添加非ASCII码字符,例如:

    var str string = "hello,世界!”

字符串其实多个是byte 类型和 rune 类型放在一起的类型,也就是 string 类型。


比如上面输出的字符串hello ,在 ascii 编码表中,每个字母对应的编号是:104,101,108,108,111
如果这样的话,我们就可以输出一组 []byte 数组,来看一下 string 的底层是什么结构。

    import (
        "fmt")

    func main() {
        var mystr01 string = "hello"
        var mystr02 [5]byte = [5]byte{104, 101, 108, 108, 111}
        fmt.Printf("mystr01: %s\n", mystr01)
        fmt.Printf("mystr02: %s", mystr02)
    }

输出的结果为:

    mystr01: hello
    mystr02: hello

上面这个例子就说明了 string 类型的底层就是由一组 byte 类型的数组组成的。
那么就可以通过数组的自带函数来获取字符串的长度:

    import (
        "fmt")

    func main() {
        var mystr string = "hello"
        fmt.Printf("mystr: %d\n", len(mystr))
        // 结果为:mystr: 5
    }

Go 语言中,字符串之间可以直接通过 + 连接起来,例如:

    import (
        "fmt"
    )
    func main() {        
        s := "hel" + "lo," 
        s += "world!" 
        fmt.Println(s) 
        //输出 “hello, world!”
    }

在遇到字符串数组时,也可以使用 Go 语言封装好的方法 strings.Join() 或者使用字符缓冲 bytes.Buffer() 拼接都可以,并且效率也更高。

转义字符

转义字符 就是一类特殊字符,它们表示特殊的函意,可以用作辅助作用:

  • \n:换行符
  • \r:回车符
  • \t:tab 键
  • \u 或
  • \U:Unicode 字符
  • \:反斜杠自身

例如:

    import "fmt"

    func main() {
        str := "hello \n world"
        fmt.Println(str)
        // 输出:
        //hello
        // world
    }

多行字符

在定义字符串的时候,可以使用 反引号 进行包括,这样就可以进行多行字符串的编译了,例如:

    import "fmt"

    func main() {
        str := `hello world 
    你好,世界`
        fmt.Println(str)
    }
    // 输出:
    //hello world 
    //你好,世界


关注公众号,随时获取最新资讯

细节决定成败!
个人愚见,如有不对,恳请斧正!

posted @ 2022-01-10 00:52  一点浩然气~  阅读(197)  评论(0编辑  收藏  举报