Convert an Integer to a String in Rust

By the end of this page, you will understand how Rust converts integers into strings using to_string() and format!, why older to_str() examples no longer compile, and how string conversion fits into everyday Rust programming.

In modern Rust, the usual way to convert an integer into a String is:

let num = 42;
let s = num.to_string();

The result is an owned String, which is Rust's growable string type.

Older Rust tutorials may show to_str(), but that API belonged to much earlier Rust versions and is no longer part of modern Rust. That is why current compilers report that the method does not exist.

Why this matters

Converting numbers to strings is common when you need to:

• print values
• build messages
• create filenames or IDs
• generate API responses
• combine numbers with text

Rust is strict about types. An integer like 42 and a string like "42" are different kinds of values. Rust requires you to convert explicitly when needed, which helps prevent bugs.

The modern tools

to_string()

Use this when you want a direct conversion to String.

  = ;
  = x.();

Think of Rust types as different container shapes.

• An integer is like a calculator result: 42
• A string is like a label printed on paper: "42"

Even if they look similar to a human, Rust treats them as different things.

to_string() is like asking Rust to print the value onto a new piece of paper.

• 42 becomes "42"
• true becomes "true"
• "Fizz" can be copied into an owned String

So the rule of thumb is:

• if you need text you can own and store, use to_string()
• if you just want to display values inside a larger message, format! is often more convenient

Core syntax

let num = 123;
let s: String = num.to_string();

Example: integer to string

fn main() {
    let num = 25;
    let text = num.to_string();

    println!("num = {}", num);
    println!("text = {}", text);
}

What this does

• num is an integer
• num.to_string() converts it into a String
• text now contains "25"

Example: building a message

fn main() {
    let  = ;
      = (, score);

    (, message);
}

Consider this example:

fn main() {
    let num = 42;
    let text = num.to_string();
    println!("{}", text);
}

Step by step

1. let num = 42;

Rust creates an integer variable named num.

• value: 42
• type: inferred as an integer type such as i32

2. let text = num.to_string();

Rust calls the to_string() method on num.

• it reads the integer value 42
• it creates a new owned string
• that string contains the characters 4 and 2

Now:

• is still an integer

Logging and messages

let user_id = 101;
let log = format!("User {} signed in", user_id);

Applications often turn numbers into strings for logs and status messages.

Building file names

let report_id = 7;
let filename = format!("report-{}.txt", report_id);

This is useful for generated files, exports, and cache keys.

API responses

A server may convert numeric data into strings when building JSON manually or preparing display text.

let count = 3;
let message = format!("Found {} results", count);

CLI tools

Command-line programs often display numeric values as text.

let exit_code = 1;
(, exit_code);

In real Rust projects, developers usually use integer-to-string conversion in a few common patterns.

1. Formatting user-facing text

let retries = 3;
let msg = format!("Retry attempt {}", retries);

format! is often preferred when the number is only one part of a bigger message.

2. Returning a single consistent type

When if or match branches must all return the same type, to_string() is a simple fix.

let status = if is_admin {
    "admin".to_string()
} else {
    user_id.to_string()
};

3. Validation and error handling

Developers often convert numbers while constructing errors.

let age = 15;
let err = (, age);

1. Using old Rust methods like to_str()

Broken code:

let num = 5;
let s = num.to_str();

Why it fails:

• to_str() is from old Rust examples
• modern Rust uses to_string()

Correct code:

let num = 5;
let s = num.to_string();

2. Confusing &str and String

Broken code:

let s: &str = 5.to_string();

Why it fails:

• to_string() returns

Related ways to work with text in Rust

Quick reference

Integer to string

let n = 42;
let s = n.to_string();

String literal to owned string

let s = "Fizz".to_string();

Build a string with values

let s = format!("Value: {}", 42);

Print without converting first

println!("{}", 42);

Rules to remember

• to_str() is old Rust and should not be used in modern code.
• to_string() returns a String.
• String literals like "hello" are .

Why does to_str() not work in modern Rust?

Older Rust versions had different APIs. In current Rust, to_str() is no longer the correct method for this task. Use to_string() instead.

How do I convert an integer to a string in Rust?

Use:

let s = 123.to_string();

Should I use to_string() or format!?

Use to_string() for simple direct conversion. Use format! when building a larger string with other text.

Is "hello" already a string in Rust?

Yes, but it is a &str, which is a string slice. If you need an owned String, use "hello".to_string().

Can println! print integers without converting them first?

Yes.

• String — the owned string type returned by to_string().
• &str — string slices are often confused with String.
• format! — useful when building strings from multiple values.
• println! — prints values directly without manual conversion in many cases.
• parse() — performs the opposite conversion, from string to typed value.
• if expressions — important because all branches must return the same type.
• match expressions — another place where consistent return types matter.
• traits and Display — to_string() works through Rust's formatting traits.