GO语言学习（二）
数据类型
变量声明
在 Go 语言中，通过 var 声明语句来定义一个变量，定义的时候需要指定这个变量的类型，然后再为它起个名字，并且设置好变量的初始值。所以 var 声明一个变量的格式如下：
var 变量名 类型 = 表达式
演示代码：
package main
import "fmt"
func main() {
var i int = 10
fmt.Println(i)
}
输出如下：
因为 Go 语言具有类型推导功能，所以也可以不去刻意地指定变量的类型，而是让 Go 语言自己推导，比如变量 i 也可以用如下的方式声明：
var i = 10
你也可以一次声明多个变量，把要声明的多个变量放到一个括号中即可:
var (
j int= 0
k int= 1
)
同理因为类型推导，以上多个变量声明也可以用以下代码的方式书写
var (
j = 0
k = 1
)
其实不止 int 类型，我后面介绍的 float64、bool、string 等基础类型都可以被自动推导，也就是可以省略定义类型
基础类型
任何一门语言都有对应的基础类型，这些基础类型和现实中的事物一一对应，比如整型对应着 1、2、3、100 这些整数，浮点型对应着 1.1、3.4 这些小数等。Go 语言也不例外，它也有自己丰富的基础类型，常用的有：整型、浮点数、布尔型和字符串
整型
在 Go 语言中，整型分为：
- 有符号整型：如 int、int8、int16、int32 和 int64。
- 无符号整型：如 uint、uint8、uint16、uint32 和 uint64。
它们的差别在于，有符号整型表示的数值可以为负数、零和正数，而无符号整型只能为零和正数
除了有用“位”（bit）大小表示的整型外，还有 int 和 uint 这两个没有具体 bit 大小的整型，它们的大小可能是 32bit，也可能是 64bit，和硬件设备 CPU 有关
在整型中，如果能确定 int 的 bit 就选择比较明确的 int 类型，因为这会让你的程序具备很好的移植性
在 Go 语言中，还有一种字节类型 byte，它其实等价于 uint8 类型，可以理解为 uint8 类型的别名，用于定义一个字节，所以字节 byte 类型也属于整型
浮点数
浮点数就代表现实中的小数。Go 语言提供了两种精度的浮点数，分别是 float32 和 float64。项目中最常用的是 float64，因为它的精度高，浮点计算的结果相比 float32 误差会更小
package main
import "fmt"
func main() {
var f32 float32 = 2.2
var f64 float64 = 10.3456
fmt.Println("f32 is", f32, ",f64 is", f64)
}
运行结果：f32 is 2.2 ,f64 is 10.3456
对于数字类型之间，可以通过强制转换的方式：
package main
import (
"fmt"
)
func main() {
i := 10
f64 := 10.3456
i2f := float64(i)
f2i := int(f64)
fmt.Println(i2f, f64, f2i)
}
演示结果：10 10.3456 10
布尔型
一个布尔型的值只有两种：true 和 false
package main
import "fmt"
func main() {
var bf bool = false
var bt bool = true
fmt.Println("bf is", bf, ",bt is", bt)
}
演示结果：bf is false ,bt is true
字符串
Go 语言中的字符串可以表示为任意的数据
package main
import "fmt"
func main() {
var s1 string = "Hello"
var s2 string = "世界"
fmt.Println("s1 is", s1, ",s2 is", s2)
}
演示结果：s1 is Hello ,s2 is 世界
可以通过操作符 + 把字符串连接起来，这个和java中差不多
package main
import "fmt"
func main() {
var s1 string = "Hello"
var s2 string = "世界"
fmt.Println("s1+s2=", s1+s2)
}
输出结果：s1+s2= Hello世界
字符串和数字互转
Go 语言是强类型的语言，也就是说不同类型的变量是无法相互使用和计算的，这也是为了保证Go 程序的健壮性，所以不同类型的变量在进行赋值或者计算前，需要先进行类型转换
package main
import (
"fmt"
"strconv"
)
func main() {
i := 10
i2s := strconv.Itoa(i)
s2i, err := strconv.Atoi(i2s)
fmt.Println(i2s, s2i, err)
}
通过包 strconv 的 Itoa 函数可以把一个 int 类型转为 string，Atoi 函数则用来把 string 转为 int
此外，Go 语言提供了 strconv.ParseFloat、strconv.ParseBool、strconv.FormatFloat 和 strconv.FormatBool 进行互转
零值
零值其实就是一个变量的默认值，在 Go 语言中，如果我们声明了一个变量，但是没有对其进行初始化，那么 Go 语言会自动初始化其值为对应类型的零值，比如数字类的零值是 0，布尔型的零值是 false，字符串的零值是 "" 空字符串等
var zi int
var zf float64
var zb bool
var zs string
fmt.Println(zi,zf,zb,zs)
演示结果：0 0 false
变量
变量简短声明
之前写的都有一个 var 关键字，但是这样写代码很烦琐。借助类型推导，Go 语言提供了变量的简短声明 :=，结构如下
变量名:=表达式
指针
在 Go 语言中，指针对应的是变量在内存中的存储位置，也就说指针的值就是变量的内存地址。通过 & 可以获取一个变量的地址，也就是指针
在以下的代码中，pi 就是指向变量 i 的指针。要想获得指针 pi 指向的变量值，通过*pi这个表达式即可。尝试运行这段程序，会看到输出结果和变量 i 的值一样
package main
import "fmt"
func main() {
i := 10
pi := &i
fmt.Println(*pi)
}
演示结果：10
常量
常量的定义
常量的定义和变量类似，只不过它的关键字是 const
package main
import "fmt"
func main() {
const name = "老王"
fmt.Println(name)
}
演示结果：老王
在 Go 语言中，只允许布尔型、字符串、数字类型这些基础类型作为常量。
iota
iota 是一个常量生成器，它可以用来初始化相似规则的常量，避免重复的初始化。假设我们要定义 one、two、three 和 four 四个常量，对应的值分别是 1、2、3 和 4，如果不使用 iota，则需要按照如下代码的方式定义
package main
import "fmt"
func main() {
const (
one = 1
two = 2
three = 3
four = 4
)
fmt.Println(one,two,three,four)
}
其等于下面这种写法：
package main
import "fmt"
func main() {
const(
one = iota+1
two
three
four
)
fmt.Println(one,two,three,four)
}
Strings 包
Go SDK 为我们提供的一个标准包 strings。它是用于处理字符串的工具包，里面有很多常用的函数，帮助我们对字符串进行操作，比如查找字符串、去除字符串的空格、拆分字符串、判断字符串是否有某个前缀或者后缀等
package main
import (
"fmt"
"strings"
)
func main() {
s1 := "Hello"
//判断s1的前缀是否是H
fmt.Println(strings.HasPrefix(s1, "H"))
//在s1中查找字符串o
fmt.Println(strings.Index(s1, "o"))
//把s1全部转为大写
fmt.Println(strings.ToUpper(s1))
}
本篇文章详细的介绍了go中常用的变量，便于后面的go研发
