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)
}