一、Go语言特性
- 语法简单
- 并发性。Go语言引入了协程goroutine，实现了并发编程
- 内存分配。Go语言为了解决高并发下内存的分配和管理，选择了tcmalloc进行内存分配（为了并发设计的高性能内存分配组件，使用cache为当前线程提供无锁分配，多个central在不同线程间平衡内存单元复用。在更高层次，heap管理大块的内存分配，用以切片成不同等级的复用内存块。快速分配和二级平衡机制，可以更高性能的进行内存分配）
- 垃圾回收。在Go中指针的运算被阻止，故垃圾回收会容易点
- 静态链接。Go的便衣只需要编译后的一个可执行文件（将运行时依赖的库直接打包到可执行文件内部），无需附加任何东西，就能部署
- 标准库。Go的标准库比较丰富
- 工具链。无论是编译、格式化、错误检查、帮助文档还是第三方包下载更新都能有对应的工具
二、Go的变量
1.变量的声明
- Go是静态语言，因此其变量必须要有明确的类型，这样编译器才能检查变量正确性
- 声明变量语法：
var 变量名 变量类型 //举例：声明两个变量都为int指针类型 var a, b *int
(1) 变量的声明
- 当一个变量被声明后，系统会自动初始化一个值。int类型初始值为0，float类型初始值为0.0，bool类型初始值为false，string类型初始值为空字符串，切片、函数、指针类型初始值为nil
- 变量命名遵循驼峰命名法，即首个单词小写，每个新单词首字母大写。如GoStudy
- 批量声明变量的格式：
//方式一：使用关键字var和花括号{}，可以将一组变量定义放在一起 var{ a int b string c byte d []float32 e func()bool f struct{ x int } } //方式二：把变量定义和初始化放在一起：名字 := 表达式。 //但这种方式有以下限制：1.不能提供数据类型；2.只能用在函数内部 func main(){ x := 10 a, s := 1, "abc" }
2.变量的初始化
- 当一个变量被声明后，系统会自动初始化一个值。int类型初始值为0，float类型初始值为0.0，bool类型初始值为false，string类型初始值为空字符串，切片、函数、指针类型初始值为nil
(1) 变量初始化语法
//方式一：var 变量名 类型 = 表达式
var a int = 10
//方式二：省略其类型，采用编译器推导类型的格式L：var 变量名 = 表达式
var a = 10
//方式三：更精简的写法，省略关键字var： 变量名 := 表达式
a := 10
//注意：
1.由于使用了:=，而不是=，因此方式三的写法的左边变量名必须是没有定义过的变量，若该变量定义过，则编译器会报错
2.在多个短变量声明和复制中，至少又一个新声明的变量出现在左值中，即使其他变量名可能是重复声明的，编译也不会出错，如下所示：
res1, err := MyTest(2)
res2, err := MyTest(3)
(2) 多重赋值
-
Go语言的多重赋值，用于变量值的互换
/* var a int = 100 var b int = 200 a, b = b, a */ package main import "fmt" func main(){ var a int = 100 b := 200 fmt.Println("a = ", a," b = ", b) b, a = a, b fmt.Println("a = ", a," b = ", b) }结果：
3.匿名变量
- Go语言中支持没有名称的变量、类型或者方法，这些统称为匿名变量，匿名变量是为了增强代码的灵活性
- 匿名变量是一个下划线”_”（被称为空白标识符），_可以像其他标识符一样用于变量的声明或者赋值（任何类型都可以赋值给它），但一旦赋值给这个标识符的值都会被抛弃，因此这些值无法在后续代码中使用
- 匿名变量，没有内存空间，不会给它分配内存
package main import "fmt" func GetTheData()(int, int){ a := 200 b := 300 return a, b } func main(){ a, _ := GetTheData() _, b := GetTheData() fmt.Printf("a=%d, b=%d",a, b) }结果：
4.变量作用域
- 局部变量：函数内定义的变量，作用域是函数体内，函数调用结束后，变量会被销毁。形参的作用域跟局部变量一样。
- 全局变量：函数外定义的变量，全局变量的声明必须用关键字var。若全局变量和局部变量同名，在函数内以局部变量为准。
三、Go的常量和const
- 和C++一样，Go中是用const关键字来定义常量，常量是在编译时创建的，值在创建后就不会改变
//常量的声明 const a = 3.1415926 //常量的批量声明 const{ b = 2.12345 c = 1.23455 }
1.无类型常量
- Go语言中有个与其他语言不一样的地方，虽然一个常量可以是任意一个明确的基础类型的值，例如，可以是int类型的值或者string类型的值；但许多常量没有一个明确的基础类型
//math.Pi可无类型的浮点数常量，可直接用于任意需要浮点或者复数的地方 var x float32 = math.Pi var y complex128 = math.Pi var z float64 = math.Pi - 若math.Pi已经被确定为特定类型之后，那么结果的精度可能不一样。若需要一个精确的值，则需要进行显式类型转换
const Pi float64 = math.Pi var x float32 = Pi //x的精度就会改变 var y float32 = (float32)Pi //y进行了类型转换，精度不会变 var z complex128 = (complex128)Pi //z进行了类型转换，精度不会变
四、Go的数据类型
1.Go的基本数据类型
| 类型名 | 含义 |
|---|---|
| bool | 布尔型，true、false |
| string | 字符串类型 |
| int、int8、int32、int64 | 有符号整型 |
| uint、uint8、uint16、uint32、uint64、uintptr | 无符号整型 |
| byte | 字符类型 |
| rune | 字符类型 |
| float32、float64 | 浮点型 |
| complex64、complex128 | 复数类型 |
2.整型
(1) 有符号整型
- int8表示8位有符号整型，范围是-128～127
- int16表示16位有符号整型，范围是-32768～32767
- int32表示32位有符号整型，范围是-2147483648～2147483647
- int64表示64位有符号整型，范围是-9223372036854775808～9223372036854775807
- int根据编译器和计算机硬件的不同数值大小不同，在32位机器中为32位=4字节，在64位机器中位64位=8字节
(2) 无符号整型
- uint8表示无符号8位，范围是0～255
- uint16表示无符号16位，范围是0-65535
- uint32表示无符号32位，范围是0～4294967295
- uint64表示无符号64位，范围是0～18446744073709551615
- uint：根据不同的底层平台，32 位系统是32位，64 位系统是64位
3.浮点型
- float32：32位浮点型
- float64：64位浮点型
4.布尔类型
- 布尔类型的值只有两种：true或false，默认是false
- 布尔类型无法参与数值运算，也无法与其他类型进行转换
5.复数类型
- 复数是有两个浮点数组成，一个是实部，一个是虚部。
- 复数的类型有两种：complex128（64位实数和虚数）和complex64（32位实数和虚数），复数的默认类型是complex128
- 复数也可以用 == 和 != 进行相等比较，只有两个复数的虚部和实部都相等时，它们才相等
- 复数的声明方式：
//var name complex128 = complex(x,y) package main import "fmt" func main(){ var x complex128 = complex(1,2) //1 + 2i var y complex128 = complex(3,4) //3 + 4i fmt.Println(x * y) fmt.Println(real(x * y)) fmt.Println(imag(x * y)) var z complex128 = complex(-5,10) var w complex128 = complex(5,10) fmt.Println(x * y == z) fmt.Println(x * y == w) }结果：
6.字符类型
- Go语言中字符类型有以下两种：
（1）一种是uint8类型即byte类型，代表一个ASCII码字符
（2）另一种是rune类型，代表一个UTF-8字符，当需要处理中文、日文或其他字符时，则需要用到rune类型。等价于int32类型 - byte类型时uint8的别名，使用举例：var ch byte = ‘A’
- 在ASCII码中，A的值时65，使用16进制表示为41，故下面写法是等效的：var ch byte = 65 或 var ch byte = ‘\x41’
- Go语言支持UTF-8即Unicode字符，该字符称为Unicode代码点或者runes，并在内存中用int来表示，一般使用格式U+hhhhh，其中h表示一个16进制数
- 在书写Unicode字符时，需要在16进制数前加上\u或者\U。若需要使用到4字节，则使用\u前缀；若需要使用到8字节，则使用\U前缀。
package main import "fmt" func main(){ var ch int = '\u0041' var ch2 byte = 'A' var ch3 int = '\U00000061' fmt.Println(ch, ch2, ch3) fmt.Printf("ch=%c, ch2=%c, ch3=%c", ch,ch2,ch3) }结果：
- Unicode包中内置了一些用于测试字符的函数，这些函数的返回值都是一个布尔值，如下：
（1）判断是否是字母：unicode.IsLetter(ch)
（2）判读是否是数字：unicode.IsDigit(ch)
（3）判断是否为空白字符：unicode.IsSpace(ch)package main import ( "fmt" "unicode" ) func main(){ var ch rune = 'A' var gi rune = '1' var sp rune = ' ' fmt.Println(unicode.IsLetter(ch)) fmt.Println(unicode.IsLetter(gi)) fmt.Println(unicode.IsDigit(ch)) fmt.Println(unicode.IsDigit(gi)) fmt.Println(unicode.IsSpace(sp)) }结果：
7.字符串类型
-
Go语言中字符串的内部实现使用UTF-8编码，通过rune类型，可以方便地对每个UTF-8字符进行访问。Go也支持按照传统地ASCII码地方式逐字符进行访问
-
可以用反引号’’来定义多行字符串
package main import ( "fmt" ) func main(){ const str = `aaaa bbbb cccc dddd ` fmt.Println(str) }结果：
8.数据类型转换
- Go语言不存在隐式类型转换，因此类型转换必须要显式的声明：valueOfTypeB = typeB(valueOfTypeA)
package main import ( "fmt" "math" ) func main(){ fmt.Println("int range:", math.MinInt, math.MaxInt) fmt.Println("int8 range:", math.MinInt8, math.MaxInt8) fmt.Println("int16 range:", math.MinInt16, math.MaxInt16) fmt.Println("int32 range:", math.MinInt32, math.MaxInt32) fmt.Println("int64 range:", math.MinInt64, math.MaxInt64) var a int32 = 912345678 //将a转换为十六进制，会发生数值截断 fmt.Printf("int32：0x%x, %d\n", a,a) var pi float32 = 3.14 fmt.Println(pi) fmt.Println(int(pi)) }结果：
9.指针
- 指针在Go语言中可被拆分成两个核心概念：
（1）类型指针，允许对这个指针类型的数据进行修改，传递数据可以使用指针，而不需要进行数据之间的拷贝。类型指针不能进行偏移和运算。
（2）切片，由指向起始元素的原始指针、元素数量和容量组成 - 指针相关的概念：指针地址、指针类型、指针取值
(1) 指针地址和指针类型
- 指针就是存放变量的地址，一个指针变量可以指向任何一个值的内存地址。按照编译器的不同在32bit和64bit机器上，指针大小不一样，在32位机器上指针的大小为4字节，在64位机器上指针的大小为8字节。默认值为nil。缩写为ptr。
- 每个变量都有一个地址，跟c++一样，&为取地址操作符，若想获取这个变量的地址，用&即可。*为解引用操作符，可以获取到指针所指向的地址中存的值。
- 指针的类型为T
package main import "fmt" func main(){ a := 100 b := 'a' c := "hello world" fmt.Printf("a的地址是%p, b的地址是%p，c的地址是%p\n", &a, &b, &c) aptr := &a bptr := &b cptr := &c fmt.Printf("a的地址是%p, b的地址是%p，c的地址是%p\n", aptr, bptr, cptr) fmt.Println("a的值是", *aptr) fmt.Printf("b的值是%c\n", *bptr) fmt.Println("c的值是", *cptr) //指针的类型 fmt.Printf("aptr的类型是%T\n", aptr) fmt.Printf("bptr的类型是%T\n", bptr) fmt.Printf("cptr的类型是%T\n", cptr) }结果：
- 创建指针的另一种方法：new()函数，new(类型)
package main import "fmt" func main(){ iptr := new(int) stptr := new(string) *iptr = 100 *stptr = "hello world" fmt.Println("*iptr=",*iptr) fmt.Println("*stptr=",*stptr) a := 200 *iptr = a fmt.Println("*iptr=",*iptr) }结果：
10.类型别名type关键字
(1) 类型别名
- Go中的类型别名的出现主要是为了解决代码升级时，迁移中存在的类型兼容性问题。在C++中，代码重构升级可以用宏快速定义一段新的代码，而Go语言中没有宏的概念。
- 写法：type int = rune
- 类型别名与类型定义表面上看只有一个等号的差异，实际区别如下：
package main import "fmt" type NewInt int //类型定义 type IntNew = int //类型别名 func main(){ var a NewInt //使用类型定义，定义的新类型 fmt.Printf("a的类型为:%T\n",a) var b IntNew //使用类型别名，定义的新类型 fmt.Printf("b的类型为:%T\n",b) }结果：
上述结果不难发现，a的类型是main.NewInt，即main包下定义的NewInt类型；b的类型还是int类型。而IntNew该类型只会在代码中存在，编译完成后就不会存在。
(2) 类型别名和类型定义的区别
- 类型定义：
（1）一个新定义的类型与源类型是两个不同的类型
（2）一个新定义的类型与源类型底层的类型是一样的，但是不能进行直接的赋值，可以进行显式的类型转换
（3）类型定义可以出现在函数体里package main import "fmt" func main(){ type NewInt int //类型定义 var a NewInt = 100 //使用类型定义，定义的新类型 var b int = 200 var c int = 300 fmt.Println("a的值为", a) fmt.Println("b的值为", b) fmt.Println("c的值为", c) b = int(a) a = NewInt(c) fmt.Println("a的值为", a) fmt.Println("b的值为", b) fmt.Println("c的值为", c) }结果：
- 类型别名：
（1）类型别名与源类型是同一种类型
（2）类型别名与源类型之间可以进行直接的赋值package main import "fmt" func main(){ type IntNew = int //类型别名 var a IntNew = 100 //使用类型别名，定义的新类型 var b int = 200 var c int = 300 fmt.Println("a的值为", a) fmt.Println("b的值为", b) fmt.Println("c的值为", c) b = a //类型别名与源类型就是同一类型，故可以直接相互赋值 a = c fmt.Println("a的值为", a) fmt.Println("b的值为", b) fmt.Println("c的值为", c) }结果：
