---
title: "Dividir String em Rust (Split)"
url: "https://rustlang.com.br/receitas/dividir-string/"
markdown_url: "https://rustlang.com.br/receitas/dividir-string.MD"
description: "Aprenda como dividir strings em Rust usando split(), splitn(), split_whitespace(), lines() e regex. Exemplos completos e práticos."
date: "2026-02-23"
author: "Equipe Rust Brasil"
---

# Dividir String em Rust (Split)

Aprenda como dividir strings em Rust usando split(), splitn(), split_whitespace(), lines() e regex. Exemplos completos e práticos.


# Dividir String em Rust (Split)

Dividir strings em partes menores é uma operação fundamental em processamento de texto. Rust oferece vários métodos nativos para isso, além de suporte a expressões regulares via crate externa.

## `split()` — dividir por delimitador

O método `split()` é o mais versátil. Aceita caracteres, strings e até closures como delimitador:

```rust
fn main() {
    let csv = "João,28,São Paulo,Desenvolvedor";

    // Split por caractere
    let campos: Vec<&str> = csv.split(',').collect();
    println!("Campos: {:?}", campos);
    println!("Nome: {}", campos[0]);
    println!("Idade: {}", campos[1]);

    // Split por string
    let texto = "Rust=>é=>incrível";
    let partes: Vec<&str> = texto.split("=>").collect();
    println!("Partes: {:?}", partes);

    // Split por closure (função)
    let misturado = "olá mundo;teste,outro:valor";
    let tokens: Vec<&str> = misturado
        .split(|c: char| !c.is_alphanumeric())
        .collect();
    println!("Tokens: {:?}", tokens);

    // Split por múltiplos caracteres
    let dados = "a+b-c*d/e";
    let letras: Vec<&str> = dados
        .split(&['+', '-', '*', '/'][..])
        .collect();
    println!("Letras: {:?}", letras);
}
```

**Saída:**
```
Campos: ["João", "28", "São Paulo", "Desenvolvedor"]
Nome: João
Idade: 28
Partes: ["Rust", "é", "incrível"]
Tokens: ["olá", "mundo", "teste", "outro", "valor"]
Letras: ["a", "b", "c", "d", "e"]
```

## `splitn()` — limitar número de divisões

Use `splitn()` quando você precisa de um número máximo de partes:

```rust
fn main() {
    let log = "2026-02-23 INFO Servidor iniciado na porta 8080";

    // Dividir em no máximo 3 partes
    let partes: Vec<&str> = log.splitn(3, ' ').collect();
    println!("Data: {}", partes[0]);
    println!("Nível: {}", partes[1]);
    println!("Mensagem: {}", partes[2]);

    // rsplitn divide a partir do final
    let caminho = "src/modulo/arquivo.rs";
    let partes: Vec<&str> = caminho.rsplitn(2, '/').collect();
    println!("Arquivo: {}", partes[0]);
    println!("Diretório: {}", partes[1]);

    // Útil para separar chave=valor
    let config = "database_url=postgres://localhost:5432/meu_banco";
    let partes: Vec<&str> = config.splitn(2, '=').collect();
    println!("Chave: {}", partes[0]);
    println!("Valor: {}", partes[1]);
}
```

**Saída:**
```
Data: 2026-02-23
Nível: INFO
Mensagem: Servidor iniciado na porta 8080
Arquivo: arquivo.rs
Diretório: src/modulo
Chave: database_url
Valor: postgres://localhost:5432/meu_banco
```

## `split_whitespace()` e `lines()`

Métodos especializados para espaços em branco e quebras de linha:

```rust
fn main() {
    // split_whitespace ignora múltiplos espaços e tabs
    let texto = "  Rust   é     incrível  ";
    let palavras: Vec<&str> = texto.split_whitespace().collect();
    println!("Palavras: {:?}", palavras);
    println!("Total: {} palavras", palavras.len());

    // lines() divide por \n ou \r\n
    let multilinhas = "Primeira linha\nSegunda linha\nTerceira linha";
    for (i, linha) in multilinhas.lines().enumerate() {
        println!("Linha {}: '{}'", i + 1, linha);
    }

    // Contando linhas não vazias
    let com_vazias = "linha 1\n\nlinha 3\n\n\nlinha 6";
    let nao_vazias: Vec<&str> = com_vazias
        .lines()
        .filter(|l| !l.is_empty())
        .collect();
    println!("Linhas não vazias: {:?}", nao_vazias);

    // Processando linhas com transformação
    let numeros = "10\n20\n30\n40";
    let soma: i32 = numeros
        .lines()
        .filter_map(|l| l.parse::<i32>().ok())
        .sum();
    println!("Soma: {}", soma);
}
```

**Saída:**
```
Palavras: ["Rust", "é", "incrível"]
Total: 3 palavras
Linha 1: 'Primeira linha'
Linha 2: 'Segunda linha'
Linha 3: 'Terceira linha'
Linhas não vazias: ["linha 1", "linha 3", "linha 6"]
Soma: 100
```

## Split com regex

Para padrões mais complexos, use a crate `regex`:

**Cargo.toml:**
```toml
[dependencies]
regex = "1"
```

```rust
use regex::Regex;

fn main() {
    // Dividir por um ou mais espaços/pontuação
    let re = Regex::new(r"[\s,;.!?]+").unwrap();
    let texto = "Olá, mundo! Como vai? Tudo bem; obrigado.";
    let palavras: Vec<&str> = re.split(texto).collect();
    println!("Palavras: {:?}", palavras);

    // Dividir por padrão numérico
    let re = Regex::new(r"\d+").unwrap();
    let misturado = "abc123def456ghi789";
    let partes: Vec<&str> = re.split(misturado).collect();
    println!("Partes texto: {:?}", partes);

    // Capturar os delimitadores também
    let re = Regex::new(r"(\d+)").unwrap();
    let resultado: Vec<&str> = re.find_iter(misturado)
        .map(|m| m.as_str())
        .collect();
    println!("Números encontrados: {:?}", resultado);

    // Split com limite usando regex
    let re = Regex::new(r"\s*,\s*").unwrap();
    let csv = "item1 , item2 , item3 , item4 , item5";
    let primeiros: Vec<&str> = re.splitn(csv, 3).collect();
    println!("Primeiros 3: {:?}", primeiros);
}
```

**Saída:**
```
Palavras: ["Olá", "mundo", "Como", "vai", "Tudo", "bem", "obrigado", ""]
Partes texto: ["abc", "def", "ghi", ""]
Números encontrados: ["123", "456", "789"]
Primeiros 3: ["item1", "item2", "item3 , item4 , item5"]
```

## Comparação dos métodos

| Método | Quando usar |
|--------|-------------|
| `split(char)` | Delimitador simples (vírgula, ponto, etc.) |
| `split(&str)` | Delimitador de múltiplos caracteres |
| `splitn(n, pat)` | Limitar número de partes |
| `split_whitespace()` | Separar palavras (ignora espaços múltiplos) |
| `lines()` | Separar por quebra de linha |
| `Regex::split()` | Padrões complexos |

## Veja também

- [Converter String para Número](/receitas/converter-string-numero/) — converta as partes divididas para números
- [Formatar Strings](/receitas/formatar-strings/) — junte e formate strings
- [Ler Arquivo](/receitas/ler-arquivo/) — leia arquivos e processe linhas
- [Ler Arquivo CSV](/receitas/ler-csv/) — parse de CSV estruturado (melhor que split manual)
- [Ler Input do Usuário](/receitas/ler-input-usuario/) — processe entrada do usuário
- Documentação oficial: [`str::split`](https://doc.rust-lang.org/std/primitive.str.html#method.split)