# Struct std::process::Stdio 1.0.0 [−] [src]

    pub struct Stdio(_);

Describes what to do with a standard I/O stream for a child process when passed to the `stdin`, `stdout`, and `stderr` methods of `Command`.

## Methods

### `impl Stdio`
[src]

#### `pub fn piped() -> Stdio`
[src]

A new pipe should be arranged to connect the parent and child processes.

# Examples

With stdout:

    use std::process::{Command, Stdio};

    let output = Command::new("echo")
        .arg("Hello, world!")
        .stdout(Stdio::piped())
        .output()
        .expect("Failed to execute command");

    assert_eq!(String::from_utf8_lossy(&output.stdout), "Hello, world!\n");
    // Nothing echoed to consoleRun

With stdin:

    use std::io::Write;
    use std::process::{Command, Stdio};

    let mut child = Command::new("rev")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .spawn()
        .expect("Failed to spawn child process");

    {
        let mut stdin = child.stdin.as_mut().expect("Failed to open stdin");
        stdin.write_all("Hello, world!".as_bytes()).expect("Failed to write to stdin");
    }

    let output = child.wait_with_output().expect("Failed to read stdout");
    assert_eq!(String::from_utf8_lossy(&output.stdout), "!dlrow ,olleH\n");Run

#### `pub fn inherit() -> Stdio`
[src]

The child inherits from the corresponding parent descriptor.

# Examples

With stdout:

    use std::process::{Command, Stdio};

    let output = Command::new("echo")
        .arg("Hello, world!")
        .stdout(Stdio::inherit())
        .output()
        .expect("Failed to execute command");

    assert_eq!(String::from_utf8_lossy(&output.stdout), "");
    // "Hello, world!" echoed to consoleRun

With stdin:

    use std::process::{Command, Stdio};

    let output = Command::new("rev")
        .stdin(Stdio::inherit())
        .stdout(Stdio::piped())
        .output()
        .expect("Failed to execute command");

    println!("You piped in the reverse of: {}", String::from_utf8_lossy(&output.stdout));Run

#### `pub fn null() -> Stdio`
[src]

This stream will be ignored. This is the equivalent of attaching the stream to `/dev/null`

# Examples

With stdout:

    use std::process::{Command, Stdio};

    let output = Command::new("echo")
        .arg("Hello, world!")
        .stdout(Stdio::null())
        .output()
        .expect("Failed to execute command");

    assert_eq!(String::from_utf8_lossy(&output.stdout), "");
    // Nothing echoed to consoleRun

With stdin:

    use std::process::{Command, Stdio};

    let output = Command::new("rev")
        .stdin(Stdio::null())
        .stdout(Stdio::piped())
        .output()
        .expect("Failed to execute command");

    assert_eq!(String::from_utf8_lossy(&output.stdout), "");
    // Ignores any piped-in inputRun

## Trait Implementations

### `impl Debug for Stdio`
1.16.0
[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`
[src]

Formats the value using the given formatter. Read more

### `impl From<ChildStdin> for Stdio`
1.20.0
[src]

#### `fn from(child: ChildStdin) -> Stdio`
[src]

Performs the conversion.

### `impl From<ChildStdout> for Stdio`
1.20.0
[src]

#### `fn from(child: ChildStdout) -> Stdio`
[src]

Performs the conversion.

### `impl From<ChildStderr> for Stdio`
1.20.0
[src]

#### `fn from(child: ChildStderr) -> Stdio`
[src]

Performs the conversion.

### `impl From<File> for Stdio`
1.20.0
[src]

#### `fn from(file: File) -> Stdio`
[src]

Performs the conversion.

### `impl FromRawFd for Stdio`
1.2.0
[src]

#### `unsafe fn from_raw_fd(fd: RawFd) -> Stdio`
[src]

This is supported on Unix only.

Constructs a new instance of `Self` from the given raw file descriptor. Read more

### `impl FromRawHandle for Stdio`
1.2.0
[src]

#### `unsafe fn from_raw_handle(handle: RawHandle) -> Stdio`
[src]

This is supported on Windows only.

Constructs a new I/O object from the specified raw handle. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## 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`)