1. go语言初识（一）

本篇博客涉及到的内容：变量和常量、iota常量生成器、类型转换

变量（Variables）和常量（Constants）

变量（Variables）

1. 定义变量
在Go中，可以使用’var‘关键字来声明一个变量，并且可以选择性地指定其类型。例如：

var age int // 声明一个整型类型的变量 age
var name string // 声明一个字符串类型的变量 name

2. 初始化变量
变量可以在声明的同时进行初始化，也可以单独进行初始化。例如：

var age int = 30	// 声明并初始化一个整型变量 age
var name string //	声明一个字符串类型的变量 name
name = 'John'	// 单独初始化变量 name

3.类型推断
在Go中，如果声明变量时不指定类型，编译器会根据右侧的值推断出变量的类型。

var age = 30 	// 编译器右侧的值推断出 age 的类型为 int

4.短变量声明
在函数内部，可以使用短变量声明语法 ‘:=’ 来声明并初始化变量，省略了 ‘var’ 关键字和类型说明。

age := 30 	// 声明并初始化一个整形的变量 age

5.变量赋值
可以使用赋值语句为变量赋新值。

age = 35 	// 为变量 age 赋新值

常量

常量类型只可以定义 bool、数值（整数、浮点数和复数）和字符串。定义的时候就指定的值， 不能修改，常量尽量全部大写。
1.定义常量
使用 ‘const’ 关键字来声明常量，并在声明时初始化。一旦初始化，常量的值在程序运行期间不能被修改。

const PI = 3.1415926	// 声明一个名为 PI 的常量，并且初始化为 3.1415926

2.类型推断
和变量类似，常量也可以根据右侧的表达式推断出类型。

const gravity = 9.8	// 编译器根据右侧的值推断出 gravity 的类型为 float64

3.常量组
在一组常量声明中，除了第一个常量外，后续常量的值可以省略，默认与前一个常量相同。

const (
	apple = '红富士'
	orange //	未指定值，默认与上一个常量相同，即 ‘红富士’
	banana //	未指定值，默认与上一个常量相同，即 ‘红富士’
)

匿名变量

在 Go 语言中，匿名变量是一种特殊的变量，它们用下划线 ‘_’ 表示。匿名变量在编程中通常用于忽略某个值的返回或在某些情况下的占位符。

1.函数返回值中的忽略
当函数返回多个值时，如果只对其中的某些值感兴趣，可以使用匿名变量来忽略其它值。例如：

package main

import "fmt"

func getData() (int, string) {
	return 10, 'Hello'
}

func main() {
	num, _ := getData()	// 忽略第二个返回值
	fmt.Println("Number", num)
}

2.忽略循环中的索引或值
在循环中，如果只需要循环的索引或值其中之一，可以使用匿名变量来忽略另一个。例如：

package main

import "fmt"

func main(){
	numbers := []int{1, 2, 3, 4, 5}
	for _, num := range numbers {
		fmt.Println(num)
	}
}

3.忽略导入包时的初始化
在导入包时，有时候只是为了执行包的初始化函数，而不需要包中的其它内容。可以使用匿名变量来忽略导入包时的初始化操作。例如：

import _ "github.com/go-sql-driver/mysql" // 导入并执行包的初始化函数，但不使用包中的其他内容

iota

在 Go 语言中，‘iota’ 是一个常量生成器，用于常量声明中生成连续的值。‘iota’ 在 ‘const’ 块内使用，每次使用 ‘iota’ 时，它的值会自动递增。通常 ‘iota’ 从0开始，每出现一次就会自增 1 。例如：

package main

import "fmt"

const (
    Sunday = iota // iota 的值为 0
    Monday        // iota 的值为 1，会自动递增
    Tuesday       // iota 的值为 2，会自动递增
    Wednesday     // iota 的值为 3，会自动递增
    Thursday      // iota 的值为 4，会自动递增
    Friday        // iota 的值为 5，会自动递增
    Saturday      // iota 的值为 6，会自动递增
)

func main() {
    fmt.Println("Sunday:", Sunday)
    fmt.Println("Monday:", Monday)
    fmt.Println("Tuesday:", Tuesday)
    fmt.Println("Wednesday:", Wednesday)
    fmt.Println("Thursday:", Thursday)
    fmt.Println("Friday:", Friday)
    fmt.Println("Saturday:", Saturday)
}

运行上述程序会输出每个常量的值：

Sunday: 0
Monday: 1
Tuesday: 2
Wednesday: 3
Thursday: 4
Friday: 5
Saturday: 6

‘iota’ 可以用于生成一系列相关的常量值，它在定义枚举类型，生成一组有规律的常量等场景下非常有用。

类型转换

在 Go 语言中，类型转换用于将一个数据类型的值转换为另一个数据类型的值。类型转换通常在两种不同类型之间进行，比如将整数转换为浮点数、将字符串转换为整数等。以下是 Go 语言中的类型转换的基本语法和示例：
基本语法

destinationType(expression)

其中，‘detinationType’ 是要转换的目标数据类型， ‘expression’ 是要转换的表达式。
** 示例**
1.整数类型转化为浮点数类型

var num1 int = 10
var num2 float64 = float64(num1)

2.浮点数类型转换为整数类型

var num3 float64 = 15.5
var num4 int = int(num3)

3.字符串类型转换为整数类型

var str string = "123"
var num5 int 
num5, _ = strconv.Atoi(str)	// 使用 strconv 包中的 Atoi 函数进行转换

4.整数类型转换为字符串类型

var num6 int = 456
var str2 string
str2 = strconv.Itoa(num6)	// 使用strconv 包中的 Itoa 函数进行转换

5.其他复杂类型的转换
对于其他复杂类型（如自定义结构体），需要进行类型断言（Type Assertion）来完成转换。