Struct Command 

pub struct Command { /* private fields */ }

Implementations

impl Command

pub fn new<S: AsRef<OsStr>>(program: S) -> Self

See std::process::Command::new.

pub fn arg_would_fit<S: AsRef<OsStr>>(&self, arg: S) -> bool

Check if an additional argument would fit in the command.

pub fn args_would_fit<I, S>(&self, args: I) -> bool

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Check if multiple additional arguments would all fit in the command.

pub fn try_arg<S: AsRef<OsStr>>(&mut self, arg: S) -> Result<&mut Self>

Like std::process::Command::arg, add an argument to the command, but only if it will fit.

pub fn try_args<I, S>(&mut self, args: I) -> Result<&mut Self>

where I: IntoIterator<Item = S> + Copy, S: AsRef<OsStr>,

Like std::process::Command::arg, add multiple arguments to the command, but only if they will all fit.

pub fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Self

See std::process::Command::current_dir.

pub fn stdin<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self

See std::process::Command::stdin.

pub fn stdout<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self

See std::process::Command::stdout.

pub fn stderr<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self

See std::process::Command::stderr.

pub fn spawn(&mut self) -> Result<Child>

See std::process::Command::spawn.

pub fn output(&mut self) -> Result<Output>

See std::process::Command::output.

pub fn status(&mut self) -> Result<ExitStatus>

See std::process::Command::status.

Methods from Deref<Target = Command>

pub fn get_program(&self) -> &OsStr

Returns the path to the program that was given to Command::new.

Examples

use std::process::Command;

let cmd = Command::new("echo");
assert_eq!(cmd.get_program(), "echo");

pub fn get_args(&self) -> CommandArgs<'_>

Returns an iterator of the arguments that will be passed to the program.

This does not include the path to the program as the first argument; it only includes the arguments specified with Command::arg and Command::args.

Examples

use std::ffi::OsStr;
use std::process::Command;

let mut cmd = Command::new("echo");
cmd.arg("first").arg("second");
let args: Vec<&OsStr> = cmd.get_args().collect();
assert_eq!(args, &["first", "second"]);

pub fn get_envs(&self) -> CommandEnvs<'_>

Returns an iterator of the environment variables explicitly set for the child process.

Environment variables explicitly set using Command::env, Command::envs, and Command::env_remove can be retrieved with this method.

Note that this output does not include environment variables inherited from the parent process. To see the full list of environment variables, including those inherited from the parent process, use Command::get_resolved_envs.

Each element is a tuple key/value pair (&OsStr, Option<&OsStr>). A None value indicates its key was explicitly removed via Command::env_remove. The associated key for the None value will no longer inherit from its parent process.

An empty iterator can indicate that no explicit mappings were added or that Command::env_clear was called. After calling Command::env_clear, the child process will not inherit any environment variables from its parent process.

Examples

use std::ffi::OsStr;
use std::process::Command;

let mut cmd = Command::new("ls");
cmd.env("TERM", "dumb").env_remove("TZ");
let envs: Vec<(&OsStr, Option<&OsStr>)> = cmd.get_envs().collect();
assert_eq!(envs, &[
    (OsStr::new("TERM"), Some(OsStr::new("dumb"))),
    (OsStr::new("TZ"), None)
]);

pub fn get_resolved_envs(&self) -> CommandResolvedEnvs

🔬This is a nightly-only experimental API. (command_resolved_envs)

Returns an iterator of the environment variables that will be set when the process is spawned.

This returns the environment as it would be if the command were executed at the time of calling this method. The returned environment includes:

• All inherited environment variables from the parent process (unless Command::env_clear was called)
• All environment variables explicitly set via Command::env or Command::envs
• Excluding any environment variables removed via Command::env_remove

Note that the returned environment is a snapshot at the time this method is called and will not reflect any subsequent changes to the Command or the parent process’s environment. Additionally, it will not reflect changes made in a pre_exec hook (on Unix platforms).

Each element is a tuple (OsString, OsString) representing an environment variable key and value.

Examples

#![feature(command_resolved_envs)]
use std::process::Command;
use std::ffi::{OsString, OsStr};
use std::env;
use std::collections::HashMap;

let mut cmd = Command::new("ls");
cmd.env("TZ", "UTC");
unsafe { env::set_var("EDITOR", "vim"); }

let resolved: HashMap<OsString, OsString> = cmd.get_resolved_envs().collect();
assert_eq!(resolved.get(OsStr::new("TZ")), Some(&OsString::from("UTC")));
assert_eq!(resolved.get(OsStr::new("EDITOR")), Some(&OsString::from("vim")));

pub fn get_current_dir(&self) -> Option<&Path>

Returns the working directory for the child process.

This returns None if the working directory will not be changed.

Examples

use std::path::Path;
use std::process::Command;

let mut cmd = Command::new("ls");
assert_eq!(cmd.get_current_dir(), None);
cmd.current_dir("/bin");
assert_eq!(cmd.get_current_dir(), Some(Path::new("/bin")));

pub fn get_env_clear(&self) -> bool

🔬This is a nightly-only experimental API. (command_resolved_envs)

Returns whether the environment will be cleared for the child process.

This returns true if Command::env_clear was called, and false otherwise. When true, the child process will not inherit any environment variables from its parent process.

Examples

#![feature(command_resolved_envs)]
use std::process::Command;

let mut cmd = Command::new("ls");
assert_eq!(cmd.get_env_clear(), false);

cmd.env_clear();
assert_eq!(cmd.get_env_clear(), true);

Trait Implementations

impl Debug for Command

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for Command

type Target = Command

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.