GO 语言基本数据类型

1.整数类型

整数类型就是存放整数的，如18 ，-18，123534等，在GO语言中，几乎不同于其它语言，以字节的视角来看其int类型还分为不同的int表达，首先int还要分为两大类。

1.1.有符号整数类型

有符号就是整数有正负之分

我们来看下图：

可以看到，这4个int后面都带了数字，这其实就是这个int类型占用内存最大的比特位，比如int8，就是这个int类型最大只能占用8个比特位，也就是一个字节（1个字节 == 8个比特位），其他的int也是这样来看的，这中分类也就确定了各个int的表数范围，所以我们在定义一个整型值使，要估摸这个整型值的范围，再来确定使用哪个int的类型。

• 我们可以看看这些表示int的类型其大小是不是如此呢？

package main
import (
	"fmt"
	"unsafe"
)

func main(){
	var num1 int8
	fmt.Println(unsafe.Sizeof(num1))
	var num2 int16
	fmt.Println(unsafe.Sizeof(num2))
	var num3 int32
	fmt.Println(unsafe.Sizeof(num3))
	var num4 int64 
	fmt.Println(unsafe.Sizeof(num4))
}

可以看到，不同的int类型其字节大小的确不同。

• 如果说int类型赋值不当就会出现如下的错误：

package main
import "fmt"

func main(){
	var num1 int8 = 666 // int8 不能承受666这个值
	fmt.Println(num1)
}

也就是说666不能作为值赋给int8，不然编译就会出问题，应该使用更高存储字节空间的int类型来存放。

1.2.无符号整数类型

无符号整数类型就是没有负数之说只有整正数（没有符号位）

我们来看下图：

可以看到，无符号整数类型在有符号整数类型int的前面多了一个u，这就是表示无符号的意思，值得注意的是，其占用储存空间的字节大小没有变化，但表数范围变了，变得没有负数了，最大值更大了，这就是无符号整型的优势，如果你想表达的数据咬定没有负数，那么选无符号整型类型会更好些（如表示身高，年龄）。

• 当然，如果用无符号整型取存放负数，这也是会严格的报错的

1.3.其他整数类型

我们来看下图：

可以看到，int和uint他们的字节大小是由计算机系统的位数来决定的，rune就相当于int32，byte相当于uint8（在后面byte可以用作字符的类型）。

定义如下：

package main
import "fmt"

func main(){
	var a int = 3
	var b uint = 5
	var c rune = 10
	var d byte = 20
	var e byte = 'a'
}

1.4.额外知识

• Golang的整数类型，默认声明为int类型
  

• 变量占用的字节数

首先要求变量所占用的字节数，需要引入unsafe这个包，然后使用这个包里面的Sizeof来求

package main
import (
	"fmt"
	"unsafe" // 引入包
)

func main(){
	// 直接使用
	var num1 int8
	fmt.Println(unsafe.Sizeof(num1)) // 1 
	var num2 int16
	fmt.Println(unsafe.Sizeof(num2)) // 2
	var num3 int32
	fmt.Println(unsafe.Sizeof(num3)) // 4
	var num4 int64 
	fmt.Println(unsafe.Sizeof(num4)) // 8
}

• 这么多整数类型，使用的时候该如何选择呢？Golang程序中整型变量在使用时,遵守保小不保大的原则, 即: 在保证程序正确运行下,尽量使用占用空间小的数据类型

// 表示学生年龄
var age byte = 8 // 小的数据尽量用byte存放

2.浮点类型

简单来说，浮点类型就是用来存放小树值的， 如3.14，5.20，-13.14。

看下图：

在GO语言中，要创建浮点类型的变量，必须在float后面加上32或者64，因为单纯的一个float不会被当作浮点类型。

• 当我们在赋值给一个浮点类型的变量时，我们可以直接赋值小数，也可以用E（或者e）（科学计数法）表示，如下：

package main
import (
	"fmt"
)

func main(){
	var fa float32 = 314E-2 // E-2表示乘以10^-2
	var fb float32 = 314E+2 // E+2表示乘以10^2
	var fc float32 = 314e-2 // 小写e与大写E没有区别
	var fd float32 = 3.14 // 直接赋值3.14
	fmt.Println(fa)  // 3.14
	fmt.Println(fb)  // 31400
	fmt.Println(fc)  // 3.14
	fmt.Println(fd)  // 3.14
}

• 我们在给float赋值的时候，很可能出现精度损失的情况，因此建议创建浮点类型的时候最好用float64。

package main
import "fmt"

func main(){
	//浮点数可能会有精度的损失，所以通常情况下，建议你使用：float64 
	var num7 float32 = 520.000001314
	fmt.Println(num7)
	var num8 float64 = 520.000001314
	fmt.Println(num8)
}

运行结果：

3.字符类型

• Golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用byte来保存。
• Golang中字符使用UTF-8编码
  UTF-8编码链接

UTF-8编码：

• 当我们用byte类型来定义一个字符变量，将其打印出来的值是其对应的ASCLL码值，各个字符的ASCLL码值对应如下：

示例如下：

所以字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出，但如果我们用Printf打印（括号里要用%c），可以打印出字符：

如果我们想要打印中文字符，比如打印一个中，这时byte类型就存放不下其对应的ASCLL码值了，所以这时我们应该使用int。

package main
import "fmt"

func main(){
	var c int = '中'
	fmt.Println(c)
	//汉字字符，底层对应的是Unicode码值
	//对应的码值为20013，byte类型溢出，能存储的范围：可以用int
	//总结：Golang的字符对应的使用的是UTF-8编码
	//（Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案）
}

转义字符

看下图：

通俗来说：

• \b
  就是往前挪一格，掩盖挪动的那一格的数据。
  

• \n
  就是换行，这个不用多说（haha）

• \r
  就是光标回到本行的开头，将\r后面的字符依次覆盖前面的字符。
  

• \t
  就是将\t前面的字符串补够8个位置（不够8个位置），不够的话，则从那够了的8个再往后数。

• \" , \' , \\
  这三个是为了在字符串中能够将”,',\打印出来而不是与旁边的"",'',或者是转义匹配。

例如：

4.布尔类型

• 布尔类型也叫bool类型，bool类型数据只允许取值true和false。
• 布尔类型占1个字节。
• 布尔类型适于逻辑运算，一般用于程序流程控制。

基本的使用：

package main
import "fmt"
func main(){
        //测试布尔类型的数值：
        var flag1 bool = true
        fmt.Println(flag1) // true
        var flag2 bool = false
        fmt.Println(flag2) // false
        var flag3 bool = 5 < 9
        fmt.Println(flag3) // true，因为5的确小于9：为真
}

5.字符串类型

• 字符串类型用 string 来定义。
• 字符串定义后就不能改变了（单指字符串，变量的值可以变）。
• 字符串可以拼接。
• 当一个字符串里面有转义的时候最好用 `` （Esc下面的按键）括起来（当然转义字符也可以）。
• 当一个字符串过长时，最好换行，而换行的时候最好将运算符放在一行的最后面，因为如果不是符号在最后面，编译器会自动在这一行的后面加上；，我们看不见而已。

示例：

package main
import "fmt"

func main(){


	// 定义一个字符串
	var str1 string = "hello golang"
	fmt.Println(str1) // hello golang


	// 转义字符过多时用``括起来
	var str2 string = `package main
	import "fmt"
	func main(){
		fmt.Println("abc\"d\"efghijklm\\nopqrs\\tuvw")
		// abc"d"efghijklm\nopqrs\tuvw
	}`


	// 字符串拼接
	var str3 string = "hahaha" + "hehehe"
	str3 += "iloveyou"
	fmt.Println(str3) // hahahaheheheiloveyou


	//当一个字符串过长的时候：注意：+保留在上一行的最后
	var str4 string = "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" +
	     "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+
		"abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" +
		"def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + 
		"abc" + "def"+ "abc" + "def"
	fmt.Println(str4)
}

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

在Golang中数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值(默认值又叫零值)。

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

Go在不同类型的变量之间赋值时需要显式转换，并且只有显式转换(强制转换)。

语法形式：
表达式T(v)将值v转换为类型T
T : 就是数据类型
v : 就是需要转换的变量

例如：

package main
import "fmt"

func main(){
	var num1 int = 1000
	var f1 float32 = float32(num1)
	fmt.Println(f1) // 1000

	var f2 float32 = 666.66
	var num2 int = int(f2)
	fmt.Println(num2) // 66
}

但如过一个大的值强制转换为一个不能存放这个大数据的值的类型时，编译器不会报错，但运行后会造成数据的溢出（截断）：
例如：

package main
import "fmt"

func main(){
	// 将int64转为int8的时候，编译不会出错的，但是会数据的溢出
	var n1 int64 = 666666
	var n2 int8 = int8(n3)
	// 这里发生了截断
	fmt.Println(n2)//56
}

8.基本数据类型转为string

• 在程序开发中，我们经常需要将基本数据类型转成string类型。或者将string类型转成基本数据类型。
• 将基本数据类型转化为string有两种方式：
  1.fmt包中的Sprintf（“%参数”， 要转换的变量（注意：原先的变量值不变，只是将面值赋给一个string类型的变量））— 推荐。
  2.使用strconv包中的函数。

• 第一种方式转换如下：

package main
import "fmt"
func main(){
	var n1 int = 19
	var n2 float32 = 4.78
	var n3 bool = false
	var n4 byte = 'a'

	var s1 string = fmt.Sprintf("%d",n1)
	fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)

	var s2 string = fmt.Sprintf("%f",n2)
	fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)

	var s3 string = fmt.Sprintf("%t",n3)
	fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
	
	var s4 string = fmt.Sprintf("%c",n4)
	fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4)
}

• 第二种方式转换我们还需了解strconv包,以及包中我们将要用到的函数。

根据函数的功能及使用，如下转换：

package main
import(
        "fmt"
        "strconv"
)
func main(){
        var n1 int = 18
        var s1 string = strconv.FormatInt(int64(n1),10)  //参数：第一个参数必须转为int64类型 ，第二个参数指定字面值的进制形式为十进制
        fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
        
        var n2 float64 = 4.29
        var s2 string = strconv.FormatFloat(n2,'f',9,64)
        //第二个参数：'f'（-ddd.dddd）  第三个参数：9 保留小数点后面9位  第四个参数：表示这个小数是float64类型
        fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
        
        var n3 bool = true
        var s3 string = strconv.FormatBool(n3)
        fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
}

9.string转为基本数据类型

将string转为基本数据类型的方式是使用strconv包中的函数。

下面通过使用函数来代码实现转化：

package main
import(
        "fmt"
        "strconv"
)

func main(){
//1. string 转 bool
        //string-->bool
        var s1 string = "true"
        var b bool
        //ParseBool这个函数的返回值有两个：(value bool, err error)
        //value就是我们得到的布尔类型的数据，err出现的错误
        //我们只关注得到的布尔类型的数据，err可以用_直接忽略
        b , _ = strconv.ParseBool(s1)
        fmt.Printf("b的类型是：%T,b=%v \n",b,b)
//2.  string 转 int64        
        //string---》int64
        var s2 string = "19"
        var num1 int64
        num1,_ = strconv.ParseInt(s2,10,64)
        fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)
//3.  string 转 float64        
        //string-->float32/float64
        var s3 string = "3.14"
        var f1 float64
        f1,_ = strconv.ParseFloat(s3,64)
        fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)
//4.        
        //注意：string向基本数据类型转换的时候，
        //一定要确保string类型能够
        //转成有效的数据类型，
        //否则最后得到的结果就是按照对应类型的默认值输出
        var s4 string = "golang"
        var b1 bool
        b1 , _ = strconv.ParseBool(s4)
        fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)
//5.        
        var s5 string = "golang"
        var num2 int64
        num2,_ = strconv.ParseInt(s5,10,64)
        fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)
}

运行结果为：

可以看到，b1与 num2的值都是默认值。

写在最后

GO语言需要求精的地方多，不能放过每一个部分，不然出来的代码就很可能会不够严谨。

感谢阅读本小白的博客，错误的地方请严厉指出噢！