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 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)
   }

结果：
![在这里插入图片描述](https://img-blog.csdnimg.cn/674e8b65811e40f28e3fd51662bc7731.png

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)
   }