【Go】二、Go的基本数据类型

偏执的太偏执、 2024-04-23 15:48 2阅读 0赞

#### 文章目录 ####

*  0、进制
 *  1、变量的声明
 *  2、数据类型
 *  3、整型
 *  4、浮点型
 *  5、字符类型
 *  6、布尔类型
 *  7、字符串类型
 *  8、基本数据类型的默认值
 *  9、类型转换
 *  10、基本类型转String
 *  11、String转其他类型

## 0、进制 ##

N进制，逢N进一

![在这里插入图片描述][2199557008174f0abf360d42952a57f4.png]

## 1、变量的声明 ##

//声明 + 赋值
    var age int = 18

//声明、赋值、使用
    func main(){
        
    	var age int
    	age = 18
    	fmt.Println("age = ", age)
    }

通过变量名在内存中找到它（通过房间号找到在一栋楼里找到某个房间），变量类型，即区分空间大小（类比单人间、双人间）

![在这里插入图片描述][21b83d230a97424fb85cfe100c45aa82.png]  
变量定义的四种形式：

package main
    import "fmt"
    func main(){
        
    	//定义在{}中的变量叫：局部变量
    	//第⼀种：变量的使⽤⽅式：指定变量的类型，并且赋值，
    	var num int = 18
    	fmt.Println(num)
    	
    	//第⼆种：指定变量的类型，但是不赋值，使⽤默认值
    	var num2 int
    	fmt.Println(num2)
    	
    	//第三种：如果没有写变量的类型，那么根据=后⾯的值进⾏判定变量的类型 （⾃动类型推断）
    	var num3 = "tom"
    	fmt.Println(num3)
    	
    	//第四种：省略var，注意 := 不能写为 = 
    	sex := "男"
    	fmt.Println(sex)
    }

也可一次声明多个变量，不论局部还是全局变量

package main
    import "fmt
    
    //全局变量：定义在函数外的变量
    var n7 = 100
    var n8 = 9.7
    
    //设计者认为上⾯的全局变量的写法太麻烦了，可以⼀次性声明：
    var (
    	n9 = 500
    	n10 = "netty"
    )
    
    func main(){
        
    	//声明多个变量：
    	var n1,n2,n3 int
    	fmt.Println(n1)    //0
    	fmt.Println(n2)	   //0
    	fmt.Println(n3)    //0
    	
    	var n4,name,n5 = 10,"jack",7.8
    	fmt.Println(n4)
    	fmt.Println(name)
    	fmt.Println(n5)
    	
    	n6,height := 6.9,100.6
    	fmt.Println(n6)
    	fmt.Println(height)
    	
    	
    	fmt.Println(n7)
    	fmt.Println(n8)
    	
    	fmt.Println(n9)
    	fmt.Println(n10)
    }

## 2、数据类型 ##

![在这里插入图片描述][5c3c46aaba184cb09842caa2d33eefe5.png]

## 3、整型 ##

有符号整数型：

![在这里插入图片描述][80db1e75b63d4ae4b80fc4f3521e9a84.png]

//首位为符号位，127即
    0111 1111

无符号型：

![在这里插入图片描述][806688cfb44d49429e1d725aee741de4.png]

//255即
    1111 1111

其他类型：

![在这里插入图片描述][415730c691764accbd398460b5bfda6b.png]

不加类型声明整形，go默认是int类型：

![在这里插入图片描述][6cd2bc67359344f1b17657aec18a6efc.png]

导入unsafe包，查看变量所占的字节数：

![在这里插入图片描述][d01a204ef8cd4f46b90aa67cfd58c558.png]

## 4、浮点型 ##

不同于Java的float和double，go中是float32和float64：

![在这里插入图片描述][9d47a5353f9248878a723fef8c00bd1f.png]

package main
    import "fmt"
    func main(){
        
            //定义浮点类型的数据：
            var num1 float32 = 3.14
            fmt.Println(num1)
            //可以表示正浮点数，也可以表示负的浮点数
            var num2 float32 = -3.14
            fmt.Println(num2)
            //浮点数可以用十进制表示形式，也可以用科学计数法表示形式  E 大写小写都可以的
            var num3 float32 = 314E-2 
            fmt.Println(num3)
            var num4 float32 = 314E+2
            fmt.Println(num4)
            var num5 float32 = 314e+2
            fmt.Println(num5)
            var num6 float64 = 314e+2
            fmt.Println(num6)
            //浮点数可能会有精度的损失，所以通常情况下，建议你使用：float64 
            var num7 float32 = 256.000000916
            fmt.Println(num7)
            var num8 float64 = 256.000000916
            fmt.Println(num8)
            //golang中默认的浮点类型为：float64 
            var num9 = 3.17
            fmt.Printf("num9对应的默认的类型为：%T",num9)
    }

运行发现精度损失：

![在这里插入图片描述][40f424a5d0e241ada60b5c4c223ffb58.png]

因此，通常建议用float64，且go中浮点类型默认也是float64

## 5、字符类型 ##

和Java有char不同，Go中没有专⻔的字符类型，如果要存储单个字符(字⺟)，⼀般使⽤`byte`类型来保存，且Go中字符使用utf-8编码

package main
    import "fmt"
    func main(){
        
            //定义字符类型的数据：
            var c1 byte = 'a'
            fmt.Println(c1)//97
            var c2 byte = '6'
            fmt.Println(c2)//54
            var c3 byte = '('
            fmt.Println(c3 + 20)//40
            //字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出
            //字母，数字，标点等字符，底层是按照ASCII进行存储。
            var c4 int = '中'
            fmt.Println(c4)
            //汉字字符，底层对应的是Unicode码值
            //对应的码值为20013，byte类型溢出，能存储的范围：可以用int
            //总结：Golang的字符对应的使用的是UTF-8编码（Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案）
            var c5 byte = 'A'
            //想显示对应的字符，必须采用格式化输出
            fmt.Printf("c5对应的具体的字符为：%c",c5)
    }

![在这里插入图片描述][494c7c1f47314d6d8962e07549fd02d5.png]

关于转义字符：

import "fmt"
    func main(){
        
            //练习转义字符：
            //\n  换行
            fmt.Println("aaa\nbbb")
            //\b 退格
            fmt.Println("aaa\bbbb")
            //\r 光标回到本行的开头，后续输入就会替换原有的字符
            fmt.Println("aaaaa\rbbb")
            //\t 制表符
            fmt.Println("aaaaaaaaaaaaa")
            fmt.Println("aaaaa\tbbbbb")
            fmt.Println("aaaaaaaa\tbbbbb")
            //\"
            fmt.Println("\"Golang\"")
    }

![在这里插入图片描述][0f343d3546aa45abbebaed1fdf2eb008.png]

## 6、布尔类型 ##

package main
    import "fmt"
    func main(){
        
            //测试布尔类型的数值：
            var flag01 bool = true
            //true
            fmt.Println(flag01)
            var flag02 bool = false
            //false
            fmt.Println(flag02)
            var flag03 bool = 5 < 9
            //true
            fmt.Println(flag03)
    }

## 7、字符串类型 ##

字符串是不可变的：指的是字符串⼀旦定义好，其中的字符的值不能变，如str\[0\] = 'b‘

*  如果字符串中没有特殊字符，字符串的表示形式⽤双引号
 *  如果字符串中有特殊字符，字符串的表示形式⽤反引号 \`\`
 *  \+号进行字符串拼接

package main
    import "fmt"
    func main(){
        
            //1.定义一个字符串：
            var s1 string = "你好Golang"
            fmt.Println(s1)
            //2.字符串是不可变的：指的是字符串一旦定义好，其中的 字符 的值不能改变
            var s2 string = "abc"
            s2 = "def"
            //s2[0] = 't'
            fmt.Println(s2)
            //3.字符串的表示形式：
            //（1）如果字符串中没有特殊字符，字符串的表示形式用双引号
            //var s3 string = "asdfasdfasdf"
            //（2）如果字符串中有特殊字符，字符串的表示形式用反引号 ``
            var s4 string = `
            package main
            import "fmt"
            
            func main(){
                    //测试布尔类型的数值：
                    var flag01 bool = true
                    fmt.Println(flag01)
            
                    var flag02 bool = false
                    fmt.Println(flag02)
            
                    var flag03 bool = 5 < 9
                    fmt.Println(flag03)
            }
            `
            fmt.Println(s4)
            //4.字符串的拼接效果：
            var s5 string = "abc" + "def"
            s5 += "hijk"
            fmt.Println(s5)
            //当一个字符串过长的时候：注意：+保留在上一行的最后
            var s6 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(s6)
    }

![在这里插入图片描述][40cfa6279a49471387ca0f0a80f99d9d.png]

最后，注意换行拼接时，+保留在上⼀⾏的最后，因为和Java不一样，没封号，你换行，编译器会认为这个语句结束了

![在这里插入图片描述][966ceee9021449e4bd4ef9d9a602fc43.png]

## 8、基本数据类型的默认值 ##

![在这里插入图片描述][304a1a4503104671bc7fb8aa2cf1f870.png]  
![在这里插入图片描述][93b648a0322a4083a99f78e85ab25fdd.png]

## 9、类型转换 ##

go不同类型变量之间赋值，需要显式转换（强制转换）

语法：
    T(v)
    //将值v转换为类型T

package main
    import "fmt"
    func main(){
                
            var n1 int = 100
            //进行类型转换：
            //var n2 float32 = n1  在这里自动转换不好使，比如显式转换
            var n2 float32 = float32(n1)
            fmt.Println(n2)
    
    
            //注意：n1的类型其实还是int类型，只是将n1的值100转为了float32而已，n1还是int的类型
            fmt.Printf("%T",n1)  //int
            fmt.Println()
    
    
            //将int64转为int8的时候，编译不会出错的，但是会数据的溢出
            var n3 int64 = 888888
            var n4 int8 = int8(n3)
            fmt.Println(n4)//转型后结果是56，就像把一个大面包强塞到一个小盒子，面包肯定要掉渣
    
    
            var n5 int32 = 12
            var n6 int64 = int64(n5) + 30  //一定要匹配=左右两边的数据类型
            fmt.Println(n6)
    
    
            var n7 int64 = 12
            var n8 int8 = int8(n7) + 127  //编译通过，但是结果可能会溢出
            
            //var n9 int8 = int8(n7) + 128 //编译不会通过
            fmt.Println(n8)
            //fmt.Println(n9)
    }

注意最后的两个，int8类型-128到127，所以这个编译能通过，但是结果可能会溢出

var n7 int64 = 12
    var n8 int8 = int8(n7) + 127

而这个则编译都不通过：

var n9 int8 = int8(n7) + 128

## 10、基本类型转String ##

*  方式一：fmt.Sprintf(“%参数”,表达式)

package main
    import "fmt"
    func main(){
        
            var n1 int = 19
            var n2 float32 = 4.78
            var n3 bool = false
            var n4 byte = 'a'
            //int转string %d
            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)
            //byte转string %c
            var s4 string = fmt.Sprintf("%c",n4)
            fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4)    //%q即将结果用引号引起来
    }

*  方式二：使⽤strconv包的函数

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

## 11、String转其他类型 ##

使用strconv包的函数

package main
    import(
            "fmt"
            "strconv"
    )
    func main(){
        
            //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)
    
    
            //string---》int64
            var s2 string = "19"
            var num1 int64
            num1,_ = strconv.ParseInt(s2,10,64)
            fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)
    
    
            //string-->float32/float64
            var s3 string = "3.14"
            var f1 float64
            f1,_ = strconv.ParseFloat(s3,64)   //转float64
            fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)
    
    		//注意下面转完后，输出Boolean的默认值false
            var s4 string = "golang"
            var b1 bool
            b1 , _ = strconv.ParseBool(s4)
            fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)   
    
    		
    		//无效转，最后输出int的默认值0
            var s5 string = "golang"
            var num2 int64
            num2,_ = strconv.ParseInt(s5,10,64)
            fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)
    }

**string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果就是按照对应类型的默认值输出**

[2199557008174f0abf360d42952a57f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/93058e048dc349e6a0cfb2354da1f7d7.png
[21b83d230a97424fb85cfe100c45aa82.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/6fea014321ae404fa0b108cf939f999f.png
[5c3c46aaba184cb09842caa2d33eefe5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/3998877a86e846adbf38ebd6367dde99.png
[80db1e75b63d4ae4b80fc4f3521e9a84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/d23c4a9649ab470191a1c8d9584fb25d.png
[806688cfb44d49429e1d725aee741de4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/850815a9194840c1a33991e9756bbd93.png
[415730c691764accbd398460b5bfda6b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/bd0615ac355240ebbe34e6d38bb374c8.png
[6cd2bc67359344f1b17657aec18a6efc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/1bd611cc1f04470795cf217a6ad48685.png
[d01a204ef8cd4f46b90aa67cfd58c558.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/1a752edde1f34b7dbe53a735ef70946c.png
[9d47a5353f9248878a723fef8c00bd1f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/8adf4754e3124030993165cb2056d98a.png
[40f424a5d0e241ada60b5c4c223ffb58.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/95c7c20ad14645daba805cda09c737a3.png
[494c7c1f47314d6d8962e07549fd02d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/da9d388e49884225b4c8997c354a3007.png
[0f343d3546aa45abbebaed1fdf2eb008.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/1abbc58566f84ce9a433f6a89556b8ed.png
[40cfa6279a49471387ca0f0a80f99d9d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/b0a590f6a3e54cf1a4d2531c9ea0ce7e.png
[966ceee9021449e4bd4ef9d9a602fc43.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/95329724dde5438093407085cbb0b22a.png
[304a1a4503104671bc7fb8aa2cf1f870.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/6657a7030fd146c1bef76f720e0624c6.png
[93b648a0322a4083a99f78e85ab25fdd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/b42e98627d754c92bb825d52daf037f2.png