2022-5-27 实习Day46

1、汇出汇款选择直接解付查看账务可显示，待解付不显示账务资金流向，再点击解付依旧不显示问题前端代码修改。 –3小时 100%
2、代理行转汇退汇中退汇行swiftcode点击放大镜自动搜索前台代码问题排查 –2小时 70%
3、协助同事调试发报后端代码测试 –100%


Golang编程学习（part 41）

1、读写channel案例演示

【1】创建一个intChan，最多可以存放3个int，演示存放3个数据到intChan，然后再取出这三个int
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"

func main() {
    intChan := make(chan int, 3)

    intChan <- 10
    intChan <- 20
    intChan <- 30

    // 因为intChan的容量为3，再存放会报deadlock
    // intChan <- 50

    num1 := <-intChan
    num2 := <-intChan
    num3 := <-intChan

    // 因为intChan这时已经没有数据了，再取就会报告deadlock
    // num4 := <-intChan
    fmt.Printf("num1=%v num2=%v num3=%v", num1, num2, num3)
}


【2】创建一个mapChan，最多可以存放10个map[string]string的key-val，演示写入和读取
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func main() {
    mapChan := make(chan map[string]string, 2)

    mapChan <- map[string]string{"city1": "北京", "city2": "天津"}
    mapChan <- map[string]string{"hero1": "绿巨人", "hero2": "美国队长"}

    m1 := <-mapChan
    m2 := <-mapChan

    fmt.Println(m1)    //map[city1:北京 city2:天津]
    fmt.Println(m2)    //map[hero1:绿巨人 hero2:美国队长]

    fmt.Printf("%T %T", m1, m2)    //map[string]string map[string]string
}


【3】创建一个catChan，最多可以存放10个Cat结构体变量，演示写入和读取
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

type Cat struct {
    Name string
    Age  string
}

func main() {
    catChan := make(chan Cat, 10)
    catChan <- Cat{Name: "小花", Age: "3"}
    catChan <- Cat{Name: "小黑", Age: "2"}

    cat1 := <-catChan
    cat2 := <-catChan
    fmt.Println(cat1, cat2)    // {小花 3} {小黑 2}
    fmt.Printf("%T %T", cat1, cat2)    // main.Cat main.Cat
}


【4】创建一个catChan1，最多可以存放10个 *Cat 变量，演示写入和读取
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

type Cat struct {
	Name string
	Age  string
}

func main() {
	catChan := make(chan *Cat, 10)
	catChan <- &Cat{Name: "小花", Age: "3"}
	catChan <- &Cat{Name: "小黑", Age: "2"}

	cat1 := <-catChan
	cat2 := <-catChan
	fmt.Println(cat1, cat2)    // &{小花 3} &{小黑 2}
	fmt.Printf("%T %T", cat1, cat2)    // *main.Cat *main.Cat
}

【5】创建一个allChan，最多可以存放10个任意数据类型变量，演示写入和读取的用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package main

import "fmt"

func main() {
	allChan := make(chan interface{}, 10)

	cat1 := struct {
		Name string
		Age  string
	}{Name: "tom", Age: "2"}

	cat2 := struct {
		Name string
		Age  string
	}{Name: "kitty", Age: "2"}

	allChan <- cat1
	allChan <- cat2
	allChan <- 10
	allChan <- "jack"

	// 取出
	catI := <-allChan
	catII := <-allChan
	v1 := <-allChan
	v2 := <-allChan

	fmt.Printf("%T %v\n%T %v\n%T %v\n%T %v\n ", catI, catI, catII, catII, v1, v1, v2, v2)
}

/*
struct { Name string; Age string } {tom 2}
struct { Name string; Age string } {kitty 2}
int 10
string jack
*/

【6】看下面代码会输出什么？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"

type Cat struct {
    Name string
    Age  string
}

func main() {
    var allChan = make(chan interface{}, 10)
    cat1 := Cat{Name: "tom", Age: "3"}
    cat2 := Cat{Name: "kitty", Age: "2"}
    allChan <- cat1
    allChan <- cat2
    allChan <- 10
    allChan <- "jack"

    catI := <-allChan
    fmt.Println(catI.Name)
}

// ./outputtest.go:20:19: catI.Name undefined (type interface{} has no field or method Name)
1
2
3
4
5
6
7
8
9
10
11
12
13
 var allChan = make(chan interface{}, 10)
 cat1 := Cat{Name: "tom", Age: "3"}
 cat2 := Cat{Name: "kitty", Age: "2"}
 allChan <- cat1
 allChan <- cat2
 allChan <- 10
 allChan <- "jack"

 catI := <-allChan

 // 之前的写法是错误的，因为识别出他是一个interface
 // 所以要用类型断言
fmt.Printf("%v", catI.(Cat).Name)


2、channel的遍历和关闭

【1】channel的关闭

使用内置函数close可以关闭channel，当关闭channel后，就不能再向channel写数据了，但是仍然可以从该channel读取数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func main() {
    intChan := make(chan int, 10)
    intChan <- 100
    intChan <- 200

    close(intChan)

    // 这时候就不能再写入数到channel
    // panic: send on closed channel
    // intChan <- 300

    //当管道关闭后，读取数据是可以的
    n1 := <-intChan
    fmt.Println("n1=", n1)
}

【2】channel的遍历

channel支持for-range的方式进行遍历，请注意两个细节

  • 在遍历时，如果channel没有关闭，则会出现deadlock的错误
  • 在遍历时，如果channel已经关闭，则会正常遍历数据，数据遍历完后就会退出遍历
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    intchan := make(chan int, 100)
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 100; i++ {
	      // 放入100个数据到管道
        intchan <- rand.Intn(1000)
        //fmt.Println(len(intchan))
    }

    //fmt.Println(cap(intchan))
    // 遍历管道不能用普通的 for 循环
    /*
		for i := 0; i < len(intchan); i++ {

		}
    */

    // 在遍历时，如果channel没有关闭，则会出现deadlock错误
    // 在遍历时，如果channel已经关闭，则会正常遍历数据，遍历完后就会退出遍历
    close(intchan)
    for v := range intchan {
        fmt.Println("v= ", v)
    }
}