Go语言基础

一、Go基础

标识符：

go语言中的标识符由字母数字和下划线（_）组成，并且只能以字母和下划线（_）开头

关键字:

关键字是指编程语言中预先定义好的具有特殊含义的标识符。关键字和保留字都不建议用作变量名。

Go语言有25个关键字：

Go语言有37个保留字:

1、变量声明

1. 变量的来历

   程序运行过程中的数据都是保存在内存中的，我们想要在代码中操作某个数据时就要去内存上找到这个变量，但是如果我们直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能在找到内存上对应的数据了。

2. 变量类型

   变量（Variable）的功能是存储数据。不同的变量保存数据类型可能会不一样。经过半个多世纪的发展，编程语言已经基本形成了一套固定的类型，常见的变量的数据类型有：整形、浮点型、布尔型等。

   Go语言中的每一个变量都有自己的类型，并且变量必须经过声明才能开始使用。

3. 变量的声明

   Go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明。并且Go语言的变量声明后必须使用。

• 标准声明

  Go语言的变量声明格式为：

  var 变量名 变量类型

  变量声明以关键字var开头，变量类型放在变量的后面，行尾无需分号。

  var name string
  var age int
  var isOK bool

• 批量声明

  每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量的声明

  var(
      a string
      b int
      c bool
      d float32
  )

• 变量的初始化

  Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始划操作。每个变量会被初始化成其类型的默认值，例如：整形和浮点类型变量的默认值为0。字符串变量的默认值为空字符串。布尔类型莫认为false。切片、函数、指针变量默认为nil。

  也可以在声明变量的时候为其指定初始值。变量初始化的标准格式如下：

  var 变量名 类型 = 表达式
  // 例
  var username string = "eric"
  var age int = 18

  也能一次初始化多个变量

  var name, age = "eric", 18

• 类型推导

  有时候我们会将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

  var name = "eric"
  var age = 18

• 短变量声明

  在函数内部，可以使用跟简略的:=方式声明并初始化变量。

  package main
  
  import ("fmt")
  // 全局变量m
  var m = 100
  
  func main(){
      n := 10
      m := 200  //此处声明局部变量m
      fmt.PrintLn(m,n)
  }

• 匿名变量

  在使用多重赋值的时候，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。匿名变量用一个下划线_表示，例如：

  func foo() (int, string){
      return 18, "eric"
  }
  func main() {
      x,_ := foo()
      _,y := foo()
      fmt.Println("x=", x)
      fmt.Println("y=", y)
  }

  匿名变量不占命名空间，不会分配内存，所以匿名变量之间不存在重复声明。（在Lua等变编程语言里，匿名变量也被叫做哑圆变量。）

  注意事项：

1. 函数外的每个语句都必须以关键字开始（var、const、func等）
2. :=不能使用在函数外。
3. _多用于占位，表示忽略值。
4. go语言中变量声明必须使用，不适用就编译不过去
5. 同一个作用域（{}）中不能重复声明同名的变量

2、常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。常量的声明和变量的声明非常类似，只是把var换成了const，常量在定义的时候必须赋值。

const pi = 3.14159275453
const e = 2.7182

声明了pi e 这两个常量之后，在整个程序运行期间他们的值都不能再发生变化了。多个常量也可以一起声明：

const(
    pi = 3.14159275453
    e = 2.7182
)

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。例如：

const(
    n1 = 100
    n2
    n3
)
// n1,n2,n3的值都是100

3、iota

使用_跳过某些值

const(
    n1 = iote // 第一次默认为0
    n2        // 1
    _
    n4        //3
)

iota声明中间插队

const(
    n1 = iota // 0
    n2 = 100  // 100
    n3 = iota // 2
    n4        // 3
)
const n5 = iota // 0

定义数量级（这里的<<表示左移操作，1<<10表示将1的二进制向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制向左移2位，也就是由10变成了1000，也就是十进制的8。）

const(
    _ = iota
    KB = 1<<(10*iota)
    MB = 1<<(10*iota)
    GB = 1<<(10*iota)
    TB = 1<<(10*iota)
    PB = 1<<(10*iota)
)

多个iota定义在一行

const(
    a, b = iota + 1, iota + 2  // 1,2
    c, d                       // 2,3
    e, f                       // 3,4
)

二、Go的基本数据类型

Go语言中有丰富的数据类型，除了基本的整形、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道（channel）等。Go语言的基本数据类型和其它语言大同小异。

1、整形

基本整形

整形分为以下两个大类：

• 按长度分为：int8、int16、int32、int64
• 对应的无符号整形：uint8、uint16、uint32、uint64

其中，uint8是我们常用和熟知的byte型，int16对应C语言中的shot型（C：短整型），int64对应C语言中的long型（C：长整型）。

特殊整形

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

注意事项：获取对象的长度的内建len()函数返回值的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或map的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台的字节长度影响，不要使用int和uint。

数字字面量语法（Number literals syntax）

Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：v:=0b001101101，代表二进制的101101，相当于十进制的45。v:=0o377，代表八进制的377，相当于十进制的255。v:=0x1p-2，代表十六进制的1除以22，也就是0.25。

package main
 
import "fmt"
 
func main(){
    // 十进制
    var a int = 10
    fmt.Printf("%d \n", a)  // 10
    fmt.Printf("%b \n", a)  // 1010  占位符%b表示二进制
 
    // 八进制  以0开头
    var b int = 077
    fmt.Printf("%o \n", b)  // 77
 
    // 十六进制  以0x开头
    var c int = 0xff
    fmt.Printf("%x \n", c)  // ff
    fmt.Printf("%X \n", c)  // FF
}

2、浮点型

Go语言中有两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准：flaot32的浮点最大范围约为1.8e308，可以使用一个常量定义：mathMaxFloat64。

打印浮点数时，可以使用fmt包配合动词%f，代码示例：

package main
import (
    "fmt"
    "math"
)
func main() {
    fmt.Printf("%f\n", math.Pi)
    fmt.Printf("%.2f\n", math.Pi)
    // 浮点数
    asd := 3.1415926
    fmt.Printf("%T\n", asd) // 默认Go语言中的小鼠都是float64类型
    asf := float32(3.14159)
    fmt.Printf("%T\n", asf) // 显示声明float32类型
    // asd = asf  // float32类型的值不能直接赋值给float64，反之还真不能
}

3、复数

两种数据类型complate64和complate128

package main
import (
    "fmt"
    "math"
)
func main() {
    var c1 complex64
    c1 = 1 + 2i
    var c2 complex128
    c2 = 2 + 3i
    fmt.Println(c1)
    fmt.Println(c2)
}

4、布尔值

Go语言中以bool类型进行声明布尔类型数据，布尔类型数据只有true(真)和falde(假)两个值。

注意：

1. 布尔类型变量的默认值为false。
2. Go语言中不允许将整形强制转换为布尔型。
3. 布尔型无法参予数值运算，也无法与其它类型进行转换。

5、字符串

Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64等）一样。Go语言里的字符串的内部实现使用UTF-8编码。字符串的值为双引号(“)中的内容，可以在Go语言的源码中直接添加非ASCII码字符，例如：

s1 := "hello"
s2 := "你好"

字符串转义符

Go语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表格所示。

举个例子，我们要打印一个Windows平台下的一个文件路径：

package main
import (
    "fmt"
)
func main() {
    fmt.Println("str := \"c:\\User\\AppDate\\.go\"")
}

多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号字符：

package main
import (
    "fmt"
)
func main() {
    asd := `第一行
第二行
第三行`
    fmt.Println(asd)
}

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

字符串的常用操作