---
title: "Converter String para Número em Rust"
url: "https://rustlang.com.br/receitas/converter-string-numero/"
markdown_url: "https://rustlang.com.br/receitas/converter-string-numero.MD"
description: "Aprenda como converter String para número em Rust usando parse(), from_str() e tratamento de erros. Exemplos completos com i32, f64 e mais."
date: "2026-02-23"
author: "Equipe Rust Brasil"
---

# Converter String para Número em Rust

Aprenda como converter String para número em Rust usando parse(), from_str() e tratamento de erros. Exemplos completos com i32, f64 e mais.


# Converter String para Número em Rust

Converter uma `String` (ou `&str`) para um tipo numérico é uma das operações mais comuns em Rust. O método `parse()` é a forma principal de fazer essa conversão, e funciona com qualquer tipo que implemente o trait `FromStr`.

## Conversão básica com `parse()`

O jeito mais direto de converter uma string para número é usando o método `parse()` com anotação de tipo:

```rust
fn main() {
    // String para i32
    let numero: i32 = "42".parse().unwrap();
    println!("i32: {}", numero);

    // String para f64
    let decimal: f64 = "3.14".parse().unwrap();
    println!("f64: {}", decimal);

    // String para u64
    let grande: u64 = "18446744073709551615".parse().unwrap();
    println!("u64: {}", grande);

    // Usando turbofish syntax (alternativa à anotação de tipo)
    let valor = "100".parse::<i64>().unwrap();
    println!("i64 (turbofish): {}", valor);
}
```

**Saída:**
```
i32: 42
f64: 3.14
u64: 18446744073709551615
i64 (turbofish): 100
```

## Tratamento de erros com `Result`

Na prática, nunca use `unwrap()` em código de produção. O método `parse()` retorna um `Result` que você deve tratar corretamente:

```rust
fn main() {
    // Usando match
    let entrada = "abc";
    match entrada.parse::<i32>() {
        Ok(numero) => println!("Convertido: {}", numero),
        Err(e) => println!("Erro ao converter '{}': {}", entrada, e),
    }

    // Usando if let
    let entrada = "256";
    if let Ok(numero) = entrada.parse::<u8>() {
        println!("u8: {}", numero);
    } else {
        println!("'{}' não cabe em u8 (0-255)", entrada);
    }

    // Usando unwrap_or para valor padrão
    let valor: i32 = "não_é_número".parse().unwrap_or(0);
    println!("Com padrão: {}", valor);

    // Usando unwrap_or_else para cálculo do padrão
    let valor: f64 = "inválido".parse().unwrap_or_else(|_| {
        eprintln!("Aviso: usando valor padrão 1.0");
        1.0
    });
    println!("Com padrão calculado: {}", valor);
}
```

**Saída:**
```
Erro ao converter 'abc': invalid digit found in string
'256' não cabe em u8 (0-255)
Com padrão: 0
Aviso: usando valor padrão 1.0
Com padrão calculado: 1.0
```

## Usando `FromStr` diretamente

O trait `std::str::FromStr` é o que permite que `parse()` funcione. Você pode usá-lo diretamente e até implementá-lo para seus próprios tipos:

```rust
use std::str::FromStr;

#[derive(Debug)]
struct Ponto {
    x: f64,
    y: f64,
}

impl FromStr for Ponto {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let partes: Vec<&str> = s.split(',').collect();
        if partes.len() != 2 {
            return Err(format!("Esperado 'x,y', recebido: '{}'", s));
        }
        let x = partes[0].trim().parse::<f64>()
            .map_err(|e| format!("Erro no x: {}", e))?;
        let y = partes[1].trim().parse::<f64>()
            .map_err(|e| format!("Erro no y: {}", e))?;
        Ok(Ponto { x, y })
    }
}

fn main() {
    // FromStr direto
    let numero = i32::from_str("42").unwrap();
    println!("FromStr direto: {}", numero);

    // Tipo personalizado
    let ponto: Ponto = "3.5, 7.2".parse().unwrap();
    println!("Ponto: {:?}", ponto);

    // Tratando erro no tipo personalizado
    match "invalido".parse::<Ponto>() {
        Ok(p) => println!("Ponto: {:?}", p),
        Err(e) => println!("Erro: {}", e),
    }
}
```

**Saída:**
```
FromStr direto: 42
Ponto: Ponto { x: 3.5, y: 7.2 }
Erro: Esperado 'x,y', recebido: 'invalido'
```

## Converter com espaços e caracteres extras

Strings do mundo real frequentemente têm espaços em branco ou formatação. Use `trim()` antes de converter:

```rust
fn main() {
    // trim() remove espaços antes e depois
    let entrada = "  42  \n";
    let numero: i32 = entrada.trim().parse().unwrap();
    println!("Trimmed: {}", numero);

    // Remover separadores de milhar
    let com_separador = "1.000.000";
    let limpo = com_separador.replace('.', "");
    let numero: i64 = limpo.parse().unwrap();
    println!("Sem separador: {}", numero);

    // Converter vários números de uma string
    let texto = "10 20 30 40 50";
    let numeros: Vec<i32> = texto
        .split_whitespace()
        .filter_map(|s| s.parse().ok())
        .collect();
    println!("Vetor: {:?}", numeros);
}
```

**Saída:**
```
Trimmed: 42
Sem separador: 1000000
Vetor: [10, 20, 30, 40, 50]
```

## Tabela de referência rápida

| Conversão | Código |
|-----------|--------|
| `&str` → `i32` | `"42".parse::<i32>().unwrap()` |
| `String` → `f64` | `s.parse::<f64>().unwrap()` |
| `&str` → `u8` | `"255".parse::<u8>().unwrap()` |
| Com padrão | `s.parse::<i32>().unwrap_or(0)` |
| `FromStr` | `i32::from_str("42").unwrap()` |

## Veja também

- [Formatar Strings em Rust](/receitas/formatar-strings/) — operação inversa: número para string formatada
- [Dividir String em Rust](/receitas/dividir-string/) — quebre strings antes de converter partes para números
- [Ler Input do Usuário](/receitas/ler-input-usuario/) — leia e converta entrada do teclado
- [Ler Arquivo CSV](/receitas/ler-csv/) — parse de dados numéricos de arquivos CSV
- [Parse JSON em Rust](/receitas/parse-json/) — deserialize números de dados JSON
- Documentação oficial: [`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html)