Rust: Fatias em Rust

Q: P:

A divisão de vec![1,2,3] com &vec[..] gera novos dados? R: Não, não há sobrecarga alguma. A divisão simplesmente cria um novo ponteiro para os dados do vetor original, juntamente com informações sobre o intervalo. Ela não aloca memória nem copia dados.

Última atualização: 2026-08-26

Uma fatia é um tipo especial de referência em Rust — ela não aponta para todo o conjunto de dados, mas sim para um segmento contíguo dele.

A divisão permite “extrair” com segurança uma parte dos dados para processamento, sem precisar copiá-los.

1. O que você vai aprender

O conceito e a criação de trechos de string &str
Use a sintaxe de intervalo [start..end] para criar fatias
As fatias de string devem coincidir com os limites de caracteres do UTF-8
Segmentação de matrizes &[T] e segmentação de vetores &[Vec]
Fatias como argumentos de função — o tipo mais flexível de entrada de string
Representação interna de uma fatia: ponteiro + comprimento

2. Diagramas conceituais

flowchart LR
    subgraph "Heap memory"
        HEAP["'H','e','l','l','o','','R','u','s','t','!'"]
    end
    subgraph "String s"
        S_PTR["ptr"] --> HEAP
        S_LEN["len: 12"]
        S_CAP["cap: 12"]
    end
    subgraph "&str slice"
        SL_PTR["ptr"] -->|"Pointing Forward5Byte"| HEAP
        SL_LEN["len: 5"]
    end

3. A história de um analista de dados

(1) Problema: A extração de informações dos registros é muito lenta

Maria é analista de dados em uma empresa de comércio eletrônico. Ela precisa extrair endereços IP de um grande volume de logs de servidor:

Cada linha de log contém dezenas de milhares de caracteres
Se você usar substring para copiar, cada entrada do log exigirá alguns milhares de bytes de memória adicional.
Processa 1.000.000 de registros por dia, com vários GB de memória adicional alocada
O servidor travou uma vez devido a um erro de OOM (falta de memória)

“Preciso de uma maneira de extrair dados que me permita ‘apenas olhar, sem copiar’ — assim como passar o dedo por uma linha de texto em um jornal sem precisar anotá-la.”

(2) Soluções para fatias em Rust

RUST

fn main() {
    let log_line = "192.168.1.1 - - [01/Jul/2026:12:00:00] \"GET /index.html\"";

    // Slices -- do not copy, they just "point to" a portion of the original string
    let ip = &log_line[0..13];           // "192.168.1.1"
    let date = &log_line[20..38];        // "01/Jul/2026:12:00:00"
    let path = &log_line[50..62];        // "/index.html"

    println!("IP: {}", ip);
    println!("Date: {}", date);
    println!("Path: {}", path);

    // Key Points: No strings were copied! All slices point to different areas of log_line
    println!("The original logs are still available: {}", log_line);
}

Uma fatia é como uma “janela” que aponta para uma visão diferente dos dados originais. Não há cópia, nem alocação — sobrecarga zero. Isso é fundamental ao se trabalhar com dados em grande escala.

4. O princípio da segmentação

(1) Modelo de memória

RUST

let s = String::from("Hello, Rust!");
let slice = &s[0..5];  // "Hello"

graph TB
    subgraph "String s"
        S_ptr[ptr ──→ H e l l o ,   R u s t !]
        S_len[len: 12]
        S_cap[cap: 12]
    end
    subgraph "&str slice"
        SL_ptr[ptr ──→ H e l l o]
        SL_len[len: 5]
    end
    S_ptr -.-> heap[Load the data]
    SL_ptr -.-> heap

Recurso	Fatias inteiras `String`	`&s[0..5]`
Memória	ptr + len + cap (3 bytes)	ptr + len (2 bytes)
Propriedade	De propriedade	Emprestado (citado)
Copiar ou não os dados	—	Não copiar
Intervalo de acesso	Sequência completa	"Olá" (5 bytes)

(2) Sintaxe do escopo

Sintaxe	Significado	Exemplo
`[0..5]`	0 a 5 (excluindo 5)	`"Hello"`
`[..5]`	Do início até 5	`"Hello"`
`[5..]`	Do 5 até o fim	`", Rust!"`
`[..]`	Sequência completa	`"Hello, Rust!"`

(3) Referência rápida aos tipos de fatia

Tipo de fatia	Sintaxe	Tamanho	Descrição
Trecho de string	`&str`	16 bytes	ptr + len (ponteiro fat)
Segmentação de matriz	`&[T]`	16 bytes	ptr + len (ponteiro fat)
Referência a matriz	`&[T; N]`	8 bytes	somente ponteiro (comprimento conhecido em tempo de compilação)
Faixa variável	`&mut [T]`	16 bytes	ptr + len (elementos modificáveis)

5. Exemplos de divisão em fatias

▶ Exemplo 1: Segmentação de strings (Dificuldade ⭐)

RUST

// ============================================
// Basic Usage of String Slicing
// ============================================

fn main() {
    let s = String::from("Hello, Rust World!");

    // Various Slicing Methods
    let hello = &s[..5];           // "Hello"
    let rust = &s[7..11];          // "Rust"
    let world = &s[12..];          // "World!"
    let full = &s[..];             // All

    println!("hello: '{}'", hello);
    println!("rust: '{}'", rust);
    println!("world: '{}'", world);
    println!("full: '{}'", full);

    // String literals are, by their very nature, &str
    let literal: &str = "Create a slice directly";
    let first_word = &literal[..2];
    println!("Literal Slicing: '{}'", first_word);
}

Resultado:

TEXT 📖 Somente leitura

hello: 'Hello'
rust: 'Rust'
world: 'World!'
full: 'Hello, Rust World!'
Literal Slicing: 'Directly'

Um literal de string (como "hello") é, por si só, do tipo &str — uma fatia que aponta para um arquivo binário. Ele não requer o prefixo &, pois já é uma referência.

▶ Exemplo 2: Armadilhas nos limites do recorte de strings (Dificuldade ⭐⭐)

RUST

// ============================================
// UTF-8 Boundary: Slices must be at character boundaries.
// ============================================

fn main() {
    let s = "RustProgramming";  // Number of bytes: R(1) u(1) s(1) t(1) Bian(3) Cheng(3) = 10 bytes

    // Security Slices
    let rust = &s[..4];         // "Rust" (first 4 bytes are exactly ASCII)
    println!("Rust Part: {}", rust);

    // The following are examples of errors (uncomment to see panic!)
    // let bad = &s[0..5];       // ❌ 5 is between 4 and 6, landing in the middle of "Bian"'s first byte

    // A Safe Approach: use chars() and char_indices() to iterate
    for (i, c) in s.char_indices() {
        println!("Byte Index {}: Character '{}'", i, c);
    }

    // Use char_indices to find safe slice boundaries
    if let Some((pos, _)) = s.char_indices().nth(4) {
        let safe_slice = &s[..pos];
        println!("First 4 character slice: {}", safe_slice);
    }
}

Resultado:

TEXT 📖 Somente leitura

Rust Part: Rust
Byte Index 0: Character 'R'
Byte Index 1: Character 'u'
Byte Index 2: Character 's'
Byte Index 3: Character 't'
Byte Index 4: Character 'Bian'
Byte Index 7: Character 'Cheng'
First 4 character slice: RustProgramming

As fatias são indexadas por bytes, e não por caracteres. Se o limite de uma fatia cair no meio de um caractere multibyte, o programa entrará em pânico e travará. Use .char_indices() para obter um índice seguro com limite de caractere.

▶ Exemplo 3: Segmentação de array x segmentação de vetor (Dificuldade ⭐⭐)

RUST

// ============================================
// Slicing Arrays and Vectors
// ============================================

fn main() {
    // Array Slicing
    let arr = [1, 2, 3, 4, 5];
    let slice_arr = &arr[1..4];      // [2, 3, 4]
    println!("Array Slicing: {:?}", slice_arr);

    // Vector Slicing
    let vec = vec![10, 20, 30, 40, 50];
    let slice_vec = &vec[..3];       // [10, 20, 30]
    println!("Vector Slicing(first 3): {:?}", slice_vec);

    // Edit Slice Content (requires &mut)
    let mut numbers = vec![1, 2, 3, 4, 5];
    let mut_slice = &mut numbers[1..4];  // [2, 3, 4]
    mut_slice[0] = 99;                   // Modifying a slice affects the original vector.
    println!("Modified original vector: {:?}", numbers);

    // Slice Type Size
    println!("&[i32] Occupancy: {} Byte", std::mem::size_of::<&[i32]>());
    println!("&[i32;5] Occupancy: {} Byte", std::mem::size_of::<&[i32; 5]>());
}

Resultado:

TEXT 📖 Somente leitura

Array Slicing: [2, 3, 4]
Vector Slicing(first 3): [10, 20, 30]
Modified original vector: [1, 99, 3, 4, 5]
&[i32] Occupancy: 16 Byte
&[i32;5] Occupancy: 8 Byte

Um tipo de fatia (&[i32]) ocupa 16 bytes (8 bytes para o ponteiro + 8 bytes para o comprimento), enquanto uma referência comum (&[i32;5]) ocupa apenas 8 bytes (apenas o ponteiro). Isso é o que se conhece como “ponteiro gordo” — uma fatia é um ponteiro que inclui informações sobre o comprimento.

▶ Exemplo 4: Fatias como argumentos de função (Dificuldade ⭐⭐)

RUST

// ============================================
// &str As a function argument -- the most flexible approach
// ============================================

// ✅ Best Practices: Receive &str -- regardless of whether the input is &str or &String
fn first_word(s: &str) -> &str {
    for (i, &b) in s.as_bytes().iter().enumerate() {
        if b == b' ' {
            return &s[..i];
        }
    }
    &s[..]  // No spaces, return the entire string
}

fn main() {
    // Incoming &str Literal
    let result1 = first_word("hello world");
    println!("The first word in the literal string: '{}'", result1);

    // Incoming &String (automatically converts to &str)
    let s = String::from("Rust is awesome");
    let result2 = first_word(&s);  // &String Automatically convert to &str
    println!("String The First Word: '{}'", result2);

    // Passing an array slice
    let arr = [1, 2, 3, 4, 5];
    let sum: i32 = sum_slice(&arr[..]);  // Use [..] to convert array to slice
    println!("Array Slicing and: {}", sum);
}

fn sum_slice(slice: &[i32]) -> i32 {
    let mut total = 0;
    for x in slice {
        total += *x;
    }
    total
}

Resultado:

TEXT 📖 Somente leitura

The first word in the literal string: 'hello'
String The First Word: 'Rust'
Array Slicing and: 15

Prática recomendada: Quando um parâmetro de função aceita uma string, use &str em vez de &String. &String é convertido automaticamente para &str (por meio de um cast de desreferenciamento), portanto, o parâmetro &str é mais versátil — ele aceita tanto literais quanto referências a strings.

▶ Exemplo 5: Exercício abrangente — Analisador de logs (Dificuldade ⭐⭐⭐)

RUST

// ============================================
// Practical Guide to Slicing: Zero-Copy Log Parsing
// ============================================

fn parse_log_line(line: &str) -> (&str, &str, &str) {
    let ip_end = line.find(' ').unwrap_or(line.len());
    let ip = &line[..ip_end];

    let rest = &line[ip_end..].trim_start();
    let method_end = rest.find(' ').unwrap_or(rest.len());
    let method = &rest[..method_end];

    let path_part = &rest[method_end..].trim_start();
    let path_end = path_part.find(' ').unwrap_or(path_part.len());
    let path = &path_part[..path_end];

    (ip, method, path)
}

fn find_longest<'a>(strings: &[&'a str]) -> &'a str {
    strings.iter().max_by_key(|s| s.len()).unwrap_or(&"")
}

fn summarize(data: &[i32]) -> (f64, i32, i32) {
    if data.is_empty() {
        return (0.0, 0, 0);
    }
    let sum: i32 = data.iter().sum();
    let avg = sum as f64 / data.len() as f64;
    let min = *data.iter().min().unwrap();
    let max = *data.iter().max().unwrap();
    (avg, min, max)
}

fn main() {
    let logs = [
        "192.168.1.1 GET /index.html HTTP/1.1",
        "10.0.0.5 POST /api/login HTTP/1.1",
        "172.16.0.1 DELETE /api/user/42 HTTP/1.1",
    ];

    println!("=== Log Analysis (Zero-Copy) ===");
    for log in &logs {
        let (ip, method, path) = parse_log_line(log);
        println!("IP: {:<15} Methods: {:<6} Path: {}", ip, method, path);
    }

    println!("\n=== Longest Path ===");
    let paths: Vec<&str> = logs.iter().map(|l| {
        let (_, _, p) = parse_log_line(l);
        p
    }).collect();
    println!("Longest Path: '{}'", find_longest(&paths));

    println!("\n=== Statistics on Numerical Slices ===");
    let scores = [85, 92, 78, 95, 88, 70, 96];
    let (avg, min, max) = summarize(&scores);
    println!("Grade Slices: {:?}", scores);
    println!("Average: {:.1}, Lowest: {}, Highest: {}", avg, min, max);
}

Resultado:

TEXT 📖 Somente leitura

=== Log Analysis (Zero-Copy) ===
IP: 192.168.1.1     Methods: GET    Path: /index.html
IP: 10.0.0.5        Methods: POST   Path: /api/login
IP: 172.16.0.1      Methods: DELETE Path: /api/user/42

=== Longest Path ===
Longest Path: '/api/user/42'

=== Statistics on Numerical Slices ===
Grade Slices: [85, 92, 78, 95, 88, 70, 96]
Average: 86.3, Lowest: 70, Highest: 96

Durante a análise do log, os três valores &str retornados por parse_log_line apontam, todos, para regiões diferentes da string original — sem cópia, sem alocação. find_longest aceita uma fatia de &[&str], o que o torna extremamente versátil. As funções estatísticas para fatias numéricas também apenas utilizam dados temporariamente.

❓ Perguntas Frequentes

P: Qual é a diferença entre uma fat slice e uma referência? R: Uma fat slice é um ponteiro fat (ponteiro + comprimento), enquanto uma referência comum é apenas um ponteiro. &str armazena duas informações na memória: “para onde aponta” e “qual é o seu comprimento”, ao passo que &String armazena apenas “para onde aponta”. Uma fatia permite que você conheça os limites dos dados, evitando o acesso fora dos limites.

P: Qual é a relação entre uma fatia de string &str e uma String? R: &str pode ser considerada uma visão parcial de uma String. A String é a proprietária dos dados, enquanto &str toma emprestada uma parte deles. Você pode pensar em uma String como um livro inteiro e em &str como uma página desse livro.

P: Por que &s[0..5] causa um panic quando usado com caracteres chineses? R: Porque as fatias são indexadas por bytes, e um único caractere chinês na codificação UTF-8 ocupa 3 bytes. &s[0..4] Em uma string ASCII, isso corresponderia exatamente a “hello”, mas na string “RustBianCheng”, corresponde a “Rust” (4 bytes). &s[0..5] Isso recai sobre o byte do meio do caractere “Bian”, e o compilador não consegue determinar se esse é um caractere válido, por isso entra em pânico.

P: Devo usar &str ou &String como parâmetro? R: Use sempre &str. Isso porque &String é automaticamente convertido para &str (por meio da desreferência), mas o contrário não ocorre. Um parâmetro que usa &str pode aceitar tanto literais de string quanto referências a String — o que o torna mais versátil.

P: A divisão de vec![1,2,3] com &vec[..] gera novos dados? R: Não, não há sobrecarga alguma. A divisão simplesmente cria um novo ponteiro para os dados do vetor original, juntamente com informações sobre o intervalo. Ela não aloca memória nem copia dados.

📖 Resumo

Uma fatia é uma “visualização” dos dados; ela não possui os dados nem cria uma cópia deles.
O corte de strings &str refere-se a um segmento de uma string ou a um literal
Sintaxe do intervalo: [start..end], [..end], [start..], [..]
Uma fat slice é um fat pointer (ponteiro + comprimento) que ocupa 16 bytes
As fatias de string devem coincidir com limites de caracteres UTF-8
Use &str para parâmetros de função que aceitam cadeias de caracteres (mais versátil do que &String)
A segmentação de matrizes &[T] funciona da mesma forma que a segmentação de vetores

📝 Exercícios

Dificuldade ⭐: Crie um String, use [..] para fragmentar a string inteira e verifique se o tipo da fragmentação é &str.
Dificuldade ⭐⭐: Escreva uma função fn last_word(s: &str) -> &str que retorne a última palavra (separada por espaços). Chame-a tanto para um literal de string quanto para String.
Dificuldade ⭐⭐⭐: Crie uma string contendo caracteres chineses e emojis "Rust🦀BianCheng", use .char_indices() para encontrar o limite seguro da fatia e extraia apenas a parte “Rust🦀” (Dica: 🦀 ocupa 4 bytes).

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós