Perl 和 PHP 使用反引号来做到这一点。例如，
$output = `ls`;
返回目录列表。一个类似的函数，system("foo")返回给定命令 foo 的操作系统返回码。我说的是一种将 foo 打印到标准输出的变体。
其他语言如何做到这一点？这个函数有一个规范的名字吗？（我要使用“反引号”；尽管也许我可以使用“syslurp”。）
dreeves
问问题
13487 次
27 回答
20
Python
from subprocess import check_output as qx
output = qx(['ls', '-lt'])
Python < 2.7或 < 3.1
subprocess.check_output()从subprocess.py中提取或改编类似于：
import subprocess
def cmd_output(args, **kwds):
kwds.setdefault("stdout", subprocess.PIPE)
kwds.setdefault("stderr", subprocess.STDOUT)
p = subprocess.Popen(args, **kwds)
return p.communicate()[0]
print cmd_output("ls -lt".split())
subprocess模块自 2.4 以来一直在 stdlib 中。
于 2008-10-25T19:35:50.810 回答
12
Python：
import os
output = os.popen("foo").read()
于 2008-10-25T17:53:24.917 回答
9
[应Alexman和dreeves的要求——请参阅评论——，您将在此DZones Java Snippet 页面上找到一个独立于操作系统的完整版本，用于在这种情况下制作“ls”。这是对他们的代码挑战的直接回答。
下面的只是核心：Runtime.exec，加上 2 个线程来监听 stdout 和 stderr。]
Java “简单！”：
E:\classes\com\javaworld\jpitfalls\article2>java GoodWindowsExec "dir *.java"
Executing cmd.exe /C dir *.java
...
或者在java代码中
String output = GoodWindowsExec.execute("dir");
但要做到这一点，你需要编码
......这很尴尬。
import java.util.*;
import java.io.*;
class StreamGobbler extends Thread
{
InputStream is;
String type;
StringBuffer output = new StringBuffer();
StreamGobbler(InputStream is, String type)
{
this.is = is;
this.type = type;
}
public void run()
{
try
{
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line=null;
while ( (line = br.readLine()) != null)
System.out.println(type + ">" + line);
output.append(line+"\r\n")
} catch (IOException ioe)
{
ioe.printStackTrace();
}
}
public String getOutput()
{
return this.output.toString();
}
}
public class GoodWindowsExec
{
public static void main(String args[])
{
if (args.length < 1)
{
System.out.println("USAGE: java GoodWindowsExec <cmd>");
System.exit(1);
}
}
public static String execute(String aCommand)
{
String output = "";
try
{
String osName = System.getProperty("os.name" );
String[] cmd = new String[3];
if( osName.equals( "Windows 95" ) )
{
cmd[0] = "command.com" ;
cmd[1] = "/C" ;
cmd[2] = aCommand;
}
else if( osName.startsWith( "Windows" ) )
{
cmd[0] = "cmd.exe" ;
cmd[1] = "/C" ;
cmd[2] = aCommand;
}
Runtime rt = Runtime.getRuntime();
System.out.println("Executing " + cmd[0] + " " + cmd[1]
+ " " + cmd[2]);
Process proc = rt.exec(cmd);
// any error message?
StreamGobbler errorGobbler = new
StreamGobbler(proc.getErrorStream(), "ERROR");
// any output?
StreamGobbler outputGobbler = new
StreamGobbler(proc.getInputStream(), "OUTPUT");
// kick them off
errorGobbler.start();
outputGobbler.start();
// any error???
int exitVal = proc.waitFor();
System.out.println("ExitValue: " + exitVal);
output = outputGobbler.getOutput();
System.out.println("Final output: " + output);
} catch (Throwable t)
{
t.printStackTrace();
}
return output;
}
}
于 2008-10-25T19:19:25.057 回答
8
Perl 中的另一种方法 (TIMTOWTDI)
$output = <<`END`;
ls
END
当在 Perl 程序中嵌入相对较大的 shell 脚本时，这特别有用
于 2008-10-25T18:12:30.153 回答
7
Ruby：反引号或 '%x' 内置语法。
puts `ls`;
puts %x{ls};
于 2008-10-25T18:02:29.237 回答
7
perl 中的另一种方法
$output = qx/ls/;
这样做的好处是您可以选择分隔符，从而可以在命令中使用 `（尽管恕我直言，如果您真的需要这样做，您应该重新考虑您的设计）。另一个重要的好处是，如果你使用单引号作为分隔符，变量将不会被插值（非常有用）
于 2008-10-25T18:08:02.860 回答
7
哈斯克尔：
import Control.Exception
import System.IO
import System.Process
main = bracket (runInteractiveCommand "ls") close $ \(_, hOut, _, _) -> do
output <- hGetContents hOut
putStr output
where close (hIn, hOut, hErr, pid) =
mapM_ hClose [hIn, hOut, hErr] >> waitForProcess pid
安装MissingH后：
import System.Cmd.Utils
main = do
(pid, output) <- pipeFrom "ls" []
putStr output
forceSuccess pid
在 Perl 和 Ruby 等“粘合”语言中，这是一个简单的操作，但 Haskell 不是。
于 2008-10-27T21:43:51.940 回答
6
壳内
OUTPUT=`ls`
或者
OUTPUT=$(ls)
第二种方法更好，因为它允许嵌套，但与第一种方法不同，并非所有 shell 都支持。
于 2008-10-25T18:00:43.327 回答
6
二郎：
os:cmd("ls")
于 2008-10-25T18:10:11.170 回答
6
好吧，由于这是依赖于系统的，因此有许多语言没有用于所需的各种系统调用的内置包装器。
例如，Common Lisp 本身并不是为在任何特定系统上运行而设计的。不过，SBCL（Steel Banks Common Lisp 实现）确实为类 Unix 系统提供了扩展，就像大多数其他 CL 实现一样。当然，这比仅仅获取输出要“强大”得多（您可以控制运行过程，可以指定各种流方向等，请参阅 SBCL 手册，第 6.3 章），但是很容易为此特定目的编写一个小宏：
(defmacro with-input-from-command ((stream-name command args) &body body)
"将command的输出流绑定到stream-name，然后执行body
在一个隐含的预测中。”
`（与开放流
(,流名称
(sb-ext:process-output (sb-ext:run-program ,command
, 参数
:搜索
：输出：流）））
，@身体））
现在，您可以像这样使用它：
(with-input-from-command (ls "ls" '("-l"))
;;用 ls 流做一些花哨的事情
)
也许你想把它全部塞进一根弦里。宏是微不足道的（尽管可能更简洁的代码是可能的）：
(defmacro syslurp (命令参数)
“将命令的输出作为字符串返回。要提供命令
作为字符串，args 作为字符串列表。”
(让 ((istream (gensym)))
(ostream (gensym))
（线（gensym）））
`(with-input-from-command (,istream ,command ,args)
(with-output-to-string (,ostream)
(loop (let ((,line (read-line ,istream nil)))
(当 (null ,line) (return))
（写线，线，ostream）））））））
现在你可以通过这个调用得到一个字符串：
(syslurp "ls" '("-l"))
于 2008-12-12T23:12:26.497 回答
4
数学：
output = Import["!foo", "Text"];
于 2008-10-25T17:46:09.097 回答
4
Perl 中的另一种方式（或 2！）....
open my $pipe, 'ps |';
my @output = < $pipe >;
say @output;
open也可以这样写……
open my $pipe, '-|', 'ps'
于 2008-10-25T20:57:18.587 回答
4
几年前，我为jEdit编写了一个与本机应用程序接口的插件。这就是我用来从正在运行的可执行文件中获取流的方法。剩下要做的就是：while((String s = stdout.readLine())!=null){...}
/* File: IOControl.java
*
* created: 10 July 2003
* author: dsm
*/
package org.jpop.io;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
/**
* Controls the I/O for a process. When using the std[in|out|err] streams, they must all be put on
* different threads to avoid blocking!
*
* @author dsm
* @version 1.5
*/
public class IOControl extends Object {
private Process process;
private BufferedReader stdout;
private BufferedReader stderr;
private PrintStream stdin;
/**
* Constructor for the IOControl object
*
* @param process The process to control I/O for
*/
public IOControl(Process process) {
this.process = process;
this.stdin = new PrintStream(process.getOutputStream());
this.stdout = new BufferedReader(new InputStreamReader(process.getInputStream()));
this.stderr = new BufferedReader(new InputStreamReader(process.getErrorStream()));
}
/**
* Gets the stdin attribute of the IOControl object
*
* @return The stdin value
*/
public PrintStream getStdin() {
return this.stdin;
}
/**
* Gets the stdout attribute of the IOControl object
*
* @return The stdout value
*/
public BufferedReader getStdout() {
return this.stdout;
}
/**
* Gets the stderr attribute of the IOControl object
*
* @return The stderr value
*/
public BufferedReader getStderr() {
return this.stderr;
}
/**
* Gets the process attribute of the IOControl object. To monitor the process (as opposed to
* just letting it run by itself) its necessary to create a thread like this: <pre>
*. IOControl ioc;
*.
*. new Thread(){
*. public void run(){
*. while(true){ // only necessary if you want the process to respawn
*. try{
*. ioc = new IOControl(Runtime.getRuntime().exec("procname"));
*. // add some code to handle the IO streams
*. ioc.getProcess().waitFor();
*. }catch(InterruptedException ie){
*. // deal with exception
*. }catch(IOException ioe){
*. // deal with exception
*. }
*.
*. // a break condition can be included here to terminate the loop
*. } // only necessary if you want the process to respawn
*. }
*. }.start();
* </pre>
*
* @return The process value
*/
public Process getProcess() {
return this.process;
}
}
于 2008-10-30T21:10:11.773 回答
4
不要忘记 Tcl：
set result [exec ls]
于 2008-12-02T19:57:15.160 回答
4
C# 3.0，比这个更简洁：
using System;
using System.Diagnostics;
class Program
{
static void Main()
{
var info = new ProcessStartInfo("cmd", "/c dir") { UseShellExecute = false, RedirectStandardOutput = true };
Console.WriteLine(Process.Start(info).StandardOutput.ReadToEnd());
}
}
警告：生产代码应正确处理 Process 对象...
于 2009-01-11T12:37:39.573 回答
3
珀尔：
$output = `foo`;
补充：这真的是一个多向领带。上面的 PHP 也是有效的，例如，Ruby 也使用相同的反引号。
于 2008-10-25T17:45:31.250 回答
3
在 PHP 中
$output = `ls`;
或者
$output = shell_exec('ls');
于 2008-10-25T18:03:59.873 回答
3
C（带glibc扩展名）：
#define _GNU_SOURCE
#include <stdio.h>
int main() {
char *s = NULL;
FILE *p = popen("ls", "r");
getdelim(&s, NULL, '\0', p);
pclose(p);
printf("%s", s);
return 0;
}
好吧，不是很简洁或干净。这就是C的生活...
于 2008-10-27T21:19:53.080 回答
3
在 C on Posix 兼容系统中：
#include <stdio.h>
FILE* stream = popen("/path/to/program", "rw");
fprintf(stream, "foo\n"); /* Use like you would a file stream. */
fclose(stream);
于 2008-12-16T22:59:24.833 回答
3
为什么这里仍然没有 c# 人:)
这是在 C# 中的操作方法。内置方式。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
namespace TestConsole
{
class Program
{
static void Main(string[] args)
{
Process p = new Process();
p.StartInfo.UseShellExecute = false;
p.StartInfo.CreateNoWindow = true;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.RedirectStandardError = true;
p.StartInfo.FileName = "cmd";
p.StartInfo.Arguments = "/c dir";
p.Start();
string res = p.StandardOutput.ReadToEnd();
Console.WriteLine(res);
}
}
}
于 2008-12-23T04:26:56.193 回答
3
这是另一种 Lisp 方式：
(defun execute (program parameters &optional (buffer-size 1000))
(let ((proc (sb-ext:run-program program parameters :search t :output :stream))
(output (make-array buffer-size :adjustable t :fill-pointer t
:element-type 'character)))
(with-open-stream (stream (sb-ext:process-output proc))
(setf (fill-pointer output) (read-sequence output stream)))
output))
然后，获取您的字符串：
(execute "cat" '("/etc/hosts"))
如果你想运行一个创建打印大量信息到 STDOUT 的命令，你可以像这样运行它：
(execute "big-writer" '("some" "parameters") 1000000)
最后一个参数为 big-writer 的输出预分配大量空间。我猜这个函数可能比一次读取一行输出流更快。
于 2009-09-03T07:36:54.480 回答
3
卢阿：
foo = io.popen("ls"):read("*a")
于 2009-09-03T07:48:54.467 回答
2
Ĵ：
output=:2!:0'ls'
于 2008-10-27T21:21:56.697 回答
2
Perl，另一种方式：
use IPC::Run3
my ($stdout, $stderr);
run3 ['ls'], undef, \$stdout, \$stderr
or die "ls failed";
很有用，因为您可以输入命令输入，并分别返回 stderr 和 stdout。远不及整洁/可怕/缓慢/令人不安IPC::Run，它可以设置子程序的管道。
于 2008-12-16T19:39:36.030 回答
2
图标/独角兽：
stream := open("ls", "p")
while line := read(stream) do {
# stuff
}
文档称之为管道。好处之一是它使输出看起来就像您正在阅读文件一样。这也意味着您可以在必要时写入应用程序的标准输入。
于 2008-12-23T05:07:00.637 回答
2
Clozure Common Lisp：
(with-output-to-string (stream)
(run-program "ls" '("-l") :output stream))
LispWorks
(with-output-to-string (*standard-output*)
(sys:call-system-showing-output "ls -l" :prefix "" :show-cmd nil))
于 2009-09-03T10:07:12.637 回答
0
当然，它不是更小（来自所有可用的语言），但它不应该那么冗长。
这个版本很脏。应处理异常，阅读可能会有所改善。这只是为了说明如何启动 java 版本。
Process p = Runtime.getRuntime().exec( "cmd /c " + command );
InputStream i = p.getInputStream();
StringBuilder sb = new StringBuilder();
for( int c = 0 ; ( c = i.read() ) > -1 ; ) {
sb.append( ( char ) c );
}
下面完成程序。
import java.io.*;
public class Test {
public static void main ( String [] args ) throws IOException {
String result = execute( args[0] );
System.out.println( result );
}
private static String execute( String command ) throws IOException {
Process p = Runtime.getRuntime().exec( "cmd /c " + command );
InputStream i = p.getInputStream();
StringBuilder sb = new StringBuilder();
for( int c = 0 ; ( c = i.read() ) > -1 ; ) {
sb.append( ( char ) c );
}
i.close();
return sb.toString();
}
}
样本输出（使用 type 命令）
C:\oreyes\samples\java\readinput>java Test "type hello.txt"
This is a sample file
with some
lines
样本输出（目录）
C:\oreyes\samples\java\readinput>java Test "dir"
El volumen de la unidad C no tiene etiqueta.
El número de serie del volumen es:
Directorio de C:\oreyes\samples\java\readinput
12/16/2008 05:51 PM <DIR> .
12/16/2008 05:51 PM <DIR> ..
12/16/2008 05:50 PM 42 hello.txt
12/16/2008 05:38 PM 1,209 Test.class
12/16/2008 05:47 PM 682 Test.java
3 archivos 1,933 bytes
2 dirs 840 bytes libres
尝试任何
java Test netstat
java Test tasklist
java Test "taskkill /pid 416"
编辑
我必须承认我不是 100% 确定这是做到这一点的“最佳”方式。随意发布参考和/或代码，以展示如何改进它或这有什么问题。
于 2008-12-16T23:57:57.647 回答