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 
    ", a)  // 10
    	fmt.Printf("%b 
    ", a)  // 1010  占位符%b表示二进制
     
    	// 八进制  以0开头
    	var b int = 077
    	fmt.Printf("%o 
    ", b)  // 77
     
    	// 十六进制  以0x开头
    	var c int = 0xff
    	fmt.Printf("%x 
    ", c)  // ff
    	fmt.Printf("%X 
    ", 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 := "你好"
    

• 字符串转义

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

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

多行字符串

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

  • s1 := `第一行
    第二行
    第三行
    
    
    	
    `
    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类型