go语言类型和常量

一、基础类型

Go语言是一种静态类型语言，这意味着所有变量的类型在编译时必须明确，并且一旦定义，类型就不能改变。

1.数字类型

整数类型
- int8：占1个字节，范围是-128到127。
- int16：占2个字节，范围是-32768到32767。
- int32：占4个字节，范围是-2147483648到2147483647。
- int64：占8个字节，范围是-9223372036854775808到9223372036854775807。
- int：根据平台不同，可以是int32或int64。
正整数类型
- uint8：占1个字节，范围是0到255。
- uint16：占2个字节，范围是0到65535。
- uint32：占4个字节，范围是0到4294967295。
- uint64：占8个字节，范围是0到18446744073709551615。
浮点数类型
- float32：32位浮点数。
- float64：64位浮点数，通常用于需要高精度的计算
复数类型
- complex64：实部和虚部都是float32。
- complex128：实部和虚部都是float64。

package mainimport "fmt"func main() {// 整数类型//var a int8 = 128 // 1. 超过范围报错var a int8 = 127var b int8 = 1fmt.Println(a + b) // 2. -128// 浮点数var c float32 = 1.555555555555555555 // 3. 1.5555556 只到小数点后七位var d float64 = 1.555555555555555555 // 4. 1.5555555555555556  到小数点后16位fmt.Println(c, d)//fmt.Println(c+d) // 5. 不同类型语言不能相加
}

2. 字符串、字节和字符类型

字符串：string，使用双引号"或反引号`` `定义。
字节类型：byte，等同于uint8，通常用于表示ASCII字符。
字符类型：rune，等同于int32，用于表示一个Unicode字符。

package mainimport "fmt"func main() {// 字符串//var a string = 'qwerty'  // 1. 单引号报错var a string = "qwerty" // 2. 使用双引号var b string = `真的假的
是真的？
是假的`fmt.Println(a)fmt.Println(b) // 3. 使用反引号// 字节类型//var c byte = 'Aa'  // 4. 长度超出，只能一个字节//var c byte = '周' // 5. 只能是ASCII所能表示的字符var c byte = 'A'fmt.Println(c)          // 6. 输出65fmt.Println(string(c))  // 7. 转换成字符输出 Afmt.Println(string(65)) // 7. 转换成字符输出 A// 字符类型var d rune = '周'fmt.Println(d)             // 8. 输出：21608fmt.Println(string(d))     // 9. 转换成字符输出：周fmt.Println(string(21608)) // 9. 转换成字符输出周
}

3. 布尔类型

布尔类型：bool，只有两个值：true和false。

二、常量

常量是指一旦被赋值后，其值就不能被改变的变量。Go语言的常量使用关键字const来定义。

常量的定义和特性
- 不变性：常量的值在初始化后不能被改变。
- 作用域：常量的作用域限定在其定义的地方，与函数或代码块内。
- 类型：Go语言中的常量可以是任何类型，包括数字、字符串、布尔值等。

Go语言常量的使用

package mainimport "fmt"// 定义常量
const school = "北京交大"func main() {// 访问全局常量fmt.Println(school) // 北京交大// 定义局部常量const school = "上海交大"fmt.Println(school) // 上海交大demo01()
}func demo01() {fmt.Println(school) // 输出全局的常量 school 北京交大
}

补充说明
- 声明关键字：使用const关键字来声明常量。
- 可读性：常量名通常使用全大写字母表示，遵循Go语言的命名习惯。
- 不能简短声明：定义常量时不需要使用:=简短声明语法，因为这会导致编译错误。
- 编译时常量：Go语言的常量在编译时就已经确定，这使得编译器可以进行优化。
- iota关键字：在Go语言中，iota是一个特殊的关键字，用于在定义一组相关常量时提供自动增量的值。
  - 示例
  - ```
  const (Monday = iota // Monday == 0Tuesday       // Tuesday == 1Wednesday     // Wednesday == 2// 以此类推...
  )
```

三、声明变量的几种方式

使用var关键字：使用var可以声明一个或多个变量，并可选地初始化它们。
```
var a int = 10
var b, c string = "hello", "world"
```
短变量声明： Go语言提供了一种更简短的变量声明方式，使用:=操作符，这种声明方式会根据赋值的值自动推断变量的类型。
```
a := 10
b, c := "hello", "world"
```
在函数内部使用短变量声明：短变量声明只能在函数内部使用，它是一种非常常见的变量声明方式，因为它可以减少代码量并提高可读性。
```
func main() {a := 10fmt.Println(a)
}
```

使用new函数： new函数可以用于分配内存，并返回一个指针，指向新分配的类型为T的零值变量。

var p *int = new(int)// 使用*操作符来访问指针指向的值，并赋值
*p = 42
// 打印指针指向的值
fmt.Println(*p) // 输出: 42

使用类型转换声明变量：如果需要声明一个变量并将其初始化为特定的类型，可以使用类型转换来实现。
```
var a int = int(10.0) // 从float64转换为int
```
使用const声明常量：虽然不是变量声明，但const用于声明编译时常量，其值在编译时就已确定，并且在运行时不可更改。
```
const Pi = 3.14159
```
多重赋值： Go语言支持多重赋值，这可以用来一次性声明和初始化多个变量。
```
a, b := 1, 2
```
使用...进行可变参数传递：在函数中，可以使用...操作符来接收不定数量的参数，这些参数被存储在一个底层为数组的变量中。
```
func sum(args ...int) int {total := 0for _, arg := range args {total += arg}return total
}
```
匿名结构体字面量：当需要创建一个结构体实例但不想显式定义结构体类型时，可以使用匿名结构体字面量。
```
var person = struct {Name stringAge  int
}{Name: "John Doe",Age:  30,
}
```