Go 入门总结（一）

2022-03-06

字数统计: 4k字 | 阅读时长≈ 18分

摘要：go入门相关内容，参考：Go入门指南，主要总结其中：一到五章的内容。

一、基本概念

1、包相关

①第一种形式

import "fmt"
import "os"

or

import "fmt"; import "os"

②第二种形式

import (
   "fmt"
   "os"
)

import ("fmt"; "os")

2、基本类型

布尔类型：bool
整数：int、int8、int16、int32、int64
无符号整数：uint、uint8、uint16、uint32、uint64
字节：byte(和 uint8 等价)
Unicode：rune(和 int32 等价)
整数指针：uintptr(存储 uint32、uint64 的指针)
浮点数：float32、float64
复数：complex64、complex128
字符串类型：string
值类型：array(数组)、struct(结构化变量)
引用类型：slice(动态数组)、map、channel(管道)
接口：interface
函数：function

3、函数相关

函数执行顺序：init —》main

测试代码如下所示：


package main

import (
	"demo/com.th3ee9ine/servic"
	"fmt"
)

func init() {
	// 先执行
	fmt.Println("初始化.....")
}

/*
  主函数
*/
func main() {
	// 后执行
	fmt.Println("主函数......")
	fmt.Println("加法")
	fmt.Println(servic.Add(1, 2))
}

4、类型转换

在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。由于 Go 语言不存在隐式类型转换，因此所有的转换都必须显式说明，就像调用一个函数一样（类型在这里的作用可以看作是一种函数）：

1	valueOfTypeB = typeB(valueOfTypeA)

例如：

1 2	var a = 5.0 var b = int(a)

5、Go 程序的一般结构

一般结构如下：

在完成包的 import 之后，开始对常量、变量和类型的定义或声明。
如果存在 init 函数的话，则对该函数进行定义（这是一个特殊的函数，每个含有该函数的包都会首先执行这个函数）。
如果当前包是 main 包，则定义 main 函数。
然后定义其余的函数，首先是类型的方法，接着是按照 main 函数中先后调用的顺序来定义相关函数，如果有很多函数，则可以按照字母顺序来进行排序。

例子：

package main

import (
   "fmt"
)

const c = "C"

var v int = 5

type T struct{}

func init() { // initialization of package
}

func main() {
   var a int
   Func1()
   // ...
   fmt.Println(a)
}

func (t T) Method1() {
   //...
}

func Func1() { // exported function Func1
   //...
}

6、常量、变量

①常量

常量使用关键字 const 定义，用于存储不会改变的数据。

存储在常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：

const identifier [type] = value

例如：

const PI = 3.14159
const NAME string = "张三"
const beef, two, c = "eat", 2, "veg"

②常量枚举

例子如下所示：

const (
    Unknown = 0
    Female = 1
    Male = 2
)

iota 可以被用作枚举值，第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1，例子如下所示：

const (
    a = iota
    b = iota
    c = iota
)

or

const (
    a = iota
    b
    c
)

②变量

声明变量的一般形式是使用 var 关键字，例子如下所示：

var identifier type

例如：

var a int = 15
var i = 5
var b bool = false

var (
    a = 15
    b = false
    city string
)

简短形式，使用 := 赋值操作符，例如：

a, b, c := 5, 7, "abc"

这是使用变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值。

同个变量不可以多次使用 := 赋值操作符。

7、运算符

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

优先级     运算符
 7      ^ !
 6      * / % << >> & &^
 5      + - | ^
 4      == != < <= >= >
 3      <-
 2      &&
 1      ||

8、字符串

字符串是一种值类型，且值不可变，即创建某个文本后你无法再次修改这个文本的内容；更深入地讲，字符串是字节的定长数组。

Go 支持以下 2 种形式的字面值：

解释字符串：

该类字符串使用双引号括起来，其中的相关的转义字符将被替换，这些转义字符包括：

\n：换行符
\r：回车符
\t：tab 键
\u 或 \U：Unicode 字符
\\：反斜杠自身

非解释字符串：

该类字符串使用反引号括起来，支持换行，例如：

1	`This is a raw string \n` 中的 `\n\` 会被原样输出。

9、时间和日期

package main

import (
	"fmt"
	"time"
)

var week time.Duration

func main() {
	t := time.Now()
	fmt.Println(t) // e.g. Wed Dec 21 09:52:14 +0100 RST 2011
	fmt.Printf("%02d.%02d.%4d\n", t.Day(), t.Month(), t.Year())
	// 21.12.2011
	t = time.Now().UTC()
	fmt.Println(t)          // Wed Dec 21 08:52:14 +0000 UTC 2011
	fmt.Println(time.Now()) // Wed Dec 21 09:52:14 +0100 RST 2011
	// calculating times:
	week = 60 * 60 * 24 * 7 * 1e9 // must be in nanosec
	weekFromNow := t.Add(week)
	fmt.Println(weekFromNow) // Wed Dec 28 08:52:14 +0000 UTC 2011
	// formatting times:
	fmt.Println(t.Format(time.RFC822))         // 21 Dec 11 0852 UTC
	fmt.Println(t.Format(time.ANSIC))          // Wed Dec 21 08:56:34 2011
	fmt.Println(t.Format("21 Dec 2011 08:52")) // 21 Dec 2011 08:52
	s := t.Format("20060102")
	fmt.Println(t, "=>", s)
	// Wed Dec 21 08:52:14 +0000 UTC 2011 => 20111221
}

10、指针

Go 语言为程序员提供了控制数据结构的指针的能力；但是，你不能进行指针运算。

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。如下所示：

1 2	var i1 = 5 fmt.Printf("An integer: %d, it's location in memory: %p\n", i1, &i1)

Go 语言的存地址符是 *，放到一个变量前使用就会返回相应变量的内存地址。如下所示：

var intP *int = &i1

使用 intP = &i1 是合法的，此时 intP 指向 i1。
intP 存储了 i1 的内存地址；它指向了 i1 的位置，它引用了变量 i1。
指针的格式化标识符为 %p。

一个指针变量可以指向任何一个值的内存地址它指向那个值的内存地址，在 32 位机器上占用 4 个字节，在 64 位机器上占用 8 个字节，并且与它所指向的值的大小无关。

当然，可以声明指针指向任何类型的值来表明它的原始性或结构性；你可以在指针类型前面加上 * 号（前缀）来获取指针所指向的内容，这里的 * 号是一个类型更改器。使用一个指针引用一个值被称为间接引用。

当一个指针被定义后没有分配到任何变量时，它的值为 nil。

一个指针变量通常缩写为 ptr。

注意事项

1、在书写表达式类似 var p *type 时，切记在 * 号和指针名称间留有一个空格.
因为 var p*type 是语法正确的，但是在更复杂的表达式中，它容易被误认为是一个乘法表达式！

2、符号 * 可以放在一个指针前，如 *intP，那么它将得到这个指针指向地址上所存储的值；
这被称为反引用（或者内容或者间接引用）操作符；另一种说法是指针转移。

对于任何一个变量 var， 如下表达式都是正确的：var == *(&var)

3、不能得到一个文字或常量的地址，例如：
const i = 5
ptr := &i //error: cannot take the address of i
ptr2 := &10 //error: cannot take the address of 10

例子一：

package main
import "fmt"
func main() {
    var i1 = 5
    fmt.Printf("An integer: %d, its location in memory: %p\n", i1, &i1)
    var intP *int
    intP = &i1
    fmt.Printf("The value at memory location %p is %d\n", intP, *intP)
}

例子二：

package main
import "fmt"
func main() {
    s := "good bye"
    var p *string = &s
    *p = "ciao"
    fmt.Printf("Here is the pointer p: %p\n", p) // prints address
    fmt.Printf("Here is the string *p: %s\n", *p) // prints string
    fmt.Printf("Here is the string s: %s\n", s) // prints same string
}

例子三：

对一个空指针的反向引用是不合法的，并且会使程序崩溃：

package main

func main() {
	var p *int = nil
	*p = 0
}

// in Windows: stops only with: <exit code="-1073741819" msg="process crashed"/>
// runtime error: invalid memory address or nil pointer dereference

二、控制结构

if-else 结构
多返回值函数
switch 结构
for (range) 结构
标签与 goto
select 结构，用于 channel 的选择

1、if-else 结构

关键字 if 和 else 之后的左大括号 { 必须和关键字在同一行，如果你使用了 else-if 结构，则前段代码块的右大括号 } 必须和 else-if 关键字在同一行。这两条规则都是被编译器强制规定的。

如下所示：

if condition1 {
    // do something
} else if condition2 {
    // do something else
} else {
    // catch-all or default
}

if 可以包含一个初始化语句（如：给一个变量赋值）。这种写法具有固定的格式（在初始化语句后方必须加上分号）：

if initialization; condition {
    // do something
}

例子：

if val := 10; val > max {
    // do something
}

但要注意的是，使用简短方式 := 声明的变量的作用域只存在于 if 结构中（在 if 结构的大括号之间，如果使用 if-else 结构则在 else 代码块中变量也会存在）。

如果变量在 if 结构之前就已经存在，那么在 if 结构中，该变量原来的值会被隐藏。

例子：

package main

import "fmt"

func main() {
    var first int = 10
    var cond int

    if first <= 0 {

        fmt.Printf("first is less than or equal to 0\n")
    } else if first > 0 && first < 5 {

        fmt.Printf("first is between 0 and 5\n")
    } else {

        fmt.Printf("first is 5 or greater\n")
    }
    if cond = 5; cond > 10 {

        fmt.Printf("cond is greater than 10\n")
    } else {

        fmt.Printf("cond is not greater than 10\n")
    }
}

2、多返回值函数

如下所示：

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var orig string = "ABC"
    // var an int
    var newS string
    // var err error

    fmt.Printf("The size of ints is: %d\n", strconv.IntSize)
    // anInt, err = strconv.Atoi(origStr)
    an, err := strconv.Atoi(orig)
    if err != nil {
        fmt.Printf("orig %s is not an integer - exiting with error\n", orig)
        return
    }
    fmt.Printf("The integer is %d\n", an)
    an = an + 5
    newS = strconv.Itoa(an)
    fmt.Printf("The new string is: %s\n", newS)
}

习惯用法，如下所示：

value, err := pack1.Function1(param1)
if err != nil {
    fmt.Printf("An error occured in pack1.Function1 with parameter %v", param1)
    return err
}
// 未发生错误，继续执行：

由于本例的函数调用者属于 main 函数，所以程序会直接停止运行。

如果我们想要在错误发生的同时终止程序的运行，我们可以使用 os 包的 Exit 函数，如下所示：

if err != nil {
    fmt.Printf("Program stopping with error %v", err)
    os.Exit(1)
}

或者将 ok-pattern 的获取放置在 if 语句的初始化部分，然后进行判断：

1
2
3

if value, ok := readData(); ok {
	...
}

3、switch 结构

Go 语言中的 switch 结构使用上更加灵活。它接受任意形式的表达式：

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。前花括号 { 必须和 switch 关键字在同一行。

一旦成功地匹配到某个分支，在执行完相应代码后就会退出整个 switch 代码块，也就是说您不需要特别使用 break 语句来表示结束。

因此，程序也不会自动地去执行下一个分支的代码。如果在执行完每个分支的代码后，还希望继续执行后续分支的代码，可以使用 fallthrough 关键字来达到目的。

switch i {
    case 0: // 空分支，只有当 i == 0 时才会进入分支
    case 1:
        f() // 当 i == 0 时函数不会被调用
}

switch i {
    case 0: fallthrough
    case 1:
        f() // 当 i == 0 时函数也会被调用
}

使用举例：

例一：
var num1 int = 100

switch num1 {
case 98, 99:
		fmt.Println("It's equal to 98")
case 100:
		fmt.Println("It's equal to 100")
default:
		fmt.Println("It's not equal to 98 or 100")
}

例二：
var num1 int = 7

switch {
		case num1 < 0:
				fmt.Println("Number is negative")
		case num1 > 0 && num1 < 10:
				fmt.Println("Number is between 0 and 10")
		default:
				fmt.Println("Number is 10 or greater")
}

例三:
switch a, b := x[i], y[j]; {
    case a < b: t = -1
    case a == b: t = 0
    case a > b: t = 1
}

4、for (range) 结构

第一种形式

基本形式为：

1	for 初始化语句; 条件语句; 修饰语句 {}

例子：

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Printf("This is the %d iteration\n", i)
    }
}

第二种形式

基本形式为：

1	for 条件语句 {}

例子：

package main

import "fmt"

func main() {
    var i int = 5

    for i >= 0 {
        i = i - 1
        fmt.Printf("The variable i is now: %d\n", i)
    }
}

第三种形式

无限循环，基本形式为：

for { }

第四种形式

for-range 结构，一般形式为：

1
2
3

for ix, val := range coll {
...
}

要注意的是，val 始终为集合中对应索引的值拷贝，因此它一般只具有只读性质，对它所做的任何修改都不会影响到集合中原有的值（译者注：如果 val 为指针，则会产生指针的拷贝，依旧可以修改集合中的原值）。

一个字符串是 Unicode 编码的字符（或称之为 rune）集合，因此您也可以用它迭代字符串：

package main

import "fmt"

func main() {
    str := "Go is a beautiful language!"
    fmt.Printf("The length of str is: %d\n", len(str))
    for pos, char := range str {
        fmt.Printf("Character on position %d is: %c \n", pos, char)
    }
    fmt.Println()
    str2 := "Chinese: 日本語"
    fmt.Printf("The length of str2 is: %d\n", len(str2))
    for pos, char := range str2 {
        fmt.Printf("character %c starts at byte position %d\n", char, pos)
    }
    fmt.Println()
    fmt.Println("index int(rune) rune    char bytes")
    for index, rune := range str2 {
        fmt.Printf("%-2d      %d      %U '%c' % X\n", index, rune, rune, rune, []byte(string(rune)))
    }
}

5、标签与 goto

for、switch 或 select 语句都可以配合标签（label）形式的标识符使用，即某一行第一个以冒号（:）结尾的单词（gofmt 会将后续代码自动移至下一行）。

例子：

package main

import "fmt"

func main() {

LABEL1:
    for i := 0; i <= 5; i++ {
        for j := 0; j <= 5; j++ {
            if j == 4 {
                continue LABEL1
            }
            fmt.Printf("i is: %d, and j is: %d\n", i, j)
        }
    }

}

continue 语句指向 LABEL1，当执行到该语句的时候，就会跳转到 LABEL1 标签的位置。

您可以看到当 j==4 和 j==5 的时候，没有任何输出：标签的作用对象为外部循环，因此 i 会直接变成下一个循环的值，而此时 j 的值就被重设为 0，即它的初始值。

如果将 continue 改为 break，则不会只退出内层循环，而是直接退出外层循环了。

注意：

标签的名称是大小写敏感的，为了提升可读性，一般建议使用全部大写字母

例子二：

package main

func main() {
	i := 0
HERE:
	print(i)
	i++
	if i == 5 {
		return
	}
	goto HERE
}

本文作者： th3ee9ine
本文链接： https://www.blog.ajie39.top/2022/03/06/Go入门总结（一）/
版权声明： 本博客所有文章除特别声明外，均采用 LICENSE 下的许可协议。转载请注明出处！