How do I print an integer in binary with leading zeros?

by 
let flags = 0b0000000000101100u16;
println!("flags: {:#018b}", flags);

The 018 pads with zeros to a width of 18. That width includes 0b (length=2) plus a u16 (length=16) so 18 = 2 + 16. It must come between # and b.

Rust’s fmt docs explain both leading zeros and radix formatting, but don’t show how to combine them.

Here are u8, u16, and u32:

//                       Width  0       8      16      24      32
//                              |       |       |       |       |
println!("{:#010b}", 1i8);  // 0b00000001
println!("{:#018b}", 1i16); // 0b0000000000000001
println!("{:#034b}", 1i32); // 0b00000000000000000000000000000001

More Related Contents:

  1. Why do I need to import a trait to use the methods it defines for a type?
  2. Why does linking lifetimes matter only with mutable references?
  3. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  4. Should trait bounds be duplicated in struct and impl?
  5. Can I do type introspection with trait objects and then downcast it?
  6. How can I perform parallel asynchronous HTTP GET requests with reqwest?
  7. Convert a String to int?
  8. How do I borrow a RefCell, find a key, and return a reference to the result? [duplicate]
  9. How can I store a Chars iterator in the same struct as the String it is iterating on?
  10. How to disable unused code warnings in Rust?
  11. Is there a way other than traits to add methods to a type I don’t own?
  12. What is the difference between `e1` and `&e2` when used as the for-loop variable?
  13. What does ‘let x = x’ do in Rust?
  14. Why is the `Sized` bound necessary in this trait?
  15. Is it possible to return either a borrowed or owned type in Rust?
  16. How do I overcome match arms with incompatible types for structs implementing same trait?
  17. Example of how to use Conditional Compilation Macros in Rust
  18. How can I call a raw address from Rust?
  19. Is there a way to perform an index access to an instance of a struct?
  20. How to use a local unpublished crate?
  21. Why do I get “type annotations needed” when using Iterator::collect?
  22. Why would I use divergent functions?
  23. How to generate statically linked executables?
  24. Why can I iterate over a slice twice, but not a vector?
  25. When is it necessary to circumvent Rust’s borrow checker?
  26. Cannot use moved BufReader after for loop with bufreader.lines()
  27. How does the Rust compiler know `Cell` has internal mutability?
  28. Creating Diesel.rs queries with a dynamic number of .and()’s
  29. How do I match based on a dynamic variable?
  30. How to match trait implementors

Leave a Comment