go执行cmd命令并获取输出内容

func RunCMD() {
    cmd0 := exec.Command("tasklist")
    stdout0 , err := cmd0.StdoutPipe() // 获取命令输出内容
    if err != nil {
        fmt.Println(err)
        return
    }
    if err := cmd0.Start(); err != nil {  //开始执行命令
        fmt.Println(err)
        return
    }
 
    useBufferIO := false
    if !useBufferIO {
        var outputBuf0 bytes.Buffer
        for {
            tempoutput := make([]byte, 256)
            n, err := stdout0.Read(tempoutput)
            if err != nil {
                if err == io.EOF {  //读取到内容的最后位置
                    break
                } else {
                    fmt.Println(err)
                    return
                }
            }
 
            if n > 0 {
                outputBuf0.Write(tempoutput[:n])
            }
 
        }
 
        fmt.Println(outputBuf0.String())
    } else {
        outputbuf0 := bufio.NewReader(stdout0)
        touput0 , _ , err := outputbuf0.ReadLine()
        if err != nil {
            return
        }
 
        fmt.Println(string(touput0))
    }
}

管道模式

//管道模式
func RunCMDPipe()  {
    cmd1 := exec.Command("tasklist")
    var outputbuf1 bytes.Buffer
    cmd1.Stdout = &outputbuf1  //设置输入
    if err := cmd1.Start(); err != nil {
        fmt.Println(err)
        return
    }
    if err := cmd1.Wait(); err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("%s", outputbuf1.Bytes())
}

内存的命名管道实现

func MEMPIPE()  {
    reader, writer := io.Pipe() //返回两个值 一个是读io 一个是写io 读写会有锁
    go func() {
        output := make([]byte, 100)
        n, err := reader.Read(output)
        if err != nil {
            println(err)
            return
        }
        println("read", n)
    }()
 
 
    input := make([]byte, 26)
    for i:=65; i<=90; i++ {
        input[i - 65] = byte(i)
    }
    n, err := writer.Write(input)
    if err != nil {
        fmt.Println(err)
    }
    time.Sleep(time.Second * 3)
 
    fmt.Println("Write", n)
}

系统的管道 实现原理就是读写文件

// 系统的管道 实现原理就是读写文件
func SystempPIPE()  {
    reader, writer, err := os.Pipe() //一个是读os 一个是写os 读写会有锁
    if err != nil {
        println(err)
        return
    }
    go func() {
        output := make([]byte, 100)
        n, err := reader.Read(output)
        if err != nil {
            println(err)
            return
        }
        println("read", n)
    }()
 
 
    input := make([]byte, 26)
    for i:=65; i<=90; i++ {
        input[i - 65] = byte(i)
    }
    n, err := writer.Write(input)
    if err != nil {
        fmt.Println(err)
    }
    time.Sleep(time.Second * 3)
 
    fmt.Println("Write", n)
}