Go语言 变量与数据类型

Go语言

3. 变量与数据类型

3.1 Go语言变量

变量是用来存储用户数据的。

3.1.1 声明变量

• 标准格式

  var 变量名 变量类型
  

• 批量格式

  var(
  	a int
  	b string
  	c bool
  )
  

3.1.2 初始化变量

类型默认值：

• 整型和浮点型变量的默认值为0

• 字符串变量的默认值为空字符串

• 布尔型变量默认为false

• 切片、映射、函数和指针变量默认为nil

  nil相当于其他编程语言中的null、None和NULL等，指代零值，在Go语言中只能赋值给切片、映射、函数、接口、指针或通道类型。

1. 标准格式

   var 变量名 变量类型 = 表达式
   

2. 编译器推导类型格式

   var age = 20
   

3. 短变量声明并初始化

   age := 30
   

package main
import "fmt"

func main() {
   name, age := "Tom", 18
   fmt.Println("name", name)
   fmt.Println("age", age)
}

package main
import "fmt"

func main() {
   var name string
   name, age := "Tom", 18
   fmt.Println("name:", name)
   fmt.Println("age:", age)
}

【注意】在多个短变量声明并初始化中，应至少有一个新声明的变量出现在左值中，这样即使其他变量名存在重复声明的情况，编译器也不会报错。

3.1.3 变量值交换

package main

import "fmt"

func main() {
   a := 1
   b := 2
   a, b = b, a
   fmt.Println(a)
   fmt.Println(b)
}

3.1.4 匿名变量

在赋值给多个变量时，如果存在不需要接收值的变量，可以使用匿名变量来代替。

package main

import "fmt"

func ReturnData() (int, int) {
   return 10, 20
}

func main() {
   a, _ := ReturnData()
   _, b := ReturnData()
   fmt.Println(a, b)
}

3.2 Go语言数据类型

3.2.1 整型

整型主要分为有符号整型和无符号整型两大类：

• 有符号整型：int8、int16、int32、int64
• 无符号整型：uint8、uint16、uint32、uint64

有符号整型其二进制最高位储存符号，因此两者的区别就是无符号整型可以存放的正数范围比有符号整型中的正数范围大一倍。int16的范围为-32768（即-2^{15）到32767（即2}15-1），uint16的范围为0到65535（即2^16-1）

package main
import "fmt"

func main() {
   a := 3
   b := 2
   fmt.Println(a / b)
}

【注意】在Go语言中，对于两个整型变量的除法运算，小数部分将会直接被截取，只取整数部分，不会存在四舍五入的情况。

3.2.2 浮点型

Go语言支持两种浮点数：float32和float64。float32浮点数的最大范围约为3.4e38，float64浮点数最大范围约为1.8e308。

package main

import (
   "fmt"
   "reflect"
)

func main() {
   a := 3.0
   b := 2.0
   fmt.Println(a / b)
   fmt.Println("变量a的类型为：", reflect.TypeOf(a))
   fmt.Println("变量b的类型为：", reflect.TypeOf(b))
}

3.2.3 字符串

Go语言中，字符串的值为双引号中的内容，而且可以直接输入中文。

输入多行字符串的情况，此时需要使用“`”字符，即反引号。

package main

import (
   "fmt"
)

func main() {
   str1 := "丁家雄"
   str2 := `第一行
第二行
第三行
`
   fmt.Println(str1)
   fmt.Println(str2)
}

3.2.4 字符与转义字符

1. 字符

   字符串中的每个元素就是字符。

   Go语言中，字符的值为单引号中的内容，而且可以直接输入中文。

   字符类型：

   • uint8类型：代表了ASCII码的一个字符。
   • rune类型：代表了UTF格式的一个字符（如中文、日文或其他复合字符），本质是int32类型。

   package main
   
   import "fmt"
   
   func main() {
      en := 'a'
      ch := '我'
      fmt.Println(en)
      fmt.Println(ch)
   }
   

   

2. 转义字符

   使用反斜线“\”来对字符进行转义

   Go语言常见转义符

   转义符	含义
   \n	换行符
   \r	回车符
   \t	制表符
   \’	单引号
   \"	双引号
   \\	反斜杠

3.2.5 布尔型

布尔型是最简单的数据类型，只有两个值：false（假）和true（真）。

package main

import "fmt"

func main() {
   var a bool
   fmt.Println(a)
   a = true
   fmt.Println(a)
}

3.2.6 数据类型判断

用Go语言标准库中的reflect包，通过将变量传入此包的TypeOf()方法，得到变量的数据类型。

3.2.7 数据类型转换

Go语言常见的数据类型之间能够互相进行类型转换，通过使用类型前置加小括号的方式进行。

package main

import (
   "fmt"
   "reflect"
)

func main() {
   var a int16 = 97
   fmt.Println("变量a值为：", a, ",变量类型为：", reflect.TypeOf(a))
   b := int32(a)
   fmt.Println("变量b值为：", b, ",变量类型为：", reflect.TypeOf(b))
   fmt.Println("转换变量b类型为string：", string(b))
}

【注意】变量进行转换后，变量原本的值会发生改变

3.3 指针

Go语言的指针则更加高效和安全。

3.3.1 声明指针

var 变量名 ＊int

package main

import "fmt"

func main() {
   var p *int
   fmt.Println(p)
}

由于指针变量未指向任何地址，所以打印值为nil。

3.3.2 取变量地址

Go语言中，使用操作符“&”取变量地址，取得的地址值可以赋给指针变量。

package main

import "fmt"

func main() {
   num := 1
   var p *int
   p = &num
   fmt.Println("num变量的地址为：", p)
   fmt.Println("指针变量p的地址为", &p)
}

由于指针变量本身也是变量，因此指针变量在计算机内存中也有自己的地址。

3.3.3 获取指针所指向的内容

指针变量存储的值为地址值，通过在指针变量前面加上“*”符号可以获取指针所指向地址值的内容。

package main

import "fmt"

func main() {
   num := 1
   var p *int
   p = &num
   fmt.Println("num变量的地址为", p)
   fmt.Println("指针变量p的地址为：", &p)
   fmt.Println("指针变量p所指向的内容：", *p)
}

【注意】p指针声明后其值为nil，这时如果获取指针p指向的地址内容，则会出错。

3.3.4 使用指针修改值

在指针变量有实际指向的地址值后，可以通过如下格式直接修改指针所指向内存地址的内容。

＊变量名 =修改值

package main

import "fmt"

func main() {
   num := 1
   var p *int
   p = &num
   fmt.Println("指针变量p所指向的内容：", *p)
   *p = 10
   fmt.Println("指针变量p所指向的内容：", *p)
}

在使用指针修改值时也需注意，也可使用new()函数来给指针分配地址并初始化地址对应的值

package main

import "fmt"

func main() {
   var p *int
   p = new(int)
   fmt.Println(*p)
   *p = 10
   fmt.Println(*p)
}

3.4 其他数据类型

除了以上类型，Go语言还有切片、通道、map（映射）和函数等类型。

3.6 拓展

3.6.1 字符串的应用

• 字符串拼接

  Go语言的字符串拼接操作可以通过“+”操作符来完成。

  当需要拼接的字符串较长时，使用“+”操作符进行字符串的拼接并不高效，因此推荐使用字节缓冲的方式来进行。

  package main
  
  import (
     "bytes"
     "fmt"
     "reflect"
  )
  
  func main() {
     a := "012345"
     b := "6789"
     var c bytes.Buffer
     c.WriteString(a)
     c.WriteString(b)
     fmt.Println(c.String())
     fmt.Println(reflect.TypeOf(c))
  }
  

  

• 字符串截取

  str := "Go语言"
  index := strings.Index(str, "语")
  fmt.Println(index) # 2
  
  str := "Go语言,Python语言"
  index := strings.LastIndex(str, "语")
  fmt.Println(index) #15
  
  切片
  str[index:]
  

• 修改字符串

  Go语言无法对字符串直接进行修改，只能将字符串转换为字节数组后再进行操作。

  package main
  
  import "fmt"
  
  func main() {
     str := "Go语言"
     bytes := []byte(str)
     for i := 0; i < 2; i++ {
        bytes[i] = ' '
     }
     fmt.Println(string(bytes))
  }
  

  

• 字符串格式化输出

  对字符串的格式化使用fmt包的Sprintf()方法。

  package main
  
  import "fmt"
  
  func main() {
     var day = 1
     var hour = 24
     str := fmt.Sprintf("%d天包含%d个小时", day, hour)
     fmt.Println(str)
  }
  

  

  常用格式化动词及其功能对照

  格式化动词	动词结构
  %v	按值的本来值输出
  %+v	在%v的基础上，对结构体字段名和值进行展开
  %#v	输出Go语言语法格式的值
  %T	输出Go语言语法格式的类型和值
  %%	输出%
  %b	整型以二进制方式显示
  %o	整型以八进制方式显示
  %d	整型以十进制方式显示
  %x	整型以十六进制方式显示
  %X	整型以十六进制方式显示，字母大写
  %U	Unicode字符
  %f	浮点数
  %p	指针，以十六进制方式显示

3.6.2 Go语言注释

Go语言中的注释必须以“//”开头。