En Rust, usamos macros para imprimir textos formateados en el editor. Las macros brindan una funcionalidad similar a las funciones pero sin el costo del tiempo de ejecución. Las declaraciones de impresión se utilizan ampliamente en la programación. Se utilizan para solicitar información a los usuarios o para depurar el programa. Las macros en Rust terminan con un signo de exclamación (!).
Algunas de las macros utilizadas son:
- ¡formato!: Convierte texto formateado a String
- ¡impresión! : ¡impresión! es similar al formato! pero el texto se imprime en la consola
- imprimir! : imprimir! es similar a imprimir! pero se agrega una nueva línea.
- eprint!: eprint! es similar a imprimir! siendo la salida enviada al error estándar la excepción.
- eprintln! : eprint! es similar a eprint! excepto que agrega una nueva línea al final de la string.
Aquí, discutimos las macros más utilizadas:
1. ¡formato!:
¡formato! se utiliza principalmente en la concatenación de strings. ¡El formato del primer argumento! recibe es una string de formato que debería ser un literal de string.
Ejemplo 1:
Rust
// Rust program for format!
fn main() {
// it formats the enclosed string
// in the braces till the 5th index
let new_string= format!("Geeks for Geeks {:.6}", "Courses");
println!("{}", new_string);
}
Producción:
2. imprimir!:
¡impresión! es una macro que imprime texto formateado en la consola (o salida estándar). ¡impresión! recibe múltiples argumentos donde el primer argumento es la string literal y las llaves {} en el primer argumento se reemplazan por los valores a los que se hace referencia, lo que da como resultado que el formato de la string se imprima en la consola.
En el siguiente ejemplo, las llaves se reemplazan por Cursos y la string formateada resultante se envía a la consola (Salida).
Ejemplo 2:
Rust
// Rust program for ptint!
fn main() {
// \n -> new line character
print!("Geeks for Geeks {}!\n", "Courses");
}
Producción:
Ejemplo 3:
Rust
// The first curly braces{} is replaced
// with GeeksforGeeks, the second braces {}
// is replaced with Jonathon, and the third
// {} is replaced with 2.5
fn main() {
print!("The {} {} is generally of {} hours ",
"GeeksforGeeks", "Jobathon",2.5);
}
Producción:
Ejemplo 4:
Rust
// Rust print example
fn main() {
print!("The coordinates of Noida: {x}N,{y}E",
x=28.55,y=77.39);
}
Producción:
3. imprimir!:
¡La impresión! macro es lo mismo que una impresión! excepto que agrega automáticamente la nueva línea \n automáticamente al final de la string.
Ejemplo 5:
Rust
// Rust PrintIn program
fn main() {
let a = 10.0;
let b = 3.0;
let c=a/b;
// prints decimal upto 3 decimal places
println!("c is: {:.3}",c);
// appends three blank spaces at first and then
// 3 digits after the decimal and the total
// no: of digits is 8
println!("c is: {:8.3}",c);
// appends three zeros at first and then 3 digits after
// decimal and the total no: of digits is 8
println!("c is: {:08.3}",c);
}
Salida :
4. eprint!:
El eprint! es similar a imprimir! excepto que muestra la salida como un error y se usa para informar mensajes de error. El siguiente ejemplo imprime «GFG» y «Curso» en la misma línea pero como un error.
Ejemplo 6:
Rust
// Rust program for eprint!
fn main() {
eprint!("GFG");
eprint!(" Courses");
}
Producción:
5. eprintln! :
La macro eprint!() muestra el resultado como un error y agrega una nueva línea (\n) al final. El siguiente ejemplo imprime «GFG» como un error y le agrega una nueva línea, luego imprime «Curso» y agrega una nueva línea.
Ejemplo 7:
Rust
// Rust program for eprintln!
fn main() {
eprintln!("GFG");
eprintln!("Course");
}
Producción:
