【一Go到底】第四天---数据类型

一、数据类型

• 基本数据类型

• 数值型

• 整数类型(int,int8,int16,int32,int64,uint,uint8,uint16,uin32,uint64,byte)
• 浮点类型(float32,float64)

• 字符型(无特定字符型)

• byte 保存单个字母字符

• 布尔型(bool)

• True | False

• 字符串(string)

• string

• 派生/复杂数据类型

• 指针(Pointer)
• 数组(Arr)
• 结构体(struct)
• 管道(channel)
• 函数
• 切片(slice)
• 接口(interface)
• map

二、整数类型

2.1 整数类型-有符号

类型	有无符号	占用存储空间	范围
int8	有	1字节	-128 ~ 127
int16	有	2字节	-2^15 ~ 2^15 - 1
int32	有	4字节	-2^31 ~ 2^31 - 1
int64	有	8字节	-2^63 ~ 2^63 - 1

package main

import "fmt"

func main() {
  // int8 正确使用
  var num1 int8 = -128
  fmt.Printf("The num1:%v \n", num1)

  // int8 错误使用
  var num2 int8 = -129
  fmt.Printf("the num2:%v ", num2)
}

2.2 整数类型-无符号

类型	有无符号	占用存储空间	范围
uint8	无	1字节	0 ~ 255
uint16	无	2字节	0 ~ 2^16 - 1
uint32	无	4字节	0 ~ 2^32 - 1
uint64	无	8字节	0 ~ 2^64 - 1

package main

import "fmt"

func main() {
  // uint8 使用
  var num3 uint8 = 0
  fmt.Printf("The num3:%v\n", num3)

  // uint8 错误示范
  var num4 uint8 = -1
  fmt.Printf("The num4:%v", num4)
}

2.3 其他类型

类型	有无符号	占用存储空间	范围	备注
int	有	32位系统 4个字节	-2^31 ~ 2^31 - 1
			64位系统 8个字节	-2^63 ~ 2^63 - 1
uint	无	32位系统 4个字节	0 ~ 2^32 - 1
			64位系统 8个字节	0 ~ 2^64 - 1
rune	有	同int32	-2^31 ~ 2^31 - 1	等价int32 ,表示一个Unicode码
byte	无	等价uint8	0 ~ 255	存储字符时使用

package main

import "fmt"

func main() {
  // int类型
  var num11 int = 10010
        
        // uint类型
  // var num12 uint = -1 //报错，超出范围
  var num12 uint = 1111
  
        // byte 类型
        var num13 byte = 255

  fmt.Printf("The num11:%v\n", num11)
  fmt.Printf("The num12:%v\n", num12)
  fmt.Printf("The num13:%v", num13)
}

2.4 整型使用细节

• 整型默认为 int 类型
• int / uint 大小和系统有关
• 查看数据类型 fmt.Printf(“%T”,变量名)

package main

import "fmt"

func main() {
  // int类型
  var num11 = 10010
        
  fmt.Printf("The num13:%T", num11)
}

• 查看变量占用字节大小

package main

import "fmt"

func main() {
  var num = 10086
  fmt.Printf("num Type is: %T, num Size is:%d", num, unsafe.Sizeof(num))
}

三、浮点类型

浮点类型就是用于存放小数的类型，例如 3.141516 | 2.22 | 1.1234

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

注意：尾数部分可能会丢失精度

package main

import "fmt"

func main() {
  // float32
  var price float32 = 12.34
  fmt.Printf("Price is %v\n", price)

  var num1 float32 = -0.00001
  var num2 float64 = -7654321.0987
  fmt.Printf("num1=%v, num2=%v\n", num1, num2)

  //尾数部分可能会丢失精度
  //精度测试
  var num3 float32 = -1.12345009
  var num4 float64 = -1.12345009

  fmt.Printf("num3 = %v, num4 = %v", num3, num4)
}

四、字符类型

字符串就是一串固定长度的字符连接起来的字符序列。 Go 的字符串是由单个字节连接起来的。也
就是说对于传统的字符串是由字符组成的，而Go的字符串不同，它是由字节组成的。

package main

import "fmt"

func main() {
  // 输出对应字符 ASCII 码值

  var ch1 byte = 'a'
  var ch2 byte = 'A'
  var ch3 byte = '0'

  fmt.Printf("ch1 = %v, ch2 = %v, ch3 = %v\n", ch1, ch2, ch3)

  //直接输出字符
  fmt.Printf("ch1 = %c, ch2 = %c, ch3 = %c\n", ch1, ch2, ch3)
        
        

  
}

五、布尔类型

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

package main

import "fmt"

func main() {
  var b1 bool = true
  var b2 = false

  fmt.Printf("b1 = %v, b2 = %v\n", b1, b2)
}

六、字符串类型

字符串就是-串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。
Go语言的字符串的字节使用UTF-8编码标识Unicode文本

package main

import "fmt"

func main() {

  var name string = "一 Go 到底！"
  fmt.Printf("name : %v\n", name)

  // 在go中，字符串一旦赋值，无法修改
  //错误示范
  // var str1 = "abcd"
  // str1[0] = 0 //这里会报错，无法编译成功

  // 字符串两种表示形式
  // 1.双引号 - 会识别转义字符
  // 2.反引号(ESC下面那个) 以字符串原生形式输出，包括换行以及特殊字符，实现防攻击、输出源代码

  str2 := "abc\nabc"
  fmt.Println(str2)

  str3 := `
  package main

  import "fmt"

  func main() {

    var name string = "一 Go 到底！"
    fmt.Printf("name : %v\n", name)

    // 在go中，字符串一旦赋值，无法修改
    //错误示范
    // var str1 = "abcd"
    // str1[0] = 0 //这里会报错，无法编译成功

    // 字符串两种表示形式
    // 1.双引号 - 会识别转义字符
    // 2.反引号(ESC下面那个) 以字符串原生形式输出，包括换行以及特殊字符，实现防攻击、输出源代码

    str2 := "abc\nabc"
    fmt.Println(str2)
  `
  fmt.Println(str3)

  // 字符串拼接使用 + 或 +=
  str4 := "abc" + "def"
  str4 += "g"
  fmt.Println(str4)

  


}

七、基本数据类型默认值

数据类型	默认值
整型	0
浮点型	0
字符串	“”
布尔型	false

八、基本数据类型转换

Golang和java/c不同，Go在不同类型的变量之间赋值时需要显式转换。也就是说Golang中数据类型不能自动转换。

8.1 基本数据类型互转

package main

import "fmt"

func main() {

  // 定义一个整型
  var i int32 = 123

  //转换为 float类型
  var j float32 = float32(i)

  // 低精度 -》 高精度
  var k int64 = int64(i)

  fmt.Printf("i = %v, j = %v, k=%v j-type:%T\n", i, j, k, j)
}

8.2 基本数据类型转 string

8.2.1 Sprintf

Sprintf根据format参数生成格式化的字符串并返回该字符串。

package main

import "fmt"

func main() {

  // 基本数据类型 转 string
  var num1 int = 100
  var num2 float64 = 1.23456
  var b1 bool = true
  var ch1 byte = 'a'
  var str1 string // 定义为空字符串
  // 使用 fmt.Sprintf 转换

  str1 = fmt.Sprintf("%d", num1)
  fmt.Printf("str1 type : %T, str1 = %q\n", str1, str1)

  str2 := fmt.Sprintf("%f", num2)
  fmt.Printf("str2 type : %T, str2 = %q\n", str2, str2)

  str3 := fmt.Sprintf("%t", b1)
  fmt.Printf("str3 type : %T, str3 = %q\n", str3, str3)

  str4 := fmt.Sprintf("%c", ch1)
  fmt.Printf("str4 type : %T, str4 = %q\n", str4, str4)

}

8.2.2 使用 strconv 包

package main

import (
  "fmt"
  "strconv"
)

func main() {

  // 法2 , strconv 函数

  var num3 int = 101
  var num4 float64 = 12.3456
  var b2 bool = true

  // 这里的 10 表示 10进制
  str5 := strconv.FormatInt(int64(num3), 10)
  fmt.Printf("str5 type : %T, str5 = %q\n", str5, str5)

  // 'f' 代表转换的格式 (-ddd.ddd)
  // 10 表示精度 ，小数位保留10位
  // 64表示小数为 float64
  str6 := strconv.FormatFloat(num4, 'f', 10, 64)
  fmt.Printf("str6 type : %T, str6 = %q\n", str6, str6)

  str7 := strconv.FormatBool(b2)
  fmt.Printf("str7 type : %T, str7 = %q\n", str7, str7)
        
        // strconv 函数中的Itoa
        var num5 int64 = 123456
  str8 := strconv.Itoa(int(num5))
  fmt.Printf("str8 type:%T, str8 = %q\n", str8, str8)
}

8.3 string转基本数据类型(strconv)

package main

import (
  "fmt"
  "strconv"
)

func main() {
  // string类型转 基本数据类型
  var str1 string = "true"
  var b1 bool
  // strconv.ParseBool 返回两个值(value bool, err error)
  b1, _ = strconv.ParseBool(str1)
  fmt.Printf("b1 type:%T, b1 = %v\n", b1, b1)

  //func ParseInt(s string, base int, bitSize int) (i int64, err error)
  //返回字符串表示的整数值，接受正负号。
  var str2 string = "1234657890"
  var num1 int64
  var num2 int
  num1, _ = strconv.ParseInt(str2, 10, 64)
  //若想得到int类型，就强转
  num2 = int(num1)
  fmt.Printf("num1 type:%T, num1 = %v\n", num1, num1)
  fmt.Printf("num2 type:%T, num2 = %v\n", num2, num2)

  // func ParseFloat(s string, bitSize int) (f float64, err error)
  // 解析一个表示浮点数的字符串并返回其值。
  var str3 string = "1.23456"
  var f1 float64
  f1, _ = strconv.ParseFloat(str3, 64)
  fmt.Printf("f1 type:%T,f1 = %v\n", f1, f1)
}