Home-theater-designers
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.
MAKEUSEDO VÍDEO DO DIA ROLE PARA CONTINUAR COM O CONTEÚDO
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.
fn main() {
let name = "Alice";
let age = 25;
let message = format!("My name is {} and I am {} years old.", name, age);
println!("{}", message);
}
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.
fn main() {
let pi = 3.14159;
let formatted_pi = format!("The value of pi is approximately {:.2}", pi);
println!("{}", formatted_pi); // prints 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:
inteiros | %d ou %i | Formata números inteiros, incluindo valores positivos e negativos. |
Números de ponto flutuante | %f | Adequado para formatar números de ponto flutuante, incluindo as partes inteiras e fracionárias. |
Notação exponêncial | %e ou %E | Formata números em notação científica (forma exponencial). |
representação octal | %o | Formata números inteiros em representação octal (base 8). |
representação hexadecimal | %x ou %X | Formata números inteiros em representação hexadecimal (base 16). coloque seu rosto em um corpo diferente |
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.
fn main() {
number = 42
formatted_number = "%10d" % number
print(formatted_number)
}
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.
use std::fmt;
// Define a struct named `Point`
struct Point {
x: i32,
y: i32,
}
// Implement the `Display` trait for `Point`
impl fmt::Display for Point {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// Format the `Point` struct as "(x, y)"
write!(f, "({}, {})", self.x, self.y)
}
}
fn main() {
// Create a new `Point` instance
let point = Point { x: 5, y: 10 };
// Print the `Point` struct using the `Display` formatting
println!("The point is: {}", point);
}
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.
use std::fmt;
// Define a struct named `Person`
#[derive(Debug)]
struct Person {
name: String,
age: u32,
}
// Implement the `Display` trait for `Person`
impl fmt::Display for Person {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// Format the `Person` struct as a human-readable string
write!(f, "Name: {}, Age: {}", self.name, self.age)
}
}
fn main() {
// Create a new `Person` instance
let person = Person {
name: String::from("Alice"),
age: 30,
};
// Print the `Person` struct using the `Display` formatting
println!("Display: {}", person);
// Print the `Person` struct using the `Debug` formatting
println!("Debug: {:?}", person);
}
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 enfrentar com confiança os desafios de formatação de strings e se beneficiar das garantias de desempenho e segurança da linguagem.