std::io::Stdin - Rust
Description: API documentation for the Rust `Stdin` struct in crate `std`.
Keywords: rust, rustlang, rust-lang, Stdin

# Struct std::io::Stdin 1.0.0 [−] [src]

    pub struct Stdin { /* fields omitted */ }

A handle to the standard input stream of a process.

Each handle is a shared reference to a global buffer of input data to this process. A handle can be `lock`'d to gain full access to `BufRead` methods (e.g. `.lines()`). Reads to this handle are otherwise locked with respect to other reads.

This handle implements the `Read` trait, but beware that concurrent reads of `Stdin` must be executed with care.

Created by the `io::stdin` method.

## Methods

### `impl Stdin`
[src]

#### `fn lock(&self) -> StdinLock`

Locks this handle to the standard input stream, returning a readable guard.

The lock is released when the returned lock goes out of scope. The returned guard also implements the `Read` and `BufRead` traits for accessing the underlying data.

# Examples

    use std::io::{self, Read};

    let mut buffer = String::new();
    let stdin = io::stdin();
    let mut handle = stdin.lock();

    handle.read_to_string(&mut buffer)?;Run

#### `fn read_line(&self, buf: &mut String) -> Result<usize>`

Locks this handle and reads a line of input into the specified buffer.

For detailed semantics of this method, see the documentation on `BufRead::read_line`.

# Examples

    use std::io;

    let mut input = String::new();
    match io::stdin().read_line(&mut input) {
        Ok(n) => {
            println!("{} bytes read", n);
            println!("{}", input);
        }
        Err(error) => println!("error: {}", error),
    }Run

You can run the example one of two ways:

- Pipe some text to it, e.g. `printf foo | path/to/executable`
- Give it text interactively by running the executable directly, in which case it will wait for the Enter key to be pressed before continuing

## Trait Implementations

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

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

Formats the value using the given formatter.

### `impl Read for Stdin`
[src]

#### `fn read(&mut self, buf: &mut [u8]) -> Result<usize>`

Pull some bytes from this source into the specified buffer, returning how many bytes were read. Read more

#### `unsafe fn initializer(&self) -> Initializer`

🔬 This is a nightly-only experimental API. (`read_initializer` #42788)

Determines if this `Read`er can work with buffers of uninitialized memory. Read more

#### `fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>`

Read all bytes until EOF in this source, placing them into `buf`. Read more

#### `fn read_to_string(&mut self, buf: &mut String) -> Result<usize>`

Read all bytes until EOF in this source, placing them into `buf`. Read more

#### `fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>`

Read the exact number of bytes required to fill `buf`. Read more

#### `fn by_ref(&mut self) -> &mut Self where
Self: Sized,`

Creates a "by reference" adaptor for this instance of `Read`. Read more

#### `fn bytes(self) -> Bytes<Self> where
Self: Sized,`

Transforms this `Read` instance to an `Iterator` over its bytes. Read more

#### `fn chars(self) -> Chars<Self> where
Self: Sized,`

🔬 This is a nightly-only experimental API. (`io` #27802)

the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this `Read` instance to an `Iterator` over `char`s. Read more

#### `fn chain<R: Read>(self, next: R) -> Chain<Self, R> where
Self: Sized,`

Creates an adaptor which will chain this stream with another. Read more

#### `fn take(self, limit: u64) -> Take<Self> where
Self: Sized,`

Creates an adaptor which will read at most `limit` bytes from it. Read more

# 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
+
  Collapse/expand 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`)