Go之入门（特性、变量、常量、数据类型）

一、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 intb stringc byted []float32e func()boolf struct{x int}}//方式二：把变量定义和初始化放在一起：名字 := 表达式。//但这种方式有以下限制：1.不能提供数据类型；2.只能用在函数内部func main(){x := 10a, 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 = 100var b int = 200a, b = b, a*/package mainimport "fmt"func main(){var a int = 100b := 200fmt.Println("a = ", a," b = ", b)b, a = a, bfmt.Println("a = ", a," b = ", b)}

结果：

3.匿名变量

• Go语言中支持没有名称的变量、类型或者方法，这些统称为匿名变量，匿名变量是为了增强代码的灵活性
• 匿名变量是一个下划线"_"（被称为空白标识符），_可以像其他标识符一样用于变量的声明或者赋值（任何类型都可以赋值给它），但一旦赋值给这个标识符的值都会被抛弃，因此这些值无法在后续代码中使用
• 匿名变量，没有内存空间，不会给它分配内存

   package mainimport "fmt"func GetTheData()(int, int){a := 200b := 300return 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.12345c = 1.23455}

1.无类型常量

• Go语言中有个与其他语言不一样的地方，虽然一个常量可以是任意一个明确的基础类型的值，例如，可以是int类型的值或者string类型的值；但许多常量没有一个明确的基础类型

   //math.Pi可无类型的浮点数常量，可直接用于任意需要浮点或者复数的地方var x float32 = math.Pivar y complex128 = math.Pivar z float64 = math.Pi

• 若math.Pi已经被确定为特定类型之后，那么结果的精度可能不一样。若需要一个精确的值，则需要进行显式类型转换

   const Pi float64 = math.Pivar 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 mainimport "fmt"func main(){var x complex128 = complex(1,2) //1 + 2ivar y complex128 = complex(3,4) //3 + 4ifmt.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 mainimport "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 mainimport ("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 mainimport ("fmt")func main(){const str = `aaaabbbbccccdddd`fmt.Println(str)}

结果：

8.数据类型转换

• Go语言不存在隐式类型转换，因此类型转换必须要显式的声明：valueOfTypeB = typeB(valueOfTypeA)

   package mainimport ("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.14fmt.Println(pi)fmt.Println(int(pi))}

结果：

9.指针

• 指针在Go语言中可被拆分成两个核心概念：
  （1）类型指针，允许对这个指针类型的数据进行修改，传递数据可以使用指针，而不需要进行数据之间的拷贝。类型指针不能进行偏移和运算。
  （2）切片，由指向起始元素的原始指针、元素数量和容量组成
• 指针相关的概念：指针地址、指针类型、指针取值

(1) 指针地址和指针类型

• 指针就是存放变量的地址，一个指针变量可以指向任何一个值的内存地址。按照编译器的不同在32bit和64bit机器上，指针大小不一样，在32位机器上指针的大小为4字节，在64位机器上指针的大小为8字节。默认值为nil。缩写为ptr。
• 每个变量都有一个地址，跟c++一样，&为取地址操作符，若想获取这个变量的地址，用&即可。*为解引用操作符，可以获取到指针所指向的地址中存的值。
• 指针的类型为T

   package mainimport "fmt"func main(){a := 100b := 'a'c := "hello world"fmt.Printf("a的地址是%p, b的地址是%p，c的地址是%p\n", &a, &b, &c)aptr := &abptr := &bcptr := &cfmt.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 mainimport "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 = afmt.Println("*iptr=",*iptr)}

结果：

10.类型别名type关键字

(1) 类型别名

• Go中的类型别名的出现主要是为了解决代码升级时，迁移中存在的类型兼容性问题。在C++中，代码重构升级可以用宏快速定义一段新的代码，而Go语言中没有宏的概念。
• 写法：type int = rune
• 类型别名与类型定义表面上看只有一个等号的差异，实际区别如下：

   package mainimport "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 mainimport "fmt"func main(){type NewInt int //类型定义var a NewInt = 100 //使用类型定义，定义的新类型var b int = 200var c int = 300fmt.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 mainimport "fmt"func main(){type IntNew =  int //类型别名var a IntNew = 100 //使用类型别名，定义的新类型var b int = 200var c int = 300fmt.Println("a的值为", a)fmt.Println("b的值为", b)fmt.Println("c的值为", c)b = a //类型别名与源类型就是同一类型，故可以直接相互赋值a = cfmt.Println("a的值为", a)fmt.Println("b的值为", b)fmt.Println("c的值为", c)}

结果：