# Struct bitflags::__core::process::Command [−] [src]

    pub struct Command {
        // some fields omitted
    }

1.0.0

The `Command` type acts as a process builder, providing fine-grained control over how a new process should be spawned. A default configuration can be generated using `Command::new(program)`, where `program` gives a path to the program to be executed. Additional builder methods allow the configuration to be changed (for example, by adding arguments) prior to spawning:

    use std::process::Command;

    let output = Command::new("sh")
                         .arg("-c")
                         .arg("echo hello")
                         .output()
                         .expect("failed to execute proces");

    let hello = output.stdout;

## Methods

### `impl Command`

#### `fn new<S>(program: S) -> Command where S: AsRef<OsStr>`

Constructs a new `Command` for launching the program at path `program`, with the following default configuration:

- No arguments to the program
- Inherit the current process's environment
- Inherit the current process's working directory
- Inherit stdin/stdout/stderr for `spawn` or `status`, but create pipes for `output`

Builder methods are provided to change these defaults and otherwise configure the process.

#### `fn arg<S>(&mut self, arg: S) -> &mut Command where S: AsRef<OsStr>`

Add an argument to pass to the program.

#### `fn args<S>(&mut self, args: &[S]) -> &mut Command where S: AsRef<OsStr>`

Add multiple arguments to pass to the program.

#### `fn env<K, V>(&mut self, key: K, val: V) -> &mut Command where V: AsRef<OsStr>, K: AsRef<OsStr>`

Inserts or updates an environment variable mapping.

Note that environment variable names are case-insensitive (but case-preserving) on Windows, and case-sensitive on all other platforms.

#### `fn env_remove<K>(&mut self, key: K) -> &mut Command where K: AsRef<OsStr>`

Removes an environment variable mapping.

#### `fn env_clear(&mut self) -> &mut Command`

Clears the entire environment map for the child process.

#### `fn current_dir<P>(&mut self, dir: P) -> &mut Command where P: AsRef<Path>`

Sets the working directory for the child process.

#### `fn stdin(&mut self, cfg: Stdio) -> &mut Command`

Configuration for the child process's stdin handle (file descriptor 0).

#### `fn stdout(&mut self, cfg: Stdio) -> &mut Command`

Configuration for the child process's stdout handle (file descriptor 1).

#### `fn stderr(&mut self, cfg: Stdio) -> &mut Command`

Configuration for the child process's stderr handle (file descriptor 2).

#### `fn spawn(&mut self) -> Result<Child, Error>`

Executes the command as a child process, returning a handle to it.

By default, stdin, stdout and stderr are inherited from the parent.

#### `fn output(&mut self) -> Result<Output, Error>`

Executes the command as a child process, waiting for it to finish and collecting all of its output.

By default, stdin, stdout and stderr are captured (and used to provide the resulting output).

# Examples

    use std::process::Command;
    let output = Command::new("/bin/cat").arg("file.txt").output()
        .expect("failed to execute process");

    println!("status: {}", output.status);
    println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
    println!("stderr: {}", String::from_utf8_lossy(&output.stderr));

    assert!(output.status.success());

#### `fn status(&mut self) -> Result<ExitStatus, Error>`

Executes a command as a child process, waiting for it to finish and collecting its exit status.

By default, stdin, stdout and stderr are inherited from the parent.

# Examples

    use std::process::Command;

    let status = Command::new("/bin/cat").arg("file.txt").status()
        .expect("failed to execute process");

    println!("process exited with: {}", status);

    assert!(status.success());

## Trait Implementations

### `impl CommandExt for Command`

#### `fn uid(&mut self, id: u32) -> &mut Command`

#### `fn gid(&mut self, id: u32) -> &mut Command`

#### `fn session_leader(&mut self, on: bool) -> &mut Command`

#### `fn before_exec<F>(&mut self, f: F) -> &mut Command where F: FnMut() -> Result<(), Error> + Send + Sync + 'static`

#### `fn exec(&mut self) -> Error`

### `impl Debug for Command`

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Format the program and arguments of a Command for display. Any non-utf8 data is lossily converted using the utf8 replacement character.

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)