目前，您无法使用标准库执行此操作，但可以：

• 使用我的板条箱radix_fmt
• 或者推出您自己的实现：

fn format_radix(mut x: u32, radix: u32) -> String {
    let mut result = vec![];

    loop {
        let m = x % radix;
        x = x / radix;

        // will panic if you use a bad radix (< 2 or > 36).
        result.push(std::char::from_digit(m, radix).unwrap());
        if x == 0 {
            break;
        }
    }
    result.into_iter().rev().collect()
}

fn main() {
    assert_eq!(format_radix(1234, 10), "1234");
    assert_eq!(format_radix(1000, 10), "1000");
    assert_eq!(format_radix(0, 10), "0");
}

如果你想增加一点性能，你可以创建一个struct并为它实现Display或Debug。这样就避免了分配String。为了最大限度的过度设计，你也可以用一个堆栈分配的数组来代替Vec。
以下是应用了这些更改的Boiethios' answer：

struct Radix {
    x: i32,
    radix: u32,
}

impl Radix {
    fn new(x: i32, radix: u32) -> Result<Self, &'static str> {
        if radix < 2 || radix > 36 {
            Err("Unnsupported radix")
        } else {
            Ok(Self { x, radix })
        }
    }
}

use std::fmt;

impl fmt::Display for Radix {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut x = self.x;
        // Good for binary formatting of `u128`s
        let mut result = ['\0'; 128];
        let mut used = 0;
        let negative = x < 0;
        if negative {
            x*=-1;
        }
        let mut x = x as u32;
        loop {
            let m = x % self.radix;
            x /= self.radix;

            result[used] = std::char::from_digit(m, self.radix).unwrap();
            used += 1;

            if x == 0 {
                break;
            }
        }

        if negative {
            write!(f, "-")?;
        }

        for c in result[..used].iter().rev() {
            write!(f, "{}", c)?;
        }

        Ok(())
    }
}

fn main() {
    assert_eq!(Radix::new(1234, 10).to_string(), "1234");
    assert_eq!(Radix::new(1000, 10).to_string(), "1000");
    assert_eq!(Radix::new(0, 10).to_string(), "0");
}

这仍然可以通过以下方式优化：

• 创建ASCII数组而不是char数组
• 不为零-初始化数组

由于这些方法需要unsafe或arraybuf这样的外部机箱，所以我没有将它们包括在内，您可以在标准库的内部实现细节中看到示例代码。

第一个注解的扩展解决方案，未将参数x绑定为u32。

fn format_radix(mut x: u128, radix: u32) -> String {
    let mut result = vec![];

    loop {
        let m = x % radix as u128;
        x = x / radix as u128;

        // will panic if you use a bad radix (< 2 or > 36).
        result.push(std::char::from_digit(m as u32, radix).unwrap());
        if x == 0 {
            break;
        }
    }
    result.into_iter().rev().collect()
}

这比另一个答案要快：

use std::char::from_digit;

fn encode(mut n: u32, r: u32) -> Option<String> {
   let mut s = String::new();
   loop {
      if let Some(c) = from_digit(n % r, r) {
         s.insert(0, c)
      } else {
         return None
      }
      n /= r;
      if n == 0 {
         break
      }
   }
   Some(s)
}

注意我也试过这些，但是它们比较慢：

• https://doc.rust-lang.org/std/collections/struct.VecDeque.html#method.push_front
• https://doc.rust-lang.org/std/string/struct.String.html#method.push
• https://doc.rust-lang.org/std/vec/struct.Vec.html#method.insert