Cómo funciona el formato de cadenas en Rust

El formato de cadenas es un aspecto crucial de la programación, ya que le permite manipular y mostrar datos de una manera estructurada y legible. Puede controlar la presentación de datos formateando cadenas para una mejor experiencia de usuario.

Rust proporciona un mecanismo poderoso y flexible para el formato de cadenas que le permite crear resultados claros y concisos, incluidas funciones numéricas, de fecha, hora y manejo de errores.

Formato básico de cadenas en Rust

Rust proporciona funcionalidad para formatear cadenas con otros Tipos incorporados de óxido.

Puedes usar el ¡formato! macro para el formato básico de cadenas en Rust. El ¡formato! macro proporciona una forma concisa y eficaz de construir cadenas formateadas con marcadores de posición encerrados entre llaves.

fnprincipal() {
dejar nombre = "Alicia";
dejar edad = 25;
dejar mensaje = ¡formato!("Mi nombre es {} y tengo {} años"., nombre Edad);
imprimir!("{}", mensaje);
}

El nombre variable contiene una cadena, y la edad variable contiene un número entero. El mensaje variable tiene una cadena formateada que utiliza ¡formato! para reemplazar los marcadores de posición con los valores correspondientes, lo que da como resultado una cadena de formato que contiene el nombre y edad.

El ¡formato! macro admite varios especificadores de formato que le permiten controlar la salida.

Aquí se explica cómo especificar la cantidad de lugares decimales para los números de coma flotante, definir el ancho de los campos y alinear la salida.

fnprincipal() {
dejar pi = 3.14159;
dejar formatted_pi = ¡formato!("El valor de pi es aproximadamente {:.2}", Pi);
imprimir!("{}", formatted_pi); // imprime 3.14
}

El Pi la variable contiene un valor de coma flotante; con el especificador de formato :.2, puede instruir al ¡formato! macro para mostrar Pi con dos decimales.

El ¡formato! macro es uno de los muchos métodos de formateo de cadenas con Rust. Dependiendo de sus requisitos, considere usar el imprimir! o ¡escribir! macro para la salida formateada a la consola u otros flujos de salida.

Dar formato a valores numéricos

Rust también proporciona funcionalidad para formatear varios valores numéricos, desde enteros hasta flotantes y otros tipos numéricos.

En general, los especificadores de formato son la base del formato de cadena en Rust, y necesitará el especificador correcto según el valor numérico que desee formatear.

Estos son algunos de los especificadores de formato que Rust proporciona para valores numéricos:

Además, puede especificar relleno y alineación para valores numéricos. El relleno agrega espacios o ceros a un valor numérico formateado para lograr el ancho deseado. El relleno ayuda a alinear los valores para la presentación en forma tabular u otros diseños organizados visualmente. Antes del valor de ancho, puede especificar el carácter de relleno, ya sea un espacio o un cero.

Para alinear a la izquierda un valor, use el - bandera. Para alinear un valor a la derecha, omita la bandera o use la bandera '0' para relleno con ceros.

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

El valor se alinea a la derecha dentro de un ancho de 10 caracteres, lo que da como resultado ocho espacios iniciales antes del número.

Formato de cadena personalizado en Rust

El formato de cadena personalizado es importante para operaciones más exigentes. Puede crear implementaciones de formato personalizado para sus tipos con el integrado de Rust estándar:: fmt módulo.

El estándar:: fmt El módulo proporciona características para dar formato a la salida con una amplia gama de opciones para personalizar la apariencia de los datos durante el proceso de conversión de cadenas. El estándar:: fmt módulo proporciona un Mostrar y Depurar rasgo que es útil para las operaciones de formato de cadena.

El rasgo de visualización

El Mostrar El rasgo ayuda a producir resultados legibles por humanos al definir cómo se debe formatear un objeto con el {} marcador de posición en una cadena. Puede implementar el Mostrar rasgo para su tipos personalizados definiendo un método llamado fmt que toma un formateador como argumento.

El formateador proporciona varios métodos para controlar la salida del formato, como el escribir_cadena y escribir_fmt métodos.

usar estándar:: fmt;
// Definir una estructura llamada `Punto`
estructuraPunto {
 X: i32,
 y: i32,
}
// Implementar el rasgo `Mostrar` para `Punto`
impl fmt:: Pantalla para Punto {
fnfmt(&ser, f: &mudo fmt:: Formateador<'_>) -> fmt::Resultado {
// Formatear la estructura `Punto` como "(x, y)"
¡escribir!(F, "({}, {})", ser.X, ser.y)
 }
}
fnprincipal() {
// Crear una nueva instancia de `Punto`
dejar punto = Punto { x: 5, y: 10 };
// Imprime la estructura `Point` usando el formato `Display`
imprimir!("La cuestión es: {}", punto);
}

El Punto struct implementa el Mostrar rasgo. Dentro de fmt método, el ¡escribir! formatos de macro y escriba la salida deseada en el formateador con el {} marcador de posición

El rasgo de depuración

El Depurar rasgo es similar al Mostrar rasgo, excepto que se enfoca en producir una salida adecuada para la depuración y manejo de errores propósitos El Depurar El rasgo se utiliza principalmente con el {:?} marcador de posición

Implementando el Depurar El rasgo en sus tipos personalizados es sencillo. El Depurar El rasgo proporciona una implementación predeterminada basada en el Mostrar rasgo. Sin embargo, puede invalidar el comportamiento predeterminado para proporcionar una representación de depuración especializada.

usar estándar:: fmt;
// Definir una estructura llamada `Persona`
#[derivar (Depurar)]
estructuraPersona {
 nombre: Cadena,
 edad: u32,
}
// Implementar el rasgo `Mostrar` para `Persona`
impl fmt:: Pantalla para Persona {
fnfmt(&ser, f: &mudo fmt:: Formateador) -> fmt::Resultado {
// Dar formato a la estructura `Person` como una cadena legible por humanos
¡escribir!(F, "Nombre Edad: {}", ser.nombre, ser.edad)
 }
}
fnprincipal() {
// Crear una nueva instancia de `Persona`
dejar persona = Persona {
 nombre: Cadena::de("Alicia"),
 edad: 30,
 };
// Imprime la estructura `Person` usando el formato `Display`
imprimir!("Mostrar: {}", persona);
// Imprime la estructura `Person` usando el formato `Debug`
imprimir!("Depurar: {:?}", persona);
}

El programa deriva el Depurar rasgo para el Persona estructura con #[derivar (Depurar)]. Esto genera automáticamente la implementación basada en los campos de estructura.

La macro println imprime la representación de depuración con el Depurar marcador de posición de formato para formatear la salida usando el Depurar implementación.

Rust tiene un sistema tipográfico rico en características

El sistema de tipos enriquecidos de Rust juega un papel crucial en el formato de cadenas. Al aprovechar la escritura estática y las poderosas bibliotecas de formato de Rust, puede escribir código seguro y eficiente mientras maneja tareas de formateo y manipulación de cadenas.

El sistema de tipos garantiza la seguridad en tiempo de compilación y evita errores comunes, desde discrepancias de tipos hasta problemas con el especificador de formato. Con la combinación del sistema de tipos de Rust y sus amplias capacidades de formateo, puede aborde con confianza los desafíos de formato de cadenas y benefíciese del rendimiento y la seguridad del lenguaje garantías.