Como funciona a formatação de strings no Rust

A formatação de string é um aspecto crucial da programação, pois permite manipular e exibir dados de maneira legível e estruturada. Você pode controlar a apresentação de dados formatando strings para uma melhor experiência do usuário.

O Rust fornece um mecanismo poderoso e flexível para formatação de strings que permite criar uma saída clara e concisa, incluindo funcionalidade numérica, data, hora e tratamento de erros.

Formatação básica de strings em Rust

Rust fornece funcionalidade para formatar strings com outros Tipos embutidos de ferrugem.

Você pode usar o formatar! macro para formatação básica de string em Rust. O formatar! A macro fornece uma maneira concisa e poderosa de construir cadeias de caracteres formatadas com espaços reservados entre chaves.

fnprincipal() {
deixar nome = "Alice";
deixar idade = 25;
deixar mensagem = formatar!("Meu nome é {} e tenho {} anos.", nome idade);
println!("{}", mensagem);
}

O nome variável contém uma string, e o

idade variável contém um número inteiro. O mensagem variável tem uma string formatada que utiliza formatar! para substituir os espaços reservados pelos valores correspondentes, resultando em uma string de formato contendo o nome e idade.

O formatar! macro oferece suporte a vários especificadores de formato que permitem controlar a saída.

Veja como especificar o número de casas decimais para números de ponto flutuante, definir a largura dos campos e alinhar a saída.

fnprincipal() {
deixar pi = 3.14159;
deixar formatado_pi = formatar!("O valor de pi é aproximadamente {:.2}", pi);
println!("{}", formatado_pi); // imprime 3.14
}

O pi a variável contém um valor de ponto flutuante; com o especificador de formato :.2, você pode instruir o formatar! macro para exibir pi com duas casas decimais.

O formatar! macro é um dos muitos métodos de formatação de string com Rust. Dependendo de seus requisitos, considere usar o println! ou escrever! macro para saída formatada para o console ou outros fluxos de saída.

Formatando Valores Numéricos

Rust também fornece funcionalidade para formatar vários valores numéricos, de inteiros a flutuantes e outros tipos numéricos.

Geralmente, os especificadores de formato são a base da formatação de strings no Rust, e você precisará do especificador correto, dependendo do valor numérico que deseja formatar.

Aqui estão alguns dos especificadores de formato que o Rust fornece para valores numéricos:

Além disso, você pode especificar preenchimento e alinhamento para valores numéricos. O preenchimento adiciona espaços ou zeros a um valor numérico formatado para atingir a largura desejada. O preenchimento ajuda a alinhar valores para apresentação em formato tabular ou outros layouts organizados visualmente. Antes do valor da largura, você pode especificar o caractere de preenchimento, um espaço ou zero.

Para alinhar um valor à esquerda, use o - bandeira. Para alinhar um valor à direita, omita o sinalizador ou use o sinalizador '0' para preenchimento com zeros.

fnprincipal() {
 número = 42
 número_formatado = "%10d" % número
 imprimir (número_formatado)
}

O valor é alinhado à direita em uma largura de 10 caracteres, resultando em oito espaços à esquerda antes do número.

Formatação de string personalizada em Rust

A formatação de string personalizada é importante para operações mais exigentes. Você pode criar implementações de formatação personalizadas para seus tipos com o Rust integrado padrão:: fmt módulo.

O padrão:: fmt O módulo fornece recursos para formatar a saída com uma ampla variedade de opções para personalizar a aparência dos dados durante o processo de conversão de string. O padrão:: fmt módulo fornece um Mostrar e Depurar trait que é útil para operações de formatação de string.

A característica de exibição

O Mostrar trait ajuda a produzir uma saída legível por humanos, definindo como um objeto deve ser formatado com o {} espaço reservado em uma string. Você pode implementar o Mostrar traço para o seu tipos personalizados definindo um método chamado fmt que usa um formatador como argumento.

O formatador fornece vários métodos para controlar a saída do formato, como o write_str e write_fmt métodos.

usar padrão:: fmt;
// Define uma struct chamada `Point`
estruturaApontar {
 x: i32,
 você: i32,
}
// Implemente o trait `Display` para `Point`
implicar fmt:: Exibição para Apontar {
fnfmt(&auto, f: &mudo fmt:: Formatador<'_>) -> fmt::Resultado {
// Formata a estrutura `Point` como "(x, y)"
escrever!(f, "({}, {})", auto.x, auto.y)
 }
}
fnprincipal() {
// Cria uma nova instância `Point`
deixar ponto = Ponto { x: 5, você: 10 };
// Imprime a estrutura `Point` usando a formatação `Display`
println!("A questão é: {}", apontar);
}

O Apontar struct implementa o Mostrar característica. Dentro de fmt método, o escrever! formatos de macro e grave a saída desejada no formatador com o {} espaço reservado.

A característica de depuração

O Depurar característica é semelhante ao Mostrar característica, exceto que se concentra na produção de saída adequada para depuração e Manipulação de erros propósitos. O Depurar característica é usada principalmente com o {:?} espaço reservado.

Implementando o Depurar característica em seus tipos personalizados é simples. O Depurar trait fornece uma implementação padrão com base no Mostrar característica. No entanto, você pode substituir o comportamento padrão para fornecer uma representação de depuração especializada.

usar padrão:: fmt;
// Define uma estrutura chamada `Pessoa`
#[derivar (depurar)]
estruturaPessoa {
 nome: Corda,
 idade: u32,
}
// Implemente o trait `Display` para `Person`
implicar fmt:: Exibição para Pessoa {
fnfmt(&auto, f: &mudo fmt:: Formatador) -> fmt::Resultado {
// Formata a estrutura `Person` como uma string legível por humanos
escrever!(f, "Nome idade: {}", auto.nome, auto.idade)
 }
}
fnprincipal() {
// Cria uma nova instância `Person`
deixar pessoa = Pessoa {
 nome: Corda::de("Alice"),
 idade: 30,
 };
// Imprime a estrutura `Person` usando a formatação `Display`
println!("Mostrar: {}", pessoa);
// Imprime a estrutura `Person` usando a formatação `Debug`
println!("Depurar: {:?}", pessoa);
}

O programa deriva o Depurar característica para o Pessoa estrutura com #[derivar (depurar)]. Isso gera automaticamente a implementação com base nos campos struct.

A macro println imprime a representação de depuração com o Depurar espaço reservado de formatação para formatar a saída usando o Depurar implementação.

Rust tem um sistema de tipo rico em recursos

O sistema de tipo rico do Rust desempenha um papel crucial na formatação de strings. Aproveitando a digitação estática e as poderosas bibliotecas de formatação do Rust, você pode escrever um código seguro e eficiente enquanto lida com tarefas de manipulação e formatação de strings.

O sistema de tipo garante segurança em tempo de compilação e evita erros comuns, desde incompatibilidades de tipo até problemas de especificador de formato. Com a combinação do sistema de tipos do Rust e seus amplos recursos de formatação, você pode enfrente com confiança os desafios de formatação de strings e beneficie-se do desempenho e da segurança da linguagem garantias.