前言

一直对Service Mesh相关内容比较感兴趣，后面一路学习了Dcoker、Kubernetes等相关内容，可以说是对基本概念和使用有一定了解，随着开始学习一些相关的组件的时候，发现基本上全部都是Go语言编写，虽然这几年国内还是Java这一套微服务很流行，但是我相信未来是Service Mesh的天下，居于这种背景我开始学习Go的一些语法，会做一些Java语法和Go语法的对比，废话不多说开始吧。

变量

关于变量使用分三个方面讲解，分别是变量定义、基本类型以及类型转换；

变量定义

关于变量的定义可以分为三种方式，使用var关键字、编译器自动决定以及使用:=;

使用var关键字

使用var声明变量的格式:var 变量名 变量类型，使用var可以放在函数内部也可以直接放到包内，如果觉得每行都用 var 声明变量比较烦琐，可以使用关键字 var 和括号，可以将一组变量定义放在一起。

var (
 aaa int    = 123
 bbb string = "123"
)

func main() {

 var a, b, c string = "a", "b", "c"

 var (
  ccc int    = 333
  ddd string = "444"
 )

 fmt.Println(a, b, c)
 fmt.Println(aaa, bbb, ccc, ddd)
}

编译器自动决定类型

如果觉得每次都要定义变量的类型，可以使用不指定变量的类型；

func main() {
 var e, d, f = "aaa", 789, true
 fmt.Println(e, d, f)
}

使用:=声明变量

如果觉得使用var也很麻烦，也支持不使用var声明变量；

func main() {
 e, d, f := "aaa", 789, true
 fmt.Println(e, d, f)
}

类型转换

Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明，string、int、float类型相互转换，相对于Java优势来说这个，Go会将错误的类型返回出来。

func main() {

 // string转int
 c := "123"
 d, err := strconv.Atoi(c)
 //如果异常则 err不为空
 if err != nil {
  fmt.Println(err)
 }
 fmt.Println("string转int", d)

 // string转int64  第二参数表示进制  第三个参数表示int位数
 f := "101"
 e, er := strconv.ParseInt(f, 2, 64)
 if er != nil {
  fmt.Println(er)
 }
 fmt.Println("string转int64", e)

 // string转float64 第二个参数表示float位数
 h := "123.66"
 g, er2 := strconv.ParseFloat(h, 64)
 if er2 != nil {
  fmt.Println(er2)
 }
 fmt.Println("string转float64", g)

 // int转string
 i := 100
 j := strconv.Itoa(i)

 fmt.Println("int转string", j)

 // int转float64
 k := float64(i)
 fmt.Printf("int转float64%T\n", k)
 fmt.Println("int转float64", k)

 // float转int 精度丢失
 a := 3.1245926
 b := int(a)

 fmt.Printf("float转int%T\n", a)
 fmt.Println("float转int", b)

 // float转string
 // 第二个参数格式标记    第三个参数数字位数  第四个参数float类型
 l := strconv.FormatFloat(a, 'G', 3, 64)
 fmt.Println(l)

}

基本类型

布尔值

对于布尔值和其他语言一样，布尔型数据只有true和 false两个值，需要注意的是，Go语言中布尔型无法参与数值运算，也无法与其他类型转换。

func main() {

 a := true
 var b bool

 fmt.Printf("%T\n", a)
 fmt.Printf("%T value:%v\n", b, b)
}

整型

整型分为以下两个大类： 按长度分为：int8、int16、int32、int64 对应的无符号整型：uint8、uint16、uint32、uint64，int64对应Java的Long，int32对应Java的int。

特殊整型

注意： 在使用int和 uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。

数字字面量语法

Go1.13版本之后引入了数字字面量语法，使用如下:

func main() {

    m := 10
 fmt.Printf("十进制%d \n", m)
 fmt.Printf("二进制%b \n", m)
 fmt.Printf("八进制%o \n", m)
 fmt.Printf("十六进制%x \n", m)
}

浮点型

Go语言支持两种浮点型数：float32和float64。 float32的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。 float64的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。

func main() {

 n := 10.11
 fmt.Printf("浮点型%f\n", n)
 fmt.Printf("浮点型%.2f\n", n)
}

复数

Go相比于其他语言多了一个复数的类型，复数的类型有两种，分别是 complex128（64 位实数和虚数）和 complex64（32 位实数和虚数），其中 complex128 为复数的默认类型。方便我们对一些公式进行表示，侧面说明了Go语言想充分涉猎多个领域。

func main() {
 c2 := 2 + 3i
 fmt.Println("复数声明", c2)
 fmt.Println("获取复数的实部", real(c2), ", 获取复数的虚部", imag(c2))
}

字符串

Go语言中的字符串不像其他语言占固定的字节数，Go语言的字符串是一个用UTF-8编码的变宽字符序列，它的每一个字符都用一个或多个字节表示 ，因此Go语言中字符串根据需要占用 1 至 4 个字节。在Go语言中，没有字符类型，字符类型是rune类型，rune实际是一个int32。可使用 []byte() 获取字节数，使用 []rune()获取字符，可对中文进行转换。

func main() {

 s := "a我没菜了" //UTF-8编码

 fmt.Println("遍历字节")
 for _, b := range []byte(s) {
  fmt.Printf("%X ", b)
 }
 fmt.Println()

 fmt.Println("获取字符串个数", utf8.RuneCountInString(s))

 fmt.Println("获取字节数", len(s))

 fmt.Println("遍历字符")
 bytes := []byte(s)
 for len(bytes) > 0 {
  k, v := utf8.DecodeRune(bytes)
  bytes = bytes[v:]
  fmt.Printf("%c ", k)
 }
 fmt.Println()

 for k, v := range []rune(s) {
  fmt.Printf("(%d,%c)", k, v)
 }
 fmt.Println()

}

定义字符串

1. 可以使用双引号""来定义字符串，字符串中可以使用转义字符来实现换行、缩进等效果，常用的转义字符包括：