How to Convert a String to an Integer in Rust

By the end of this page, you will understand how Rust converts text into numbers, why String and &str are treated differently, and how to use modern Rust methods like .parse() to convert both String and &str into integer types safely.

In Rust, parsing a number from text means reading characters like "42" and turning them into a numeric type like i32 or u64.

The main idea is that Rust separates:

• Owned text: String
• Borrowed text: &str

A String owns heap-allocated text. A &str is a view into text. Many parsing APIs work with &str because they only need to read the characters, not own them.

In modern Rust, the usual way to convert text to an integer is:

let n: i32 = "42".parse().unwrap();

This works because Rust provides parsing through the FromStr trait. Types like i32, u32, and usize implement this trait, so they know how to build themselves from text.

A can also be parsed easily because method calls can automatically borrow it as when needed:

Think of String as a book you own and &str as a page someone is reading from that book.

If you want to parse a number, the parser does not need to own the whole book. It just needs to read the page.

So when you write:

let s = String::from("123");
let n: i32 = s.parse().unwrap();

Rust is effectively saying:

• s owns the text
• the parser temporarily borrows that text
• the parser reads it and produces an integer

You still keep ownership of the original String unless you move it elsewhere.

This is why parsing usually works through borrowing rather than copying.

Core syntax

In modern Rust, use .parse():

let n: i32 = "42".parse().unwrap();

Because .parse() returns a Result, you can also handle errors safely:

let n: Result<i32, _> = "42".parse();

Parsing a &str

fn main() {
    let text = "123";
    let number: i32 = text.parse().unwrap();
    println!("{}", number);
}

Explanation:

• text is a

Consider this example:

fn main() {
    let text = String::from("256");
    let number: i32 = text.parse().unwrap();
    println!("{}", number);
}

Step by step:

1. let text = String::from("256");

   • A String is created.
   • It owns the text "256".

2. let number: i32 = text.parse().unwrap();

   • .parse() is called on text.
   • Rust borrows the contents of text as &str.
   • It sees that you want an i32.
   • It tries to convert the characters 2, , and into the integer .

Parsing strings into integers appears in many practical Rust programs.

Command-line arguments

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() > 1 {
        match args[1].parse::<i32>() {
            Ok(port) => println!("Port: {}", port),
            Err(_) => println!("Please provide a valid number"),
        }
    }
}

Used when reading values like ports, limits, or IDs.

User input

If a user types their age, quantity, or menu choice, the program receives text first. You must parse that text into a number before doing calculations.

Config files and environment variables

Environment variables are strings by default:

use std::env;

fn main() {
    let timeout = env::var()
        .()
        .(|s| s.parse::<>().())
        .();

    (, timeout);
}

In real Rust codebases, developers usually combine parsing with validation and error handling.

Pattern: parse close to the input boundary

Convert text into a number as soon as you receive it.

fn parse_age(input: &str) -> Result<u8, std::num::ParseIntError> {
    input.parse::<u8>()
}

This keeps the rest of your code working with proper numeric types instead of raw strings.

Pattern: guard clauses for invalid input

fn set_retry_count(input: &str) -> Result<u32, String> {
    let count: u32 = input.parse().map_err(|_| "Invalid retry count".to_string())?;

    if count > 10 {
        return Err("Retry count must be 10 or less".to_string());
    }

    Ok(count)
}

First parse, then validate business rules.

Pattern: optional parsing with defaults

1. Forgetting that parsing can fail

Broken code:

fn main() {
    let text = "abc";
    let number: i32 = text.parse().unwrap();
    println!("{}", number);
}

Problem:

• "abc" is not a number
• unwrap() will panic

Better:

fn main() {
    let text = "abc";

    match text.parse::<i32>() {
        Ok(n) => println!("{}", n),
        Err(_) => println!("Invalid number"),
    }
}

2. Not specifying the target type

Broken code:

 () {
      = ;
      = text.().();
}

String vs &str

Quick reference

Parse a string slice

let n: i32 = "42".parse().unwrap();

Parse a String

let s = String::from("42");
let n: i32 = s.parse().unwrap();

Specify the type explicitly

let n = "42".parse::<u64>().unwrap();

Handle errors safely

match "42".parse::<i32>() {
    Ok(n) => println!("{}", n),
    Err(e) => (, e),
}

Can I parse a String directly in Rust?

Yes. You can call .parse() directly on a String, and Rust will borrow it as &str automatically.

What is the difference between String and &str when parsing?

String owns the text, while &str is a borrowed view. Parsing usually only needs a borrowed view, so both work.

Why does parse() return a Result?

Because not every string is a valid number. Rust forces you to handle possible failure safely.

How do I parse an integer without crashing?

Use match, if let, or the ? operator instead of unwrap().

What replaces from_str::<int>(...) in modern Rust?

Use .parse::<i32>(), .parse::<u64>(), or another specific integer type.

• String — important because it is Rust's owned string type.
• &str — closely related because parsing APIs commonly read borrowed string slices.
• Result — parsing returns Result, so error handling is essential.
• match — often used to handle parsing success and failure.
• unwrap — commonly seen in examples, but should be used carefully.
• FromStr — the trait that powers .parse().
• Error handling in Rust — useful because numeric conversion can fail.
• Type inference — relevant because parsing often needs an explicit target type.