当请求新输入时如何终止控制台输入请求

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《当请求新输入时如何终止控制台输入请求》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

当请求新的控制台输入请求时，我需要终止现有的控制台输入请求。以下代码尝试使用通道关闭现有请求，但它似乎并未终止输入请求。

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "strings"
    "time"
)

func main() {
    go Confirm("you are a programmer, aint you?")
    time.Sleep(2 * time.Second)
    Confirm("do you love go?")
}

var cancelChannel chan struct{}

func Confirm(s string) bool {
    //check if channel type holds a value then close the channel to remove previous confirmation input
    if cancelChannel != nil {
        fmt.Println("channel to be closed")
        close(cancelChannel)
    }
    cancelChannel = make(chan struct{})
    reader := bufio.NewReader(os.Stdin)
    for {
        fmt.Printf("%s [y/n]: ", s)

        response, err := reader.ReadString('\n')
        if err != nil {
            log.Fatal(err)
        }

        response = strings.ToLower(strings.TrimSpace(response))

        if response == "y" || response == "yes" {
            return true
        } else if response == "n" || response == "no" {
            return false
        }

        if _, ok := <-cancelChannel; !ok {
            fmt.Println("channel closed")
            return false
        }

    }
}

正确答案

正如 @jimb 在评论中提到的，你不能中断 stdin 上的读取，尽管有一些阴暗的技巧可以实现它。可以使用 syscall 复制 os.stdin 文件描述符（不推荐）并将其作为非阻塞文件打开。

package main

import (
    "bytes"
    "context"
    "errors"
    "fmt"
    "io"
    "io/fs"
    "io/ioutil"
    "os"
    "syscall"
    "time"
)

func setNonblock(f *os.File) error {
    c, err := f.SyscallConn()
    if err != nil {
        return err
    }

    var err2 error
    err = c.Control(func(fd uintptr) {
        err2 = syscall.SetNonblock(int(fd), true)
    })
    if err != nil {
        return err
    }
    return err2
}

func nonBlockingFile(f *os.File) (*os.File, error) {
    if err := setNonblock(f); err != nil {
        return nil, err
    }
    fd, err := syscall.Dup(int(f.Fd()))
    if err != nil {
        return nil, err
    }
    f2 := os.NewFile(uintptr(fd), f.Name())
    return f2, nil
}

func read(ctx context.Context, f *os.File) (io.Reader, error) {
    r, err := nonBlockingFile(f)
    if err != nil {
        return nil, err
    }
    go func() {
        defer r.Close()
        <-ctx.Done()
    }()
    buff := bytes.NewBuffer([]byte{})
    for {
        _, err := io.Copy(buff, r)
        if err != nil {
            if errors.Is(err, fs.ErrClosed) {
                break
            }
            panic(err)
        }
    }
    return buff, nil
}

func main() {
    ctx1, cancel := context.WithCancel(context.Background())
    go func() {
        time.Sleep(time.Second * 2)
        cancel()
        
    }()
    buf1, err := read(ctx1, os.Stdin)
    if err != nil {
        panic(err)
    }
    ctx2, _ := context.WithTimeout(context.Background(), time.Second*2)
    buf2, err := read(ctx2, os.Stdin)

    fmt.Println("buf1")
    fmt.Println(ioutil.ReadAll(buf1))
    fmt.Println("buf2")
    fmt.Println(ioutil.ReadAll(buf2))
}

理论要掌握，实操不能落！以上关于《当请求新输入时如何终止控制台输入请求》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！