go学习

系统管理员 2023-01-01 03:37 181阅读 0赞

[https://www.runoob.com/go/go-functions.html][https_www.runoob.com_go_go-functions.html]

# 1.变量 #

1.  **第一种，指定变量类型，如果没有初始化，则变量默认为零值**。
2.  **第二种，根据值自行判定变量类型。**
3.  **第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：**
4.      v_name := value
5.  **局部变量一定要被使用**
6.  **全局变量允许声明但不使用**
7.  **如果你想要交换两个变量的值，则可以简单地使用 a, b = b, a，两个变量的类型必须是相同。**
8.  **空白标识符 \_ 也被用于抛弃值，如值 5 在：\_, b = 5, 7 中被抛弃。**
9.  **并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)。**

package main
    import "fmt"
    func main() {
    
        // 声明一个变量并初始化
        var a = "RUNOOB"
        fmt.Println(a)
    
        // 没有初始化就为零值
        var b int
        fmt.Println(b)
    
        // bool 零值为 false
        var c bool
        fmt.Println(c)
    }

以上实例执行结果为：

RUNOOB
    0
    false

*  数值类型（包括complex64/128）为 **0**
 *  布尔类型为 **false**
 *  字符串为 **""**（空字符串）
 *  以下几种类型为 **nil**：
    
    >     var a *int
    >     var a []int
    >     var a map[string] int
    >     var a chan int
    >     var a func(string) int
    >     var a error // error 是接口
    
        package main
        
        var x, y int
        var (  // 这种因式分解关键字的写法一般用于声明全局变量
            a int
            b bool
        )
        
        var c, d int = 1, 2
        var e, f = 123, "hello"
        
        //这种不带声明格式的只能在函数体中出现
        //g, h := 123, "hello"
        
        func main(){
            g, h := 123, "hello"
            println(x, y, a, b, c, d, e, f, g, h)
        }
    
    # 2.常量 #
 *  常量是一个简单值的标识符，在程序运行时，不会被修改的量。
    
    常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
 *  显式类型定义： `const b string = "abc"`
 *  隐式类型定义： `const b = "abc"`
 *  iota 用法
 *      package main
        
        import "fmt"
        
        func main() {
            const (
                    a = iota   //0
                    b          //1
                    c          //2
                    d = "ha"   //独立值，iota += 1
                    e          //"ha"   iota += 1
                    f = 100    //iota +=1
                    g          //100  iota +=1
                    h = iota   //7,恢复计数
                    i          //8
            )
            fmt.Println(a,b,c,d,e,f,g,h,i)
        }
    
    以上实例运行结果为：
    
        0 1 2 ha ha 100 100 7 8
 *  # 3.运算符 #
 *  基本同java一样
 *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyOTA3MTk1_size_16_color_FFFFFF_t_70][]

package main
    
    import "fmt"
    
    func main() {
       var a int = 4
       var b int32
       var c float32
       var ptr *int
    
       /* 运算符实例 */
       fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
       fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
       fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );
    
       /*  & 和 * 运算符实例 */
       ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
       fmt.Printf("a 的值为  %d\n", a);
       fmt.Printf("*ptr 为 %d\n", *ptr);
    }

>     第 1 行 - a 变量类型为 = int
>     第 2 行 - b 变量类型为 = int32
>     第 3 行 - c 变量类型为 = float32
>     a 的值为  4
>     *ptr 为 4

# 4 .条件语句 #

package main
    
    import "fmt"
    
    func main() {
       /* 局部变量定义 */
       var a int = 100;
     
       /* 判断布尔表达式 */
       if a < 20 {
           /* 如果条件为 true 则执行以下语句 */
           fmt.Printf("a 小于 20\n" );
       } else {
           /* 如果条件为 false 则执行以下语句 */
           fmt.Printf("a 不小于 20\n" );
       }
       fmt.Printf("a 的值为 : %d\n", a);
    
    }

# 5.循环语句 #

Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。

和 C 语言的 for 一样：

for init; condition; post { }

和 C 的 while 一样：

for condition { }

和 C 的 for(;;) 一样：

for { }

package main
    
    import "fmt"
    
    func main() {
            sum := 0
            for i := 0; i <= 10; i++ {
                    sum += i
            }
            fmt.Println(sum)
    }

**For-each range 循环**

这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。

## 实例 ##

package main
    import "fmt"
    
    func main() {
            strings := []string{"google", "runoob"}
            for i, s := range strings {
                    fmt.Println(i, s)
            }
    
    
            numbers := [6]int{1, 2, 3, 5}
            for i,x:= range numbers {
                    fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
            }  
    }

以上实例运行输出结果为:

0 google
    1 runoob
    第 0 位 x 的值 = 1
    第 1 位 x 的值 = 2
    第 2 位 x 的值 = 3
    第 3 位 x 的值 = 5
    第 4 位 x 的值 = 0
    第 5 位 x 的值 = 0

#  6.函数 #

以下实例为 max() 函数的代码，该函数传入两个整型参数 num1 和 num2，并返回这两个参数的最大值：
    
    实例
    /* 函数返回两个数的最大值 */
    func max(num1, num2 int) int {
       /* 声明局部变量 */
       var result int
    
       if (num1 > num2) {
          result = num1
       } else {
          result = num2
       }
       return result
    }

分为值传递和引用传递，值传递和java差不多，引用传递就是前边加上了指针

package main
    
    import "fmt"
    
    func main() {
       /* 定义局部变量 */
       var a int = 100
       var b int= 200
    
       fmt.Printf("交换前，a 的值 : %d\n", a )
       fmt.Printf("交换前，b 的值 : %d\n", b )
    
       /* 调用 swap() 函数
       * &a 指向 a 指针，a 变量的地址
       * &b 指向 b 指针，b 变量的地址
       */
       swap(&a, &b)
    
       fmt.Printf("交换后，a 的值 : %d\n", a )
       fmt.Printf("交换后，b 的值 : %d\n", b )
    }
    
    func swap(x *int, y *int) {
       var temp int
       temp = *x    /* 保存 x 地址上的值 */
       *x = *y      /* 将 y 值赋给 x */
       *y = temp    /* 将 temp 值赋给 y */
    }
    以上代码执行结果为：
    
    交换前，a 的值 : 100
    交换前，b 的值 : 200
    交换后，a 的值 : 200
    交换后，b 的值 : 100

# 7.变量作用域 #

*  函数内定义的变量称为局部变量
 *  函数外定义的变量称为全局变量
 *  函数定义中的变量称为形式参数

# 8.数组 #

**声明数组**

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type

以上为一维数组的定义方式。例如以下定义了数组 balance 长度为 10 类型为 float32：

var balance [10] float32

**初始化数组**

以下演示了数组初始化：

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

初始化数组中 \{\} 中的元素个数不能大于 \[\] 中的数字。

如果忽略 \[\] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

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

该实例与上面的实例是一样的，虽然没有设置数组的大小。

balance[4] = 50.0

# 9.指针 #

## Go 空指针 ##

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

nil 指针也称为空指针。

nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。

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

查看以下实例：

package main
    
    import "fmt"
    
    func main() {
       var  ptr *int
    
       fmt.Printf("ptr 的值为 : %x\n", ptr  )
    }
    以上实例输出结果为：
    
    ptr 的值为 : 0
    空指针判断：
    
    if(ptr != nil)     /* ptr 不是空指针 */
    if(ptr == nil)    /* ptr 是空指针 */

# 10.结构体 #

**结构体中属性的首字母大小写问题**

*   首字母大写相当于 public。
 *   首字母小写相当于 private。

**注意:** 这个 public 和 private 是相对于包（go 文件首行的 package 后面跟的包名）来说的。

**敲黑板，划重点**

当要将结构体对象转换为 JSON 时，对象中的属性首字母必须是大写，才能正常转换为 JSON。

示例一：

type Person struct {
    　　　Name string　　　　　　//Name字段首字母大写
    　　　age int               //age字段首字母小写
    }
    
    func main() {
    　　person:=Person{"小明",18}
    　　if result,err:=json.Marshal(&person);err==nil{  //json.Marshal 将对象转换为json字符串
    　　　　fmt.Println(string(result))
    　　}
    }
    控制台输出：
    
    {"Name":"小明"}    //只有Name，没有age

#  11.语言切片 #

**len() 和 cap() 函数**

package main
    
    import "fmt"
    
    func main() {
       var numbers = make([]int,3,5)
    
       printSlice(numbers)
    }
    
    func printSlice(x []int){
       fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
    }
    以上实例运行输出结果为:
    
    len=3 cap=5 slice=[0 0 0]

**空(nil)切片**

package main
    
    import "fmt"
    
    func main() {
       var numbers []int
    
       printSlice(numbers)
    
       if(numbers == nil){
          fmt.Printf("切片是空的")
       }
    }
    
    func printSlice(x []int){
       fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
    }
    以上实例运行输出结果为:
    
    len=0 cap=0 slice=[]
    切片是空的

**切片截取**

package main
    
    import "fmt"
    
    func main() {
       /* 创建切片 */
       numbers := []int{0,1,2,3,4,5,6,7,8}  
       printSlice(numbers)
    
       /* 打印原始切片 */
       fmt.Println("numbers ==", numbers)
    
       /* 打印子切片从索引1(包含) 到索引4(不包含)*/
       fmt.Println("numbers[1:4] ==", numbers[1:4])
    
       /* 默认下限为 0*/
       fmt.Println("numbers[:3] ==", numbers[:3])
    
       /* 默认上限为 len(s)*/
       fmt.Println("numbers[4:] ==", numbers[4:])
    
       numbers1 := make([]int,0,5)
       printSlice(numbers1)
    
       /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
       number2 := numbers[:2]
       printSlice(number2)
    
       /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
       number3 := numbers[2:5]
       printSlice(number3)
    
    }
    
    func printSlice(x []int){
       fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
    }
    执行以上代码输出结果为：
    
    len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
    numbers == [0 1 2 3 4 5 6 7 8]
    numbers[1:4] == [1 2 3]
    numbers[:3] == [0 1 2]
    numbers[4:] == [4 5 6 7 8]
    len=0 cap=5 slice=[]
    len=2 cap=9 slice=[0 1]
    len=3 cap=7 slice=[2 3 4]

**append() 和 copy() 函数**

package main
    
    import "fmt"
    
    func main() {
       var numbers []int
       printSlice(numbers)
    
       /* 允许追加空切片 */
       numbers = append(numbers, 0)
       printSlice(numbers)
    
       /* 向切片添加一个元素 */
       numbers = append(numbers, 1)
       printSlice(numbers)
    
       /* 同时添加多个元素 */
       numbers = append(numbers, 2,3,4)
       printSlice(numbers)
    
       /* 创建切片 numbers1 是之前切片的两倍容量*/
       numbers1 := make([]int, len(numbers), (cap(numbers))*2)
    
       /* 拷贝 numbers 的内容到 numbers1 */
       copy(numbers1,numbers)
       printSlice(numbers1)  
    }
    
    func printSlice(x []int){
       fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
    }
    以上代码执行输出结果为：
    
    len=0 cap=0 slice=[]
    len=1 cap=1 slice=[0]
    len=2 cap=2 slice=[0 1]
    len=5 cap=6 slice=[0 1 2 3 4]
    len=5 cap=12 slice=[0 1 2 3 4]

# 12.go的语言范围（range） #

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。

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)
        }
    }
    以上实例运行输出结果为：
    
    sum: 9
    index: 1
    a -> apple
    b -> banana
    0 103
    1 111

# 13.map #

**定义 Map**

package main
    
    import "fmt"
    
    func main() {
        var countryCapitalMap map[string]string /*创建集合 */
        countryCapitalMap = make(map[string]string)
    
        /* map插入key - value对,各个国家对应的首都 */
        countryCapitalMap [ "France" ] = "巴黎"
        countryCapitalMap [ "Italy" ] = "罗马"
        countryCapitalMap [ "Japan" ] = "东京"
        countryCapitalMap [ "India " ] = "新德里"
    
        /*使用键输出地图值 */
        for country := range countryCapitalMap {
            fmt.Println(country, "首都是", countryCapitalMap [country])
        }
    
        /*查看元素在集合中是否存在 */
        capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
        /*fmt.Println(capital) */
        /*fmt.Println(ok) */
        if (ok) {
            fmt.Println("American 的首都是", capital)
        } else {
            fmt.Println("American 的首都不存在")
        }
    }
    以上实例运行结果为：
    
    France 首都是 巴黎
    Italy 首都是 罗马
    Japan 首都是 东京
    India  首都是 新德里
    American 的首都不存在

### delete() 函数 ###

package main
    
    import "fmt"
    
    func main() {
            /* 创建map */
            countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}
    
            fmt.Println("原始地图")
    
            /* 打印地图 */
            for country := range countryCapitalMap {
                    fmt.Println(country, "首都是", countryCapitalMap [ country ])
            }
    
            /*删除元素*/ delete(countryCapitalMap, "France")
            fmt.Println("法国条目被删除")
    
            fmt.Println("删除元素后地图")
    
            /*打印地图*/
            for country := range countryCapitalMap {
                    fmt.Println(country, "首都是", countryCapitalMap [ country ])
            }
    }
    以上实例运行结果为：
    
    原始地图
    India 首都是 New delhi
    France 首都是 Paris
    Italy 首都是 Rome
    Japan 首都是 Tokyo
    法国条目被删除
    删除元素后地图
    Italy 首都是 Rome
    Japan 首都是 Tokyo
    India 首都是 New delhi

# 14.递归函数 #

## 阶乘 ##

package main
    
    import "fmt"
    
    func Factorial(n uint64)(result uint64) {
        if (n > 0) {
            result = n * Factorial(n-1)
            return result
        }
        return 1
    }
    
    func main() {  
        var i int = 15
        fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(uint64(i)))
    }
    以上实例执行输出结果为：
    
    15 的阶乘是 1307674368000

## 斐波那契数列 ##

package main
    
    import "fmt"
    
    func fibonacci(n int) int {
      if n < 2 {
       return n
      }
      return fibonacci(n-2) + fibonacci(n-1)
    }
    
    func main() {
        var i int
        for i = 0; i < 10; i++ {
           fmt.Printf("%d\t", fibonacci(i))
        }
    }
    以上实例执行输出结果为：
    
    0    1    1    2    3    5    8    13    21    34

# 15.语言类型转换 #

package main
    
    import "fmt"
    
    func main() {
       var sum int = 17
       var count int = 5
       var mean float32
       
       mean = float32(sum)/float32(count)
       fmt.Printf("mean 的值为: %f\n",mean)
    }
    以上实例执行输出结果为：
    
    mean 的值为: 3.400000

# 16.接口 #

package main
    
    import (
        "fmt"
    )
    
    type Phone interface {
        call()
    }
    
    type NokiaPhone struct {
    }
    
    func (nokiaPhone NokiaPhone) call() {
        fmt.Println("I am Nokia, I can call you!")
    }
    
    type IPhone struct {
    }
    
    func (iPhone IPhone) call() {
        fmt.Println("I am iPhone, I can call you!")
    }
    
    func main() {
        var phone Phone
    
        phone = new(NokiaPhone)
        phone.call()
    
        phone = new(IPhone)
        phone.call()
    
    }
    在上面的例子中，我们定义了一个接口Phone，接口里面有一个方法call()。然后我们在main函数里面定义了一个Phone类型变量，并分别为之赋值为NokiaPhone和IPhone。然后调用call()方法，输出结果如下：
    
    I am Nokia, I can call you!
    I am iPhone, I can call you!

# 17.错误处理 #

package main
    
    import (
        "fmt"
    )
    
    // 定义一个 DivideError 结构
    type DivideError struct {
        dividee int
        divider int
    }
    
    // 实现 `error` 接口
    func (de *DivideError) Error() string {
        strFormat := `
        Cannot proceed, the divider is zero.
        dividee: %d
        divider: 0
    `
        return fmt.Sprintf(strFormat, de.dividee)
    }
    
    // 定义 `int` 类型除法运算的函数
    func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
        if varDivider == 0 {
                dData := DivideError{
                        dividee: varDividee,
                        divider: varDivider,
                }
                errorMsg = dData.Error()
                return
        } else {
                return varDividee / varDivider, ""
        }
    
    }
    
    func main() {
    
        // 正常情况
        if result, errorMsg := Divide(100, 10); errorMsg == "" {
                fmt.Println("100/10 = ", result)
        }
        // 当除数为零的时候会返回错误信息
        if _, errorMsg := Divide(100, 0); errorMsg != "" {
                fmt.Println("errorMsg is: ", errorMsg)
        }
    
    }
    执行以上程序，输出结果为：
    
    100/10 =  10
    errorMsg is:  
        Cannot proceed, the divider is zero.
        dividee: 100
        divider: 0

# 18.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")
    }
    执行以上代码，你会看到输出的 hello 和 world 是没有固定先后顺序。因为它们是两个 goroutine 在执行：
    
    world
    hello
    hello
    world
    world
    hello
    hello
    world
    world
    hello

## 通道（channel） ##

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

以下实例通过两个 goroutine 来计算数字之和，在 goroutine 完成计算后，它会计算两个结果的和：

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)
    }
    输出结果为：
    
    -5 17 12

### 通道缓冲区 ###

带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态，就是说发送端发送的数据可以放在缓冲区里面，可以等待接收端去获取数据，而不是立刻需要接收端去获取数据。

不过由于缓冲区的大小是有限的，所以还是必须有接收端来接收数据的，否则缓冲区一满，数据发送端就无法再发送数据了。

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

package main
    
    import "fmt"
    
    func main() {
        // 这里我们定义了一个可以存储整数类型的带缓冲通道
            // 缓冲区大小为2
            ch := make(chan int, 2)
    
            // 因为 ch 是带缓冲的通道，我们可以同时发送两个数据
            // 而不用立刻需要去同步读取数据
            ch <- 1
            ch <- 2
    
            // 获取这两个数据
            fmt.Println(<-ch)
            fmt.Println(<-ch)
    }
    执行输出结果为：
    
    1
    2

### Go 遍历通道与关闭通道 ###

如果通道接收不到数据后 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)
            }
    }
    执行输出结果为：
    
    0
    1
    1
    2
    3
    5
    8
    13
    21
    34

[https_www.runoob.com_go_go-functions.html]: https://www.runoob.com/go/go-functions.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyOTA3MTk1_size_16_color_FFFFFF_t_70]: /images/20221120/d38448312f674e1fa6b46421233fe669.png