（七）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(“%参数”，表达式)：参数和表达式的类型要匹配；结果返回转换后的字符串；
（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)
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 = "888" 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”不能转换成布尔值、整型、浮点型