Go 结构体-字段-匿名函数(context.Context, string) (int, error)、context.TODO() 示例、使用上下文超时示例、time.Tick

系统管理员 2023-10-12 08:59 3阅读 0赞

#### 阅读目录 ####

*  Go 结构体-字段-匿名函数(context.Context, string) (int, error)
 *   *  context.TODO() 示例
     *  使用上下文超时示例
     *  匿名函数超时打印
     *  Go语言中，错误字符串通常以小写字母开头
     *  上下文传值并指定超时

## Go 结构体-字段-匿名函数(context.Context, string) (int, error) ##

### context.TODO() 示例 ###

package main
    
    import (
    	"context"
    	"fmt"
    	"log"
    )
    
    type MiraMenu struct {
        
    	startWatch func(context.Context, string) (int, error)
    }
    
    func main() {
        
    	// 创建一个 MiraMenu 结构体实例
    	menu := MiraMenu{
        }
    
    	// 设置 startWatch 函数
    	menu.startWatch = func(ctx context.Context, message string) (int, error) {
        
    		// 在这里实现 startWatch 函数的具体逻辑
    		// ...
    		fmt.Println("Received message:", message)
    		return len(message), nil
    	}
    
    	// 创建一个 context.Context 对象
    	ctx := context.TODO()
    
    	// 调用 startWatch 函数
    	result, err := menu.startWatch(ctx, "Hello, world!")
    	if err != nil {
        
    		log.Fatal(err)
    	}
    
    	fmt.Println("Result:", result)
    }

示例代码中，ctx := context.TODO() 的作用是创建一个空的 context.Context 对象。

> 需要注意的是，空的上下文对象在某些情况下可能不提供任何有用的功能，具体取决于你的代码逻辑。

这个示例中，ctx 变量虽然被创建了，但实际上并没有被使用到。在示例代码中，ctx 是作为参数传递给 startWatch 函数，在 startWatch 函数的实现中并没有使用到该参数。

因此，ctx 并没有实际的作用，它可以被省略而不影响程序的逻辑和结果。这可能是因为示例代码中的 startWatch 函数并没有需要使用上下文的需求。

### 使用上下文超时示例 ###

package main
    
    import (
    	"context"
    	"fmt"
    	"log"
    	"time"
    )
    
    type MiraMenu struct {
        
    	startWatch func(context.Context, string) (int, error)
    }
    
    func main() {
        
    	// 创建一个 MiraMenu 结构体实例
    	menu := MiraMenu{
        }
    
    	// 设置 startWatch 函数
    	menu.startWatch = func(ctx context.Context, message string) (int, error) {
        
    		select {
        
    		case <-ctx.Done():
    			// 超时错误
    			fmt.Println("Timeout error:", ctx.Err())
    		case <-time.After(3 * time.Second):
    			// 模拟耗时操作
    			fmt.Println("Operation completed")
    		}
    
    		// 在这里实现 startWatch 函数的具体逻辑
    		fmt.Println("Received message:", message)
    		return len(message), nil
    	}
    
    	// 创建一个带超时的上下文对象
    	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    	defer cancel()
    
    	// 调用 startWatch 函数
    	result, err := menu.startWatch(ctx, "Hello, world!")
    	if err != nil {
        
    		log.Fatal(err)
    	}
    
    	fmt.Println("Result:", result)
    }

PS E:\TEXT\test> go run .\test.go
    Timeout error: context deadline exceeded
    Received message: Hello, world!
    Result: 13
    PS E:\TEXT\test>

使用 select 语句同时监听 ctx.Done() 和 time.After 通道。

如果超时发生，ctx.Done() 会被关闭，case <-ctx.Done() 分支会被执行，从而打印超时错误信息。

如果耗时操作完成，time.After(3 \* time.Second) 会发送一个值到通道，case <-time.After(3 \* time.Second) 分支会被执行，从而打印 “Operation completed”。

> 注意：超时要用 time.After

### 匿名函数超时打印 ###

package main
    
    import (
    	"context"
    	"fmt"
    	"time"
    )
    
    func main() {
        
    	// 创建一个带超时的上下文对象
    	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    	defer cancel()
    
    	// 在 goroutine 中执行耗时操作
    	func(ctx context.Context) {
        
    		select {
        
    		case <-ctx.Done():
    			// 超时错误
    			fmt.Println("Timeout error:", ctx.Err())
    		case <-time.After(3 * time.Second):
    			// 模拟耗时操作
    			fmt.Println("Operation completed")
    		}
    	}(ctx)
    
    	// 等待上下文超时
    	<-ctx.Done()
    }

PS E:\TEXT\test> go run .\test.go
    Timeout error: context deadline exceeded
    PS E:\TEXT\test>

### Go语言中，错误字符串通常以小写字母开头 ###

在Go语言中，错误字符串通常以小写字母开头，因为它们被认为是局部的错误描述，而不是完整的句子或段落。将错误字符串以小写字母开头可以与其他常规错误消息保持一致，并且符合Go语言的命名约定。

为了修复这个问题，您可以将错误字符串首字母改为小写字母。例如，将"Timeout error"修改为"timeout error"。

![在这里插入图片描述][194834d66631496798f10f94040ec225.png]  
这个问题是由静态代码分析工具staticcheck中的规则ST1005引起的。规则ST1005指出错误的字符串应该使用小写字母开头。

通过将错误字符串首字母改为小写字母，代码就符合了规则ST1005的要求。

请注意，修复这个问题是可选的，因为它只是一条静态代码分析工具的建议。在实际运行中，这不会导致任何功能问题。

### 上下文传值并指定超时 ###

package main
    
    import (
    	"context"
    	"fmt"
    	"time"
    )
    
    type MiraMenu struct {
        
    	startWatch func(context.Context, string) (int, error)
    }
    
    func main() {
        
    	// 创建一个 MiraMenu 结构体实例
    	menu := MiraMenu{
        }
    
    	// 设置 startWatch 函数
    	menu.startWatch = func(ctx context.Context, message string) (int, error) {
        
    		ticker := time.Tick(3 * time.Second)
    
    		for {
        
    			select {
        
    			case <-ticker:
    				// 每秒执行的操作
    				fmt.Println("Received message:", message)
    			case <-ctx.Done():
    				// 上下文取消或超时时执行的代码
    				return 0, fmt.Errorf("timeout ==== error")
    			}
    		}
    
    	}
    
    	// 创建一个带超时的上下文对象
    	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    	defer cancel()
    
    	// 调用 startWatch 函数
    	result, err := menu.startWatch(ctx, "Hello, world!")
    	if err != nil {
        
    		fmt.Println(err)
    	}
    
    	fmt.Println("Result:", result)
    }

PS E:\TEXT\test> go run .\test.go
    timeout ==== error
    Result: 0
    PS E:\TEXT\test>

`time.Tick(duration time.Duration) <-chan time.Time：` 返回一个定期发送时间的通道。每隔指定的时间间隔，通道将发送当前时间。

可以通过循环读取该通道来定期执行操作。

[194834d66631496798f10f94040ec225.png]: https://img-blog.csdnimg.cn/194834d66631496798f10f94040ec225.png