6-数据类型&&基本数据类型

Golang的数据类型

• 基本数据类型
  • 数值型
    • 整数类型: int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64、byte
    • 浮点数类型: float32、float64
  • 字符型(没有单独的字符型,使用byte来保存单个的字符)
  • 布尔型 bool
  • 字符串 string
• 派生/复杂数据类型
  • 指针
  • 数组
  • 结构体
  • 管道
  • 函数
  • 切片
  • 接口
  • map

进制和进制转换

1.二进制转十进制
二进制: 1101
1*2^3 + 1*2^2 + 0*2^1 + a*2^0
=  8 + 4 + 0 + 1 = 13

2. 十进制转二进制
十进制 13
2 | 13
  ——————
2 | 6    1
  ——————
2 | 3    0
  ——————
2 |  1   1
  _____
     0   1
1101

package main
import "fmt"

func main() {
    // 十进制
    var a int = 10
    fmt.Printf("%d\n", a)// 10  占位符%d表示十进制
    fmt.Printf("%b\n", a)// 1010 占位符%b表示二进制

    // 八进制 以0开头
    var b = 075
    fmt.Printf("%d\n", b)// 61
    fmt.Printf("%o\n", b)// 75 占位符%o表示八进制

    // 十六进制
    f := 0xff
    fmt.Printf("%d\n", f)// 255
    fmt.Printf("%x\n", f)// ff 占位符%x表示十六进制
}

整数类型

• 整数不给类型默认类型 int
• 有符号整数类型

类型     有无符号    占用存储空间    表数范围
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 ~ 255
uint16     有           2字节        0 ~2^16 - 1
uint32     有           4字节        0 ~ 2^32 - 1
uint64     有           8字节        0 ~ 2^64 - 1

• 特殊类型

package main
import (
    "fmt"
    "math"
)

func main() {
    // uint8
    var age uint8 = 255
    fmt.Println(age)

    // 浮点型 float32 float64
    // 最大值
    fmt.Println(math.MaxFloat32)// 3.4028234663852886e+38
    fmt.Println(math.MaxFloat64)// 1.7976931348623157e+308
}

布尔值

• bool类型声明的,只有2个值 true和false
• 注意:
  • 默认值false
  • Go语言不允许将整型强制转换成布尔型
  • 布尔型无法参与数值运算,也无法与其它类型进行转换

package main
import (
    "fmt"
)

func main() {
    // 布尔值
    var a bool
    fmt.Println(a)// false
    a = true
    fmt.Println(a)// true
}	

字符串

• Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容，可以在Go语言的源码中直接添加非ASCII码字符

package main
import (
    "fmt"
    "strings"
)

func main() {
    // 字符串
    a := "hello world"
    b := "hello 沫沫"
    fmt.Println(a)
    fmt.Println(b)

    // 转移符
    // 打印windows的文件路径 c:\code\t.exe
    fmt.Println("c:\\code\\t.exe")// \表示转义符
    fmt.Println("\t制表符\n换行符")// \t表示制表符 \n换行符

    // 多行字符串 `` 中间的内容会原样输出
    s := `
        多行字符串
        \t
        \n
    `
    fmt.Println(s)

    // 字符串操作
    s1 := "hello"
    fmt.Println(len(s1))// 5 返回字符串长度

    s2 := "hello 沫沫"
    fmt.Println(len(s2))// 12 中文一个算3个字节

    // 拼接字符串
    // + 拼接
    fmt.Println(s1 + s2)// hellohello 沫沫
    s3 := fmt.Sprintf("%s - %s", s1, s2)// %s占位符等待被替换
    fmt.Println(s3)//hello - hello 沫沫

    // 字符串的分割
    s4 := "how do you do"
    fmt.Println(strings.Split(s4, " "))// [how do you do]
    // 查看分割后类型 -> 切片
    fmt.Printf("%T\n", strings.Split(s4, " "))// []string
	
    //判断字符串是否包含
    fmt.Println(strings.Contains(s4, "do"))// true 

    // 判断前缀/后缀
    fmt.Println(strings.HasPrefix(s4, "how"))// true 前缀
    fmt.Println(strings.HasSuffix(s4, "how"))// false 后缀

    // 判断字串首次出现的位置
    fmt.Println(strings.Index(s4, "do"))// 4
    // 判断最后子串出现的位置
    fmt.Println(strings.LastIndex(s4, "do"))// 11

    // 把字符串切片按规则拼接 join
    s5 := []string{"how", "do", "you", "do"}
    fmt.Println(strings.Join(s5, "-"))// how-do-you-do
}	

字符

• 组成字符串的每个元素称之为字符
• ''定义字符
• 字符的分类
  • byte: uint8的别名 -> 只能表示常见的 ASCII码
  • rune: int32的别名 -> 中文类的就要用这种的了

package main
import (
	"fmt"
)

func main() {
    // 字符
    var c1 byte = 'c'
    var c2 rune = 'c'
    fmt.Println(c1, c2)// 99 99
    fmt.Printf("c1:%T c2:%T\n",c1, c2)// c1:uint8 c2:int32

    s := "hello 小白"
    for i:=0; i < len(s); i++ {
        fmt.Printf("%c\n", s[i])// %c把字符展示出来,遇到中文乱码了
    }
    
    // 处理中英文混杂的字符串时用推荐这个
    for _, r := range s {
        // 中文也能展示出来,会自动的去匹配每个字符占一个字节还是多个字节
        fmt.Printf("%c\n", r)
    }
}