Go语言学习
|
|
386
|
1
|
Golang

Go语言学习

菜鸟链接：https://www.runoob.com/go/go-tutorial.html

hello world

// 定义包名
package main

// 导包
import "fmt"

// 程序开始执行的函数
func main() {
	fmt.Println("Hello, 世界")
}

直接执行代码：

go run hello.go

编译成二进制文件

go build hello.go

语言结构

  • 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。
  • 同一个文件夹下的文件只能有一个包名，否则编译报错。

Go语法基础语法

  • Go一行代表结束，不需要分号结尾
  • 字符串连接通过+实现。
  • Go 语言中变量的声明必须使用空格隔开，如：
var age int;
  • 使用fmt.Sprintf格式化字符串

Go语言数据类型

数字类型：uint8~uint64，int8~int64，float32/64，complex64/128。

其他数字类型：byte（类似uint8），rune（类似int32），uint（32或64），int（32或64），uintptr（无符号整型，用于存放一个指针）

Go 语言变量

声明变量的形式

var identifier type

变量声明

第一种，指定变量类型，如果没有初始化，则变量默认为零值。

var v_name v_type
v_name = value

第二种，根据值自行判定变量类型。

var v_name = value

第三种，如果变量已经使用 var 声明过了，再使用 *:=* 声明变量，就产生编译错误

v_name := value

多变量声明

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

初始化声明

使用 := 赋值操作符，只不过这种不带声明格式的只能在函数体中出现，而不可以用于全局变量的声明与赋值。

声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用（有趣）

交换变量a, b = b, a

空白标识符 _ 也被用于抛弃值，_ 实际上是一个只写变量。

Go 语言常量

const identifier [type] = value

常量还可以用作枚举：

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

常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过。

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值：

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

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

const (
    a = iota
    b
    c
)

Go 语言运算符

看了一下，和C++的没区别。

Go 语言条件语句

if最大的区别就是没有括号

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

switch最大的区别就是case最后自带break语句

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

使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

Go 语言循环语句

for

for init; condition; post { }

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

for key, value := range oldMap {
    newMap[key] = value
}

循环控制语句

break和continue都可以做到标记。

无限循环

for {}
// 或者
for true {}

Go 语言函数

函数定义

Go 语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] {
   函数体
}
func 函数名称 ( [参数列表] ) [返回类型] {
    函数体
}

函数定义解析：

  • func：函数由 func 开始声明
  • function_name：函数名称，参数列表和返回值类型构成了函数签名。
  • parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
  • return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
  • 函数体：函数定义的代码集合。

函数方法

一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。语法格式如下：

func (variable_name variable_data_type) function_name() [return_type]{
   /* 函数体*/
}

Go 语言数组

声明数组

var variable_name [SIZE] variable_type

初始化数组

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果长度不确定

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，我们还可以通过指定下标来初始化元素： （有趣）

//  将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

多维数组

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

    values := [][]int{}

    // Step 2: 使用 appped() 函数向空的二维数组添加两行一维数组
    row1 := []int{1, 2, 3}
    row2 := []int{4, 5, 6}
    values = append(values, row1)
    values = append(values, row2)

初始化

a := [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11},   /* 第三行索引为 2 */
}

**注意：**以上代码中倒数第二行的 } 必须要有逗号，因为最后一行的 } 不能单独一行，也可以写成这样：

a := [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11}}   /* 第三行索引为 2 */

向函数传递数组

方式一

形参设定数组大小：

void myFunction(param [10]int)
{
.
.
.
}

形参未设定数组大小：

void myFunction(param []int)
{
.
.
.
}

Go 语言指针

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

var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。以下是有效的指针声明：

var var_name *var-type

如何使用指针

指针使用流程：

  • 定义指针变量。
  • 为指针变量赋值。
  • 访问指针变量中指向地址的值。

在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。

实例

package main

import "fmt"

func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}

Go 语言结构体

定义结构体，有点像ts的interface

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

声明

variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

结构体指针

你可以定义指向结构体的指针类似于其他指针变量，格式如下：

var struct_pointer *Books

以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前：

struct_pointer = &Book1

使用结构体指针访问结构体成员，使用 “.” 操作符：

struct_pointer.title

Go 语言切片(Slice)

Go 语言切片是对数组的抽象。相当于可变的数组

定义切片

你可以声明一个未指定大小的数组来定义切片：

var identifier []type

切片不需要说明长度。

或使用 make() 函数来创建切片:

var slice1 []type = make([]type, len)

也可以简写为

slice1 := make([]type, len)

也可以指定容量，其中 capacity 为可选参数。

make([]T, length, capacity)

切片初始化切片初始化

s :=[] int {1,2,3 }

直接初始化切片，[] 表示是切片类型，{1,2,3} 初始化值依次是 1,2,3，其 cap=len=3。

s := arr[:]

初始化切片 s，是数组 arr 的引用。

s := arr[startIndex:endIndex]

将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片。

s := arr[startIndex:]

默认 endIndex 时将表示一直到arr的最后一个元素。

s := arr[:endIndex]

默认 startIndex 时将表示从 arr 的第一个元素开始。

s1 := s[startIndex:endIndex]

通过切片 s 初始化切片 s1。

s :=make([]int,len,cap)

通过内置函数 make() 初始化切片s，[]int 标识为其元素类型为 int 的切片。

len() 和 cap() 函数

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

append() 和 copy() 函数

如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)  
   /* 同时添加多个元素 */
  copy(numbers1,numbers)

Go 语言范围(Range)

实例

package main
import "fmt"
func main() {
    //这是我们使用range去求一个slice的和。使用数组跟这个很类似
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)
    //在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    //range也可以用在map的键值对上。
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
    //range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

最简单的循环

	nums := []int{1,2,3,4};
    length := 0;
    for range nums {                                                  
        length++;
    }
    fmt.Println( length);

Go 语言Map(集合)

定义 Map

可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

实例

countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}

Go 语言类型转换

type_name(expression)

Go 语言接口

Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。（感觉有点像java，挺抽象的，java的我就没懂）

/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

如果想要通过接口方法修改属性，需要在传入指针的结构体才行，具体代码入下的 [1] [2] 处：

type fruit interface{
    getName() string   
    setName(name string)
}
type apple struct{   
    name string
}
//[1]
func (a *apple) getName() string{   
    return a.name
}
//[2]
func (a *apple) setName(name string) {
   a.name = name
}
func testInterface(){   
    a:=apple{"红富士"}   
    fmt.Print(a.getName())   
    a.setName("树顶红")   
    fmt.Print(a.getName())
}

Go 错误处理

  • 错误：意料之内，可能出的问题, 比如网络连接超时，json解析错误等
  • 异常：意料之外，不应该出的问题,比如空指针异常，下标溢出等异常

错误处理

抛出一个Error。

golang中的error是interface类型的

type error interface {
	Error() string
}

//此方法种只有一种逻辑上的错误，不应该返回error, 推荐使用checkNumAreaB函数的写法
func checkNumArea(num int) error {
    if num > 100{
        return errors.New("超出值域")
    }
    return nil
}

func checkNumAreaB(num int) bool {
    if num > 100{
        return false
    }
    return true
}

Go 异常处理

Go 中引入的处理方式为：defer, panic, recover

defer

是go语言的延迟执行语句，用来添加函数结束时执行的代码，常用于释放某些已分配的资源、关闭数据库连接、断开socket连接、解锁一个加锁的资源。类似其他语言的finally。

多个defer语句的执行顺序是逆序执行

当出现多条 defer 语句时以逆序执行(类似栈，即后进先出)

defer与panic

1、在panic语句后面的defer语句不被执行

示例代码：

func panicDefer() {
    panic("panic")
    defer fmt.Println("defer after panic")
}

上述代码的输出如下：

panic: panic

goroutine 1 [running]:
main.panicDefer()
  E:/godemo/testdefer.go:17 +0x39
main.main()
  E:/godemo/testdefer.go:13 +0x20

Process finished with exit code 2

可以看到 defer 语句没有执行。

2、在panic语句前的defer语句会被执行

示例代码：

func deferPanic() {
    defer fmt.Println("defer before panic")
    panic("panic")
}

上述代码的输出如下：

defer before panic
panic: panic

goroutine 1 [running]:
main.deferPanic()
  E:/godemo/testdefer.go:19 +0x95
main.main()
  E:/godemo/testdefer.go:14 +0x20

Process finished with exit code 2

defer 语句输出了内容。

Go中的panic类似其它语言中的抛出异常，panic后面的代码不再执行(panic语句前面的defer语句会被执行)。

return 的实现逻辑

1、第一步给返回值赋值(若是有名返回值直接赋值，匿名返回值 则 先声明再 赋值) ;

2、第二步调用RET返回指令并传入返回值，RET会检查是否存在defer语句，若存 在就先逆序插播 defer语句 ;

3、最后 RET 携带返回值退出函数 。

可以看出 ， return 不是一个原子操作，函数返回值与 RET 返回值并不一定一致。

defer、 return、返回值三者顺序

defer、 return、返回值 三者的执行顺序是 : return 最先给返回值赋值；接着 defer 开始执行一些收尾工作；最后 RET 指令携带返回值退出函数。

panic

panic调用会使整个调用栈逆序终止，最终导致整个程序终止并输出调中栈信息。

if err != nil {
    //如果读取文件发生错误,则err不为空(nil),并终止程序
    panic(err)
}
  • 发生panic后，程序会从调用panic的函数位置或发生panic的地方立即返回，逐层向上执行函数的defer语句，然后逐层打印函数调用堆栈，直到被recover捕获或运行到最外层函数。
  • panic不但可以在函数正常流程中抛出，在defer逻辑里也可以再次调用panic或抛出panic。defer里面的panic能够被后续执行的defer捕获。

recover

方法捕获异常而避免程序终结，生产环境种必须有此操作以避免程序终止

  • recover用来捕获panic，阻止panic继续向上传递。recover()和defer一起使用，但是defer只有在后面的函数体内直接被调用才能捕获panic来终止异常，否则返回nil，异常继续向外传递。

一个比较复杂的例子

package main

import (
"fmt"
)

func main() {
  fmt.Println("外层开始")
  defer func() {
    fmt.Println("外层准备recover")
    if err := recover(); err != nil {
      fmt.Printf("%#v-%#v\n", "外层", err) // err已经在上一级的函数中捕获了，这里没有异常，只是例行先执行defer，然后执行后面的代码
    } else {
      fmt.Println("外层没做啥事")
    }
    fmt.Println("外层完成recover")
  }()
  fmt.Println("外层即将异常")
  f()
  fmt.Println("外层异常后")
  defer func() {
    fmt.Println("外层异常后defer")
  }()
}

func f() {
  fmt.Println("内层开始")
  defer func() {
    fmt.Println("内层recover前的defer")
  }()

  defer func() {
    fmt.Println("内层准备recover")
    if err := recover(); err != nil {
      fmt.Printf("%#v-%#v\n", "内层", err) // 这里err就是panic传入的内容
    }

    fmt.Println("内层完成recover")
  }()

  defer func() {
    fmt.Println("内层异常前recover后的defer")
  }()

  panic("异常信息")

  defer func() {
    fmt.Println("内层异常后的defer")
  }()

  fmt.Println("内层异常后语句") //recover捕获的一级或者完全不捕获这里开始下面代码不会再执行
}

执行结果

外层开始
外层即将异常
内层开始
内层异常前recover后的defer
内层准备recover
"内层"-"异常信息"
内层完成recover
内层recover前的defer
外层异常后
外层异常后defer
外层准备recover
外层没做啥事
外层完成recover

Go 并发

实例

package main

import (
        "fmt"
        "time"
)

func say(s string) {
        for i := 0; i < 5; i++ {
                time.Sleep(100 * time.Millisecond)
                fmt.Println(s)
        }
}

func main() {
        go say("world")
        say("hello")
}

通道（channel）

通道（channel）是用来传递数据的一个数据结构。

通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。

向 channel 传入数据， CHAN <- DATA ， CHAN 指的是目的 channel 即收集数据的一方， DATA 则是要传的数据。

从 channel 读取数据， DATA := <-CHAN ，和向 channel 传入数据相反，在数据输送箭头的右侧的是 channel，形象地展现了数据从隧道流出到变量里。

ch <- v    // 把 v 发送到通道 ch
v := <-ch  // 从 ch 接收数据
           // 并把值赋给 v

创建一个 channel， make(chan TYPE {, NUM}) TYPE 指的是 channel 中传输的数据类型，第二个参数是可选的，指的是 channel 的容量大小。

ch := make(chan int)

注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须有接收端相应的接收数据。

实例

package main

import "fmt"

func sum(s []int, c chan int) {
        sum := 0
        for _, v := range s {
                sum += v
        }
        c <- sum // 把 sum 发送到通道 c
}

func main() {
        s := []int{7, 2, 8, -9, 4, 0}

        c := make(chan int)
        go sum(s[:len(s)/2], c)
        go sum(s[len(s)/2:], c)
        x, y := <-c, <-c // 从通道 c 中接收

        fmt.Println(x, y, x+y)
}

通道缓冲区

通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：

ch := make(chan int, 100)

带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态

注意：如果通道不带缓冲，发送方会阻塞直到接收方从通道中接收了值。如果通道带缓冲，发送方则会阻塞直到发送的值被拷贝到缓冲区内；如果缓冲区已满，则意味着需要等待直到某个接收方获取到一个值。接收方在有值可以接收之前会一直阻塞。

实例

package main

import "fmt"

func main() {
    // 这里我们定义了一个可以存储整数类型的带缓冲通道
        // 缓冲区大小为2
        ch := make(chan int, 2)

        // 因为 ch 是带缓冲的通道，我们可以同时发送两个数据
        // 而不用立刻需要去同步读取数据
        ch <- 1
        ch <- 2

        // 获取这两个数据
        fmt.Println(<-ch)
        fmt.Println(<-ch)
}

Go 遍历通道与关闭通道

Go 通过 range 关键字来实现遍历读取到的数据，类似于与数组或切片。格式如下：

v, ok := <-ch

如果通道接收不到数据后 ok 就为 false，这时通道就可以使用 close() 函数来关闭。

关闭通道并不会丢失里面的数据，只是让读取通道数据的时候不会读完之后一直阻塞等待新数据写入



实例
package main

import (
        "fmt"
)

func fibonacci(n int, c chan int) {
        x, y := 0, 1
        for i := 0; i < n; i++ {
                c <- x
                x, y = y, x+y
        }
        close(c)
}

func main() {
        c := make(chan int, 10)
        go fibonacci(cap(c), c)
        // range 函数遍历每个从通道接收到的数据，因为 c 在发送完 10 个
        // 数据之后就关闭了通道，所以这里我们 range 函数在接收到 10 个数据
        // 之后就结束了。如果上面的 c 通道不关闭，那么 range 函数就不
        // 会结束，从而在接收第 11 个数据的时候就阻塞了。
        for i := range c {
                fmt.Println(i)
        }
}

Channel 是可以控制读写权限的 具体如下:

go func(c chan int) { //读写均可的channel c } (a)
go func(c <- chan int) { //只读的Channel } (a)
go func(c chan <- int) {  //只写的Channel } (a)
Golang菜鸟教程速成

评论

  1. Adobe Yu
    Windows Chrome 93.0.4577.82
    2年前
    2021-9-14 22:33:39

    我超，强啊

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				



			

				

											

							
							
						

																					

							
							
						

										
					
											
						

	

		


|´・ω・)ノ


ヾ(≧∇≦*)ゝ


(☆ω☆)


（╯‵□′）╯︵┴─┴


￣﹃￣


(/ω＼)


∠( ᐛ 」∠)＿


(๑•̀ㅁ•́ฅ)


→_→


୧(๑•̀⌄•́๑)૭


٩(ˊᗜˋ*)و


(ノ°ο°)ノ


(´இ皿இ｀)


⌇●﹏●⌇


(ฅ´ω`ฅ)


(╯°A°)╯︵○○○


φ(￣∇￣o)


ヾ(´･ ･｀｡)ノ"


( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃


(ó﹏ò｡)


Σ(っ °Д °;)っ


( ,,´･ω･)ﾉ"(´っω･｀｡)


╮(╯▽╰)╭


o(*////▽////*)q


＞﹏＜


( ๑´•ω•) "(ㆆᴗㆆ)






😂


😀


😅


😊


🙂


🙃


😌


😍


😘


😜


😝


😏


😒


🙄


😳


😡


😔


😫


😱


😭


💩


👻


🙌


🖕


👍


👫


👬


👭


🌚


🌝


🙈


💊


😶


🙏


🍦


🍉


😣






































































Source: github.com/k4yt3x/flowerhd


	

	

		
颜文字


Emoji


小恐龙


花!
	


									

			

			
			
		

	









上一篇




下一篇 






                    

                    
			        推荐文章
		            

		            



							
Go学习之字符串

							
							



							
Go开发学习

							
							



							
安装Golang