问如何在一次访问中发送多个命令，但单独保存输出

EN

package main

import (
    "errors"
    "fmt"
    "io/ioutil"
    "log"
    "time"

    "golang.org/x/crypto/ssh"
)

func main() {

    // List of the commands should be sent to the devices
    listCMDs := []string{
        "set cli op-command-xml-output on",
        "test routing fib-lookup virtual-router default ip 1.1.1.1",
        "test routing fib-lookup virtual-router default ip 2.2.2.2",
        "show interface ethernet1/1",
        "show interface ethernet1/2",
        "test security-policy-match protocol 6 source 1.1.1.1 destination 2.2.2.2 destination-port 443 from ZONE1 to ZONE2",
        "test security-policy-match protocol 6 source 10.0.0.1 destination 10.0.2.1 destination-port 443 from ZONE1 to ZONE2",
        "exit",
    }

    sshconfig := InsecureClientConfig("admin", "admin")

    s, err := ExecCommands("192.168.1.250", listCMDs, sshconfig)
    fmt.Println(s, err)
}

// ExecCommands ...
func ExecCommands(ipAddr string, commands []string, sshconfig *ssh.ClientConfig) (string, error) {

    // Gets IP, credentials and config/commands, SSH Config (Timeout, Ciphers, ...) and returns
    // output of the device as "string" and an error. If error == nil, means program was able to SSH with no issue

    // Creating outerr as Output Error.
    outerr := errors.New("nil")
    outerr = nil

    // Creating Output as String
    var outputStr string

    // Dial to the remote-host
    client, err := ssh.Dial("tcp", ipAddr+":22", sshconfig)
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    // Create sesssion
    session, err := client.NewSession()
    if err != nil {
        log.Fatal(err)
    }
    defer session.Close()

    // StdinPipee() returns a pipe that will be connected to the remote command's standard input when the command starts.
    // StdoutPipe() returns a pipe that will be connected to the remote command's standard output when the command starts.
    stdin, err := session.StdinPipe()
    if err != nil {
        log.Fatal(err)
    }

    stdout, err := session.StdoutPipe()
    if err != nil {
        log.Fatal(err)
    }

    // Start remote shell
    err = session.Shell()
    if err != nil {
        log.Fatal(err)
    }

    // Send the commands to the remotehost one by one.
    for _, cmd := range commands {
        _, err := stdin.Write([]byte(cmd + "\n"))
        if err != nil {
            log.Fatal(err)
        }
    }

    // Wait for session to finish
    err = session.Wait()
    if err != nil {
        log.Fatal(err)
    }

    strByte, _ := ioutil.ReadAll(stdout)
    outputStr = string(strByte)

    return outputStr, outerr
}

// InsecureClientConfig ...
func InsecureClientConfig(userStr, passStr string) *ssh.ClientConfig {

    SSHconfig := &ssh.ClientConfig{
        User:    userStr,
        Timeout: 5 * time.Second,
        Auth:    []ssh.AuthMethod{ssh.Password(passStr)},

        HostKeyCallback: ssh.InsecureIgnoreHostKey(),
        Config: ssh.Config{
            Ciphers: []string{"aes128-ctr", "aes192-ctr", "aes256-ctr", "aes128-cbc", "aes192-cbc",
                "aes256-cbc", "3des-cbc", "des-cbc"},
            KeyExchanges: []string{"diffie-hellman-group1-sha1",
                "diffie-hellman-group-exchange-sha1",
                "diffie-hellman-group14-sha1"},
        },
    }
    return SSHconfig
}