Golang中如何对进程数组进行排序

Golang中如何对进程数组进行排序

func main() {
r1, w1 := io.Pipe()
var cmds = []*exec.Cmd{
exec.Command(“ls”, “-l”),
exec.Command(“ps”, “-A”),
}
cmds[1].Stdin, cmds[0].Stdout = r1, w1
cmds[1].Stdout = os.Stdout

if err := cmds[0].Start(); err != nil {
	fmt.Println(err)
	return
}
if err := cmds[1].Start(); err != nil {
	fmt.Println(err)
	return
}

cmds[1].Run()
cmds[0].Run()
}

更多关于Golang中如何对进程数组进行排序的实战教程也可以访问 https://www.itying.com/category-94-b0.html

9 回复

你好，@siquency，欢迎来到论坛。你想按什么标准对这些进程进行排序？

更多关于Golang中如何对进程数组进行排序的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


我不知道该如何完成所有这些，你能帮我解决第一点吗？

我需要帮助，了解如何将这些进程的输出写入数组以及如何对它们进行排序。

你面临三个问题。

  1. 读取程序的输出
  2. 将字符串拆分为行切片
  3. 对字符串切片进行排序

逐个解决它们，然后在中间添加一些“粘合剂”，它们就应该能组合在一起了。

What are you trying to sort these processes by?

从 A 到 Z 以及从 Z 到 A 按 PID 从 1…N 以及相反的顺序 用户必须在终端中输入他需要的排序方式 希望你能做到这一点

如何在Go中获取系统命令的输出？

标签： go

使用os/exec在Go中进行高级命令执行

图片

在Go中使用os/exec库执行外部程序的示例。

本网站上的成员不太可能编写一个完整的程序来解决你的全部问题并直接提供给你。有一些其他网站可以付费请人代劳，但本网站成员的目标是引导你，以便你能（主要）自己解决问题。

话虽如此，

你是否有什么特殊原因，要解析 ls 的文本输出，而不是使用像 (*os.File).Readdirnames 这样的内置函数？或者，对于解析 ps 的输出，为什么不使用像 GitHub - shirou/gopsutil: psutil for golang 这样的库呢？

请查阅 os/exec 包的文档，特别是 (*exec.Cmd).StdoutPipe 示例。在那个示例中，stdout 管道被传递给了 json.NewDecoder，但这并不符合你的需求。你可能需要获取那个 stdout 管道，并将其传递给 bufio.NewReader。它提供了一个便捷的 ReadString 方法，可以帮助你开始读取命令的输出。

在Golang中对进程数组进行排序，通常指的是按照特定规则对*exec.Cmd数组进行排序。这里提供几种常见的排序方式：

1. 按命令名称排序

import (
    "os/exec"
    "sort"
)

func main() {
    cmds := []*exec.Cmd{
        exec.Command("ls", "-l"),
        exec.Command("ps", "-A"),
        exec.Command("echo", "hello"),
    }
    
    // 按命令名称排序
    sort.Slice(cmds, func(i, j int) bool {
        return cmds[i].Args[0] < cmds[j].Args[0]
    })
}

2. 按参数数量排序

func main() {
    cmds := []*exec.Cmd{
        exec.Command("ls", "-l", "-a"),
        exec.Command("ps", "-A"),
        exec.Command("echo"),
    }
    
    // 按参数数量排序
    sort.Slice(cmds, func(i, j int) bool {
        return len(cmds[i].Args) < len(cmds[j].Args)
    })
}

3. 按进程启动顺序需求排序

对于管道连接的进程，可以按照依赖关系排序：

func sortByDependency(cmds []*exec.Cmd) []*exec.Cmd {
    // 创建依赖图并拓扑排序
    // 这里简化处理，假设需要按特定顺序执行
    sorted := make([]*exec.Cmd, len(cmds))
    copy(sorted, cmds)
    
    // 示例：按命令字符串排序作为执行顺序
    sort.Slice(sorted, func(i, j int) bool {
        cmdStrI := sorted[i].Path
        for _, arg := range sorted[i].Args[1:] {
            cmdStrI += " " + arg
        }
        cmdStrJ := sorted[j].Path
        for _, arg := range sorted[j].Args[1:] {
            cmdStrJ += " " + arg
        }
        return cmdStrI < cmdStrJ
    })
    
    return sorted
}

4. 完整示例：排序后执行

package main

import (
    "fmt"
    "io"
    "os"
    "os/exec"
    "sort"
)

func main() {
    // 创建命令数组
    cmds := []*exec.Cmd{
        exec.Command("echo", "world"),
        exec.Command("ls", "-la"),
        exec.Command("ps", "-ef"),
    }
    
    // 按命令名称排序
    sort.Slice(cmds, func(i, j int) bool {
        return cmds[i].Args[0] < cmds[j].Args[0]
    })
    
    // 执行排序后的命令
    for _, cmd := range cmds {
        cmd.Stdout = os.Stdout
        cmd.Stderr = os.Stderr
        
        if err := cmd.Run(); err != nil {
            fmt.Printf("命令执行失败: %v\n", err)
        }
    }
}

5. 管道连接的进程排序

对于需要管道连接的进程，排序应该基于数据流依赖：

func sortPipedCommands(cmds []*exec.Cmd) []*exec.Cmd {
    // 这里需要根据实际的管道连接关系进行拓扑排序
    // 简化示例：假设第一个命令输出到第二个命令
    if len(cmds) >= 2 {
        r1, w1 := io.Pipe()
        cmds[1].Stdin = r1
        cmds[0].Stdout = w1
    }
    
    // 返回原始顺序或调整后的顺序
    return cmds
}

排序进程数组的关键是定义明确的比较规则，使用sort.Slice函数可以灵活地实现各种排序需求。

回到顶部