Go语言学习第一天

Go语言简介

go语言的特性：
- 一个目录下的同级文件属于同一个包。
- 包名可以与其目录名不同？。
- main包是Go语言程序的入口包，一个Go语言程序必须有且仅有一个main包，如果一个程序没有main包，那么编译事就会出错，无法生成可执行文件。(main函数只能声明在main包中)
导入的包中不能含有代码中没有使用的包，否则Go编译器会出错。

import(

"name1"

"name2"

)
func 函数名 (参数列表) (返回值列表) {

函数体

}
- go build 命令可以将Go语言程序代码编译成二进制的可执行文件，但是需要我们手动运行该二进制文件；
- go run 命令则更加方便，它会在编译后直接运行Go语言程序，编译过程中会产生一个临时文件，但不会生成可执行文件，这个特点很适合用来调试程序

Go语言基本语法

- var 变量名变量类型
- 当一个变量被声明之后，系统自动赋予它该类型的零值：int 为 0，float 为 0.0，bool 为 false，string 为空字符串，指针为 nil 等。所有的内存在 Go 中都是经过初始化的
复制代码
```
var (
    a int
    b string
    c []float32
    d func() bool
    e struct {
        x int
    }
)
```
- 名字 := 表达式 (简短变量声明被广泛用于大部分的局部变量的声明和初始化。var 形式的声明语句往往是用于需要显式指定变量类型地方，或者因为变量稍后会被重新赋值而初始值无关紧要的地方)
  - 定义变量，同时显式初始化
  - 不能提供数据类型
  - 只能用在函数内部
- 匿名变量 _ 将被抛弃
- 作用域（Go语言会在编译时检查每个变量是否使用过，一旦出现未使用的变量，就会报编译错误。如果不能理解变量的作用域，就有可能会带来一些不明所以的编译错误。）
  - 函数内定义的变量称为局部变量
  - 函数外定义的变量称为全局变量（在函数体外声明的变量称之为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，当然，不包含这个全局变量的源文件需要使用"import"关键字引入全局变量所在的源文件之后才能使用这个全局变量。）（全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写）
  - 函数定义中的变量称为形式参数
- Go语言同时提供了有符号和无符号的整数类型，其中包括 int8、int16、int32 和 int64 四种大小截然不同的有符号整数类型，分别对应 8、16、32、64 bit（二进制位）大小的有符号整数，与此对应的是 uint8、uint16、uint32 和 uint64 四种无符号整数类型。
- 浮点类型
  - 常量 math.MaxFloat32 表示 float32 能取到的最大数值，大约是 3.4e38；
  - 常量 math.MaxFloat64 表示 float64 能取到的最大数值，大约是 1.8e308；
  - float32 和 float64 能表示的最小值分别为 1.4e-45 和 4.9e-324
  - 一个 float32 类型的浮点数可以提供大约 6 个十进制数的精度，而 float64 则可以提供约 15 个十进制数的精度，通常应该优先使用 float64 类型，因为 float32 类型的累计计算误差很容易扩散，并且 float32 能精确表示的正整数并不是很大。
    复制代码
```
var f float32 = 16777216 // 1 << 24
fmt.Println(f == f+1)    // "true"!
```
  - 浮点数在声明的时候可以只写整数部分或者小数部分
    复制代码
```
const e = .71828 // 0.71828
const f = 1.     // 1
```
  - 很小或很大的数最好用科学计数法书写，通过 e 或 E 来指定指数部分
    复制代码
```
const Avogadro = 6.02214129e23  // 阿伏伽德罗常数
const Planck   = 6.62606957e-34 // 普朗克常数
```
  - 用 Printf 函数打印浮点数时可以使用"%f"来控制保留几位小数
- 复数 Go语言中复数的类型有两种，分别是 complex128（64 位实数和虚数）和 complex64（32 位实数和虚数），其中 complex128 为复数的默认类型
  - var name complex128 = complex(x, y)
  - name := complex(x, y)
  - 对于一个复数z := complex(x, y)，可以通过Go语言的内置函数real(z)来获得该复数的实部，也就是 x；通过imag(z)获得该复数的虚部，也就是 y
  - 复数也可以用==和!=进行相等比较，只有两个复数的实部和虚部都相等的时候它们才是相等的
- Go语言中不允许将整型强制转换为布尔型
- 定义字符串
  - 可以使用双引号""来定义字符串，字符串中可以使用转义字符来实现换行、缩进等效果，常用的转义字符包括：
    - \n：换行符
    - \r：回车符
    - \t：tab 键
    - \u 或 \U：Unicode 字符
    - \：反斜杠自身
  - 在Go语言中，使用双引号书写字符串的方式是字符串常见表达方式之一，被称为字符串字面量（string literal），这种双引号字面量不能跨行，如果想要在源码中嵌入一个多行字符串时，就必须使用```反引号
    复制代码
```
const str = `第一行
第二行
第三行
\r\n
`
fmt.Println(str)
```
- Go语言的字符有以下两种:
  - 一种是 uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。
    - 在 ASCII 码表中，A 的值是 65，使用 16 进制表示则为 41，所以下面的写法是等效的：
      
      var ch byte = 65 或 var ch byte = '\x41' //（\x 总是紧跟着长度为 2 的 16 进制数）
      
      另外一种可能的写法是\后面紧跟着长度为 3 的八进制数，例如 \377
  - 另一种是 rune 类型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。rune 类型等价于 int32 类型
    - Go语言同样支持 Unicode（UTF-8），因此字符同样称为 Unicode 代码点或者 runes，并在内存中使用 int 来表示。在文档中，一般使用格式 U+hhhh 来表示，其中 h 表示一个 16 进制数。
    - 在书写 Unicode 字符时，需要在 16 进制数之前加上前缀\u或者\U。因为 Unicode 至少占用 2 个字节，所以我们使用 int16 或者 int 类型来表示。如果需要使用到 4 字节，则使用\u前缀，如果需要使用到 8 个字节，则使用\U前缀。
  复制代码
```
var ch int = '\u0041'
var ch2 int = '\u03B2'
var ch3 int = '\U00101234'
fmt.Printf("%d - %d - %d\n", ch, ch2, ch3) // integer
fmt.Printf("%c - %c - %c\n", ch, ch2, ch3) // character
fmt.Printf("%X - %X - %X\n", ch, ch2, ch3) // UTF-8 bytes
fmt.Printf("%U - %U - %U", ch, ch2, ch3)   // UTF-8 code point
```
  - 格式化说明符%c用于表示字符，当和字符配合使用时，%v或%d会输出用于表示该字符的整数，%U输出格式为 U+hhhh 的字符串
  - Unicode 包中内置了一些用于测试字符的函数，这些函数的返回值都是一个布尔值，如下所示（其中 ch 代表字符）：
    - 判断是否为字母：unicode.IsLetter(ch)
    - 判断是否为数字：unicode.IsDigit(ch)
    - 判断是否为空白符号：unicode.IsSpace(ch)
- 类型 B 的值 = 类型 B(类型 A 的值)
  - valueOfTypeB = typeB(valueOfTypeA)
- 指针（pointer）在Go语言中可以被拆分为两个核心概念：
  - 类型指针，允许对这个指针类型的数据进行修改，传递数据可以直接使用指针，而无须拷贝数据，类型指针不能进行偏移和运算。
  - 切片，由指向起始元素的原始指针、元素数量和容量组成
  - 每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用在变量名前面添加&操作符（前缀）来获取变量的内存地址（取地址操作）
    - ptr := &v // v 的类型为 T
      - 其中 v 代表被取地址的变量，变量 v 的地址使用变量 ptr 进行接收，ptr 的类型为*T，称做 T 的指针类型，*代表指针
    - 量、指针和地址三者的关系是，每个变量都拥有地址，指针的值就是地址
    - 取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值
    - 变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：
      - 对变量进行取地址操作使用&操作符，可以获得这个变量的指针变量。
      - 指针变量的值是指针地址。
      - 对指针变量进行取值操作使用*操作符，可以获得指针变量指向的原变量的值。
    - Go语言还提供了另外一种方法来创建指针变量
      - new(类型)
    - 堆（heap）：堆是用于存放进程执行中被动态分配的内存段。它的大小并不固定，可动态扩张或缩减。当进程调用 malloc 等函数分配内存时，新分配的内存就被动态加入到堆上（堆被扩张）。当利用 free 等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）；
    - 栈(stack)：栈又称堆栈，用来存放程序暂时创建的局部变量，也就是我们函数的大括号{ }中定义的局部变量。
    - 在Go语言中，你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。
      - 显式类型定义： const b string = "abc"
      - 隐式类型定义： const b = "abc"