Junção de strings em Rust: join para vetores em 2025

Introdução: Por que a pergunta sobre join em Rust é tão popular?

Se você já migrou do Python ou JavaScript para Rust, certamente já passou por isso. Você escreve um código bonito, tem um vetor de strings Vec<String>, e precisa simplesmente uni-las com vírgula. Em Python seria ", ".join(my_list). Em JavaScript — myArray.join(", "). E em Rust... você vai à documentação e descobre que o método join existe, mas não em Vec, e sim em fatias (slice).

A pergunta no Stack Overflow "What is the equivalent of the join operator over a vector of Strings?" acumulou milhares de visualizações. E não é por acaso. Em 2025, quando Rust continua conquistando programadores de sistemas e desenvolvedores web, entender como unir strings de forma correta e eficiente torna-se uma habilidade crítica.

Neste artigo, não vamos apenas dar a resposta. Vamos analisar todas as formas de unir strings em Rust: desde o simples concat até o avançado join com separadores personalizados. Você aprenderá qual método escolher para sua tarefa e por quê. Vamos lá!

Base: O que é join e para que serve?

Imagine que você tem uma lista de nomes de usuários: ["Alice", "Bob", "Charlie"]. Você quer exibi-los no formato: "Alice, Bob, Charlie". Essa é a operação join — unir elementos de uma coleção em uma única string usando um separador.

Em Rust, não há um método join embutido diretamente para Vec<String>. Mas existem duas abordagens principais que resolvem esse problema:

• Método join em fatias (slice) — o caminho mais direto e eficiente.
• Método collect com iterador — mais funcional, mas menos óbvio para iniciantes.

Vamos analisar cada um deles com exemplos.

Método nº1: slice.join() — o clássico

Esta é a forma mais simples e intuitiva. Em Rust, o método join é definido para a trait SliceConcatExt, que é implementada para todas as fatias. Como Vec pode ser facilmente convertido em uma fatia (via &vec ou vec.as_slice()), podemos usá-lo diretamente.

fn main() {    let names = vec!["Alice".to_string(), "Bob".to_string(), "Charlie".to_string()];        // Transforma Vec<String> em &[String] e chama join    let joined = names.join(", ");        println!("{}", joined); // Saída: Alice, Bob, Charlie}

Como funciona?

O método join pega um separador (no nosso caso ", ") e o insere entre cada elemento da fatia. Ele não adiciona separador no início ou no final — apenas entre os elementos.

Importante: join retorna uma String, não &str. Isso significa que ele cria uma nova string, copiando os dados de todos os elementos.

Quando usar slice.join()?

• Quando você tem um Vec<String> ou &[String]
• Quando você precisa de um separador personalizado
• Quando a performance é importante — esta é a forma mais rápida

Método nº2: iter().collect() — abordagem funcional

Se você gosta de iteradores e estilo funcional, vai gostar desta forma. Em vez de join, você pode usar collect com o tipo String:

fn main() {    let names = vec!["Alice".to_string(), "Bob".to_string(), "Charlie".to_string()];        // Usa iterador e collect    let joined: String = names.iter().map(|s| s.as_str()).collect::<Vec<&str>>().join(", ");        println!("{}", joined); //