Go语言之基本数据类型

第五章 Go语言之基本数据类型

整型

类型	描述
uint8	无符号 8位整型 (0 到 255)
uint16	无符号 16位整型 (0 到 65535)
uint32	无符号 32位整型 (0 到 4294967295)
uint64	无符号 64位整型 (0 到 18446744073709551615)
int8	有符号 8位整型 (-128 到 127)
int16	有符号 16位整型 (-32768 到 32767)
int32	有符号 32位整型 (-2147483648 到 2147483647)
int64	有符号 64位整型 (-9223372036854775808 到 9223372036854775807)

• uint8就是我们熟知的byte型，int16对应C语言中的short型，int64对应C语言中的long型

特殊整型

类型	描述
uint	32位操作系统上就是uint32，64位操作系统上就是uint64
int	32位操作系统上就是int32，64位操作系统上就是int64
uintptr	无符号整型，用于存放一个指针

• 数字字面量语法

  • package main
    
    import "fmt"
    
    func main(){
        // 十进制
        var a int = 10
        fmt.Printf("%d \n", a)  // 10
        fmt.Printf("%b \n", a)  // 1010  占位符%b表示二进制
    
        // 八进制  以0开头
        var b int = 077
        fmt.Printf("%o \n", b)  // 77
    
        // 十六进制  以0x开头
        var c int = 0xff
        fmt.Printf("%x \n", c)  // ff
        fmt.Printf("%X \n", c)  // FF
    }

浮点型

• Go语言支持两种浮点型数：float32和float64

  • package main
    import (
            "fmt"
            "math"
    )
    func main() {
            fmt.Println(math.MaxFloat32)
            fmt.Println(math.MaxFloat64)
    }
    
    >>>
    3.4028234663852886e+38
    1.7976931348623157e+308

复数

• complex64和complex128

• var c1 complex64
  c1 = 1 + 2i
  var c2 complex128
  c2 = 2 + 3i
  fmt.Println(c1)
  fmt.Println(c2)

• complex64的实部和虚部为32位，complex128的实部和虚部为64位。

布尔值

• 布尔型数据只有true（真）和false（假）两个值。

备注：

1. 布尔类型变量的默认值为false。
2. Go 语言中不允许将整型强制转换为布尔型.
   • 即没有python中的0就表示False，1表示True
3. 布尔型无法参与数值运算，也无法与其他类型进行转换。

字符串

• string

• 字符串的值为双引号 ""或反引号中的内容

  • s1 := "hello"
    s2 := "你好"

• 字符串转义

  • 使用反斜杠  进行转义：\r \n 等

  • // 比如打印一个Windows平台下的一个文件路径
    package main
    import (
        "fmt"
    )
    func main() {
        fmt.Println("str := \"c:\\Code\\lesson1\\go.exe\"")
    }

多行字符串

• 多行字符串时，就必须使用反引号字符

  • s1 := `第一行
    第二行
    第三行
    \n
    \t
    `
    fmt.Println(s1)

字符串的常用操作

方法	介绍
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作,使用符号拼接

byte 和 rune 类型

• 组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（’）包裹起来

  • var a := '中'
    var b := 'x'

• Go 语言的字符有以下两种：

  • byte 型，代表了ASCII码的一个字符。
    • byte 类型实际是一个uint8类型
  • rune类型，代表一个 UTF-8字符
    • rune类型实际是一个int32。

• func main() {
    s := "hello沙河"
    for i := 0; i < len(s); i++ { //byte
        fmt.Printf("%c", s[i])
    }
    fmt.Println()
    for _, r := range s { //rune
        fmt.Printf("%c", r)
    }
  }
  
  >>>
  helloæ²æ²³
  hello沙河

修改字符串

• 要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

• func main() {
    s1 := "big"
    // 强制类型转换
    byteS1 := []byte(s1)
    byteS1[0] = 'p'
    fmt.Println(string(byteS1))
  
    s2 := "白萝卜"
    runeS2 := []rune(s2)
    runeS2[0] = '红'
    fmt.Println(string(runeS2))
  }
  
  >>>
  pig
  红萝卜

类型转换

• Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

• func sqrtDemo() {
    var a, b = 3, 4
    var c int
    // math.Sqrt()接收的参数是float64类型，需要强制转换
    c = int(math.Sqrt(float64(a*a + b*b)))
    fmt.Println(c)
  }
  
  // 将a*a + b*b的结果强制转换成float64类型