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

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

文章目录

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

0、进制

N进制，逢N进一

在这里插入图片描述

1、变量的声明

  1. //声明 + 赋值
  2. var age int = 18
  4. //声明、赋值、使用
  5. func main(){
  7.     var age int
  8.     age = 18
  9.     fmt.Println("age = ", age)
  10. }

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

在这里插入图片描述
变量定义的四种形式：

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

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

  1. package main
  2. import "fmt
  4. //全局变量：定义在函数外的变量
  5. var n7 = 100
  6. var n8 = 9.7
  8. //设计者认为上⾯的全局变量的写法太麻烦了，可以⼀次性声明：
  9. var (
  10.     n9 = 500
  11.     n10 = "netty"
  12. )
  14. func main(){
  16.     //声明多个变量：
  17.     var n1,n2,n3 int
  18.     fmt.Println(n1)    //0
  19.     fmt.Println(n2)       //0
  20.     fmt.Println(n3)    //0
  22.     var n4,name,n5 = 10,"jack",7.8
  23.     fmt.Println(n4)
  24.     fmt.Println(name)
  25.     fmt.Println(n5)
  27.     n6,height := 6.9,100.6
  28.     fmt.Println(n6)
  29.     fmt.Println(height)
  32.     fmt.Println(n7)
  33.     fmt.Println(n8)
  35.     fmt.Println(n9)
  36.     fmt.Println(n10)
  37. }

2、数据类型

在这里插入图片描述

3、整型

有符号整数型：

在这里插入图片描述

  1. //首位为符号位，127即
  2. 0111 1111

无符号型：

在这里插入图片描述

  1. //255即
  2. 1111 1111

其他类型：

在这里插入图片描述

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

在这里插入图片描述

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

在这里插入图片描述

4、浮点型

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

在这里插入图片描述

  1. package main
  2. import "fmt"
  3. func main(){
  5.         //定义浮点类型的数据：
  6.         var num1 float32 = 3.14
  7.         fmt.Println(num1)
  8.         //可以表示正浮点数，也可以表示负的浮点数
  9.         var num2 float32 = -3.14
  10.         fmt.Println(num2)
  11.         //浮点数可以用十进制表示形式，也可以用科学计数法表示形式  E 大写小写都可以的
  12.         var num3 float32 = 314E-2 
  13.         fmt.Println(num3)
  14.         var num4 float32 = 314E+2
  15.         fmt.Println(num4)
  16.         var num5 float32 = 314e+2
  17.         fmt.Println(num5)
  18.         var num6 float64 = 314e+2
  19.         fmt.Println(num6)
  20.         //浮点数可能会有精度的损失，所以通常情况下，建议你使用：float64 
  21.         var num7 float32 = 256.000000916
  22.         fmt.Println(num7)
  23.         var num8 float64 = 256.000000916
  24.         fmt.Println(num8)
  25.         //golang中默认的浮点类型为：float64 
  26.         var num9 = 3.17
  27.         fmt.Printf("num9对应的默认的类型为：%T",num9)
  28. }

运行发现精度损失：

在这里插入图片描述

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

5、字符类型

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

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

在这里插入图片描述

关于转义字符：

  1. import "fmt"
  2. func main(){
  4.         //练习转义字符：
  5.         //\n  换行
  6.         fmt.Println("aaa\nbbb")
  7.         //\b 退格
  8.         fmt.Println("aaa\bbbb")
  9.         //\r 光标回到本行的开头，后续输入就会替换原有的字符
  10.         fmt.Println("aaaaa\rbbb")
  11.         //\t 制表符
  12.         fmt.Println("aaaaaaaaaaaaa")
  13.         fmt.Println("aaaaa\tbbbbb")
  14.         fmt.Println("aaaaaaaa\tbbbbb")
  15.         //\"
  16.         fmt.Println("\"Golang\"")
  17. }

在这里插入图片描述

6、布尔类型

  1. package main
  2. import "fmt"
  3. func main(){
  5.         //测试布尔类型的数值：
  6.         var flag01 bool = true
  7.         //true
  8.         fmt.Println(flag01)
  9.         var flag02 bool = false
  10.         //false
  11.         fmt.Println(flag02)
  12.         var flag03 bool = 5 < 9
  13.         //true
  14.         fmt.Println(flag03)
  15. }

7、字符串类型

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

  • 如果字符串中没有特殊字符，字符串的表示形式⽤双引号
  • 如果字符串中有特殊字符，字符串的表示形式⽤反引号 ``

  • +号进行字符串拼接

    package main
    import “fmt”
    func main(){

    1.     //1.定义一个字符串：
    2.     var s1 string = "你好Golang"
    3.     fmt.Println(s1)
    4.     //2.字符串是不可变的：指的是字符串一旦定义好，其中的 字符 的值不能改变
    5.     var s2 string = "abc"
    6.     s2 = "def"
    7.     //s2[0] = 't'
    8.     fmt.Println(s2)
    9.     //3.字符串的表示形式：
    10.     //（1）如果字符串中没有特殊字符，字符串的表示形式用双引号
    11.     //var s3 string = "asdfasdfasdf"
    12.     //（2）如果字符串中有特殊字符，字符串的表示形式用反引号 ``
    13.     var s4 string = `
    14.     package main
    15.     import "fmt"
    17.     func main(){
    18.             //测试布尔类型的数值：
    19.             var flag01 bool = true
    20.             fmt.Println(flag01)
    22.             var flag02 bool = false
    23.             fmt.Println(flag02)
    25.             var flag03 bool = 5 < 9
    26.             fmt.Println(flag03)
    27.     }
    28.     `
    29.     fmt.Println(s4)
    30.     //4.字符串的拼接效果：
    31.     var s5 string = "abc" + "def"
    32.     s5 += "hijk"
    33.     fmt.Println(s5)
    34.     //当一个字符串过长的时候：注意：+保留在上一行的最后
    35.     var s6 string = "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" +
    36.      "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+
    37.       "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" +
    38.        "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + 
    39.        "abc" + "def"+ "abc" + "def"
    40.     fmt.Println(s6)

    }

在这里插入图片描述

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

在这里插入图片描述

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

在这里插入图片描述
在这里插入图片描述

9、类型转换

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

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

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

  1. var n7 int64 = 12
  2. var n8 int8 = int8(n7) + 127

而这个则编译都不通过：

  1. var n9 int8 = int8(n7) + 128

10、基本类型转String

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

    package main
    import “fmt”
    func main(){

    1.     var n1 int = 19
    2.     var n2 float32 = 4.78
    3.     var n3 bool = false
    4.     var n4 byte = 'a'
    5.     //int转string %d
    6.     var s1 string = fmt.Sprintf("%d",n1)
    7.     fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
    8.     var s2 string = fmt.Sprintf("%f",n2)
    9.     fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
    10.     var s3 string = fmt.Sprintf("%t",n3)
    11.     fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
    12.     //byte转string %c
    13.     var s4 string = fmt.Sprintf("%c",n4)
    14.     fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4)    //%q即将结果用引号引起来

    }

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

    package main
    import(

    1.     "fmt"
    2.     "strconv"

    )

    func main(){

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

    }

11、String转其他类型

使用strconv包的函数

  1. package main
  2. import(
  3.         "fmt"
  4.         "strconv"
  5. )
  6. func main(){
  8.         //string-->bool
  9.         var s1 string = "true"
  10.         var b bool
  11.         //ParseBool这个函数的返回值有两个：(value bool, err error)，返回值结果不能只用一个变量去接收
  12.         //value就是我们得到的布尔类型的数据，err表示可能出现的错误
  13.         //我们只关注得到的布尔类型的数据，err可以用_直接忽略
  14.         b , _ = strconv.ParseBool(s1)
  15.         fmt.Printf("b的类型是：%T,b=%v \n",b,b)
  18.         //string---》int64
  19.         var s2 string = "19"
  20.         var num1 int64
  21.         num1,_ = strconv.ParseInt(s2,10,64)
  22.         fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)
  25.         //string-->float32/float64
  26.         var s3 string = "3.14"
  27.         var f1 float64
  28.         f1,_ = strconv.ParseFloat(s3,64)   //转float64
  29.         fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)
  31.         //注意下面转完后，输出Boolean的默认值false
  32.         var s4 string = "golang"
  33.         var b1 bool
  34.         b1 , _ = strconv.ParseBool(s4)
  35.         fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)   
  38.         //无效转，最后输出int的默认值0
  39.         var s5 string = "golang"
  40.         var num2 int64
  41.         num2,_ = strconv.ParseInt(s5,10,64)
  42.         fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)
  43. }

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

发表评论

表情：
评论列表 （有 0 条评论，210人围观）

还没有评论，来说两句吧...

相关阅读

    相关 go的基本数据类型

    Go 语言中的基本数据类型主要有 整型，浮点型，布尔型 和 字符串类型。 整型 说到整型，你可能就想到 int，但实际上 int 不能代表 Go 中的所有整型。Go语言

    旧城等待，旧城等待，/ 0 赞/ 503 阅读

    相关 Go——基本数据类型

    基本数据类型 G0是一种强类型的静态编译语言，类型是高级语言的基础，有了类型，高级语言才能对不同类型抽象出不同的运算，编程者才能在更高的抽象层次上操纵数据，而不用关注具体

    快来打我*快来打我*/ 0 赞/ 169 阅读

    相关 go语言基本数据类型

    Go语言中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道（channel）等。Go 语言的基本类型和其他语言大同小异。

    今天药忘吃喽~今天药忘吃喽~/ 0 赞/ 169 阅读