用go做一个Windows命令行

你可以使用 Go 的 "os/exec" 库来执行 Windows 命令行。以下是一个示例程序，它可以执行 "dir" 命令并输出结果：

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("cmd", "/c", "dir")
    out, err := cmd.Output()
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(out))
}

在这个程序中，我们使用 `exec.Command` 函数创建一个 `cmd` 命令行进程，并使用 `/c` 参数来指定要执行的命令（在本例中是 "dir"）。然后，我们使用 `cmd.Output()` 方法来执行命令并获取输出结果。如果有错误产生，我们将其打印出来。最后，我们将输出结果转换为字符串并打印出来。

你可以根据自己的需要修改命令和参数，来实现其他的 Windows 命令行程序。

相关问题

用go做Windows的命令行，并制作一个界面

你可以使用Go语言的`os/exec`包来执行Windows命令行，使用`syscall`包来控制Windows命令行窗口的外观。

以下是一个示例代码，它执行`dir`命令并将其输出到Windows命令行窗口：

package main

import (
    "os/exec"
    "syscall"
)

func main() {
    cmd := exec.Command("cmd", "/c", "dir")
    cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
    cmd.Run()
}

在此代码中，`cmd`变量表示要执行的命令，它在此处设置为`dir`。`/c`标志表示命令应在执行后关闭命令行窗口。

使用`syscall.SysProcAttr`结构体中的`HideWindow`字段可以隐藏命令行窗口。如果你想显示窗口，请将其设置为`false`。

如果你想创建一个带有界面的命令行应用程序，可以使用`github.com/gizak/termui`包。以下是一个示例代码，它使用该包创建了一个简单的界面，该界面以Windows命令行窗口中的形式显示`dir`命令的输出：

package main

import (
    "os/exec"
    "syscall"

    "github.com/gizak/termui"
)

func main() {
    err := termui.Init()
    if err != nil {
        panic(err)
    }
    defer termui.Close()

    par := termui.NewPar("")
    par.Height = termui.TermHeight()
    par.Width = termui.TermWidth()

    cmd := exec.Command("cmd", "/c", "dir")
    cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
    out, _ := cmd.Output()
    par.Text = string(out)

    termui.Render(par)

    for e := range termui.PollEvents() {
        if e.Type == termui.KeyboardEvent {
            break
        }
    }
}

在此代码中，`termui.Init()`用于初始化界面，`termui.NewPar("")`用于创建一个新的文本段落，可以将`dir`命令的输出复制到该段落中，使用`termui.Render(par)`将段落渲染到屏幕上，使用`termui.PollEvents()`等待用户按键事件。

golang编写一个最简单的常驻内存的windows服务

要编写一个最简单的常驻内存的Windows服务，你可以使用`github.com/kardianos/service`包。下面是一个示例代码：

package main

import (
	"fmt"
	"log"
	"os"
	"time"

	"github.com/kardianos/service"
)

var logger service.Logger

type program struct{}

func (p *program) Start(s service.Service) error {
	go p.run()
	return nil
}

func (p *program) run() {
	for {
		select {
		case <-time.Tick(1 * time.Second):
			fmt.Println("Service is running...")
		}
	}
}

func (p *program) Stop(s service.Service) error {
	return nil
}

func main() {
	svcConfig := &service.Config{
		Name:        "MyService",
		DisplayName: "My Service",
		Description: "This is a simple Windows service.",
	}

	prg := &program{}
	s, err := service.New(prg, svcConfig)
	if err != nil {
		log.Fatal(err)
	}

	logger, err = s.Logger(nil)
	if err != nil {
		log.Fatal(err)
	}

	if len(os.Args) > 1 {
		err = service.Control(s, os.Args[1])
		if err != nil {
			log.Fatal(err)
		}
		return
	}

	err = s.Run()
	if err != nil {
		logger.Error(err)
	}
}

在这个示例中，我们创建了一个`program`结构体来实现Windows服务的逻辑。在`Start`方法中，我们通过一个无限循环来模拟服务的常驻内存。你可以在循环中添加自己的逻辑。

在`main`函数中，我们首先定义了服务的配置，包括服务的名称、显示名称和描述。然后创建了一个`program`实例，并使用`service.New`函数创建了一个服务实例。接下来，我们判断命令行参数，如果有参数，则根据参数来控制服务的状态（如启动、停止、重启）。如果没有参数，则调用`s.Run()`方法来启动服务。

通过编译这个代码并将生成的可执行文件安装为Windows服务，你就可以在后台运行这个常驻内存的服务了。可以使用以下命令来安装和管理服务：

# 安装服务
myService.exe install

# 启动服务
myService.exe start

# 停止服务
myService.exe stop

# 重启服务
myService.exe restart

# 卸载服务
myService.exe uninstall

请注意，安装和管理服务需要管理员权限。