（七）golang-变量之基本数据类型（看这篇就够了）

1.整数类型

类型	有无符号	占用存储空间	表示范围	备注
int8	有	1字节	-2**7~2**7-1
int16	有	2字节	-2**15~2**15-1
int32	有	4字节	-2**31~2**31-1
int64	有	8,字节	-2**63~2**63-1
uint8	无	1字节	0~2**8-1
uint16	无	2字节	0~2**16-1
uint32	无	4字节	0~2**32-1
uint64	无	8字节	0~2**64-1
int	有	32位系统4字节 64位系统8字节	-2**31~2**31-1 -2**63~2**63-1
uint	无	32位系统4字节 64位系统8字节	0~2**32-1 0~2**64-1
rune	有	与int32一样	-2**31~2**31-1	等价int32，表示 一个unicode码
byte	无	与uint8一样	0~2**8-1	当要存储字符时 使用byte

整型的使用细节：

（1）golang整数类型分为：有符号和无符号，int和uint的大小和系统有关；

（2）golang整型默认申明为int；

（3）如何在程序查看某个变量的数据类型？

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var num int64 = 10
    fmt.Printf("num的数据类型是 %T，占的字节数是 %d", num, unsafe.Sizeof(num))
}

（4）golang使用整数类型时，遵从保小不保大原则，即在保证程序正常运行的情况下，尽量使用占用空间小的数据类型；

（5）bit：计算机中最小的存储单位，byte：计算机中基本的存储单元；

2.浮点类型

类型	占用存储空间	表示范围
单精度float32	4字节	-3.403E38~3.403E38
双精度float64	8字节	-1.798E308~1.798E308

说明：

（1）浮点数在机器中存在的形式：浮点数=符号位+指数位+尾数位（浮点数都是有符号的）11110000111.111111111111111111000

（2）尾数部分可能丢失，造成精度损失；

（3）浮点型的存储分为三个部分：符号位+指数位+尾数位；

浮点型的使用细节：

（1）golang浮点类型有固定的范围和字段长度，不受操作系统的影响；

（2）默认为float64类别；

（3）浮点型常用两种形式表示：

　　1）十进制：5.12、.512

　　2）科学记数法形式：5.1234E2、5.1234E-2

（4）通常使用float64，它精度更高；

3.字符类型

字符串是一串固定长度的字符连接起来的字符序列。golang没有专门的存储字符类型，如果要存储单个字符，用byte来保存。go的字符串是由单个字节连接起来的，它与传统的字符串是由字符组成的不同。

package main

import (
    "fmt"
)

func main() {
    var c1 byte = 'a'
    fmt.Println(c1)
}

当我们直接输出字符c1,，得到的是它的ascII值：97。要用格式化输出：fmt.Printf("%c",c1)。而当我们要存储中文时，此时不能够用byte类型了，即ASCII值大于255时，会显示溢出，我们要用int来存储：

（补：格式化输出代表含义 %d：输出整型；%f：输出浮点型；%c：输出字符型；%v：输出原变量值；%T：输出变量的数据类型；%t：输出布尔值：%q：输出带双引号的字符串）

package main

import (
    "fmt"
)

func main() {
    var c1 byte = 'a'
    var c2 int = '被'
    fmt.Println(c1)
    fmt.Printf("c1的值是：%c \n", c1)
    fmt.Printf("c2的值是：%c，它的ASCii值是：%d", c2, c2)
}

字符类型使用细节：（再也不用担忧编码的问题了，所有的编码都是utf-8）
（1）字符常量使用单引号括起来的单个字符；

（2）go中允许使用转义字符'\'来将其后的字符转变为特殊字符型常量，例如 var c int = '\n'；

（3）字符使用utf-8编码；

（4）go中，字符的本质是一个整数，直接输出时，会输出它对应的UTF-8编码的值；

（5）可以直接给变量赋予某个数字，然后格式化输出%c，会输出该数字对应的unicode字符；

（6）字符类型是可以进行运算的，相当于一个整数，因为它都对应unicode码；

4.布尔类型

只允许取两个值：true、false；占用1个字节；主要用在逻辑运算；

5.字符串类型

go的字符串是由字节连接而成；

package main

import (
    "fmt"
)

func main() {
    var address string = "北京长城"
    fmt.Println(address)
}

字符串的使用细节：
（1）go语言的字符串的字节使用utf-8编码；

（2）与python一样，一旦字符串赋值了，就不能被更改；

（3）两种表示形式

　　1）双引号，会识别转义字符；

　　2）反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击，输出源代码等

package main

import (
    "fmt"
)

func main() {
    var c = "abc\nabc"
    var d = `abc\nabc`
    fmt.Println(c)
    fmt.Println(d)
}

　　3）字符串的拼接，当我们要拼接多行字符串时，要将加号留在每行末尾：（注意单个字符进行拼接是指对unicode值进行相加）

package main

import (
    "fmt"
)

func main() {
    var str = "hello " + "world " +
        "!"
    fmt.Println(str)
}

6.基本数据类型的默认值

整型：0

浮点型：0

字符串：""

布尔类型：false

7.基本数据类型之间的转换

golang和java、c不同，Go在不同类型变量之间赋值需要显示转换，也就是golang中数据类型不能自动转换；

基本语法：T(v)，即将变量v转换成T数据类型

整数型之间的转换：例如var i int8 = 10; var n1 int64 = int64(i)

（1）数据类型转换可以从范围小-->范围大，范围大-->范围小；

（2）被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化；

（3）在转换中，比如将int64转成int8，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样；

基本数据类型和string之间的转换

（1）fmt.Sprintf("%参数"，表达式)：参数和表达式的类型要匹配；结果返回转换后的字符串；

package main

import (

    "fmt"

)

func main() {

    var num1 int = 99

    var num2 float64 = 23.456

    var b bool = false

    var c byte = 'g'

    var str1 = fmt.Sprintf("%d", num1)

    var str2 = fmt.Sprintf("%f", num2)

    var str3 = fmt.Sprintf("%t", b)

    var str4 = fmt.Sprintf("%c", c)

    fmt.Printf("%T--%q\n", str1, str1)

    fmt.Printf("%T--%q\n", str2, str2)

    fmt.Printf("%T--%q\n", str3, str3)

    fmt.Printf("%T--%q", str4, str4)

}

（2）使用strconv函数package main

import (
    "fmt"
    "strconv"
)

func main() {
    var num1 int = 99
    var num2 float64 = 23.456
    var b bool = false
    //FormatInt()第一个参数必须转成int64,第二个是十进制表示
    var str1 = strconv.FormatInt(int64(num1), 10)
    //FormatFloat，'f'表示格式，10表示保留小数，64表示float64
    var str2 = strconv.FormatFloat(num2, 'f', 10, 64)
    var str3 = strconv.FormatBool(b)

      //将int转换成string

      var str4 = strconv.Itoa(num1)

    fmt.Printf("%T--%q\n", str1, str1)
    fmt.Printf("%T--%q\n", str2, str2)
    fmt.Printf("%T--%q\n", str3, str3)

    fmt.Printf("%T--%q\n", str4, str4)

}

string和基本数据类型转换：

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var s1 string = "true"
    var s2 string = ""
    var s3 string = "23.45"
    var num1 int64
    var num2 float64
    var b bool
    b, _ = strconv.ParseBool(s1)
    num1, _ = strconv.ParseInt(s2, 10, 64)
    num2, _ = strconv.ParseFloat(s3, 64)
    fmt.Printf("%T--%t\n", b, b)
    fmt.Printf("%T--%d\n", num1, num1)
    fmt.Printf("%T--%f\n", num2, num2)
}

注意：要确保string类型要能够转换成有效的数据，即"hello"不能转换成布尔值、整型、浮点型