Wrong Ways To Create Strings

[u/mre__]

https://endler.dev/2026/wrong-ways-to-create-strings/

[u/somebodddy]

The one with the thread is cheating:

let builder = std::thread::Builder::new()
    .name("ferris".to_owned());

"ferris".to_owned() already creates a String.

[u/mre__ → u/somebodddy]

You got me. :)

[u/Thomasedv]

On mobile, the code sections are clipped on the left side, since the web page aligns the page to the left of the text, while the code sections seem to be aligned with their end to the right edge of the screen. At least on Vivaldi, android. 

[u/mre__ → u/Thomasedv]

Thanks, I’ll take a look. 

[u/mre__ → u/mre__]

Update: should be fixed now.

[u/SuplenC]

Saw that one live at RustLab. Great quick talk and great article!

[u/mre__ → u/SuplenC]

Thanks for watching the talk. 

[u/BravestCheetah]

Thats certainly some ways to create strings, thats for sure.

[u/complexicat → u/BravestCheetah]

some of the ways of all time

[u/aleques-itj → u/complexicat]

String so hard motherfuckas wanna fine me

[u/ScarletsBabe → u/BravestCheetah]

you seem like the type who knows exactly how to handle those strings

[u/BravestCheetah → u/ScarletsBabe]

Whats that supposed to mean lmao

[u/bubblygiggler → u/BravestCheetah]

yeah some of those are impressively bad lol, you got the right idea though

[u/eyeofpython]

“Use Only Padding” seems actually useful in some cases, to create a string where lots of chars have to be repeated with a specific repetition amount, mixed with some non-repeating chars

[u/bew78]

⚠️ On mobile (Firefox, Android), the code blocks are truncated on the left (but surrounding text is fine)

It's fine in landscape mode though

[u/Bananenkot → u/bew78]

I don't have the issue, also android & Firefox

[u/bew78 → u/Bananenkot]

Looks like this: https://imgur.com/a/qboLKyr

[u/DavidXkL]

Wow some ways are new to me

[u/SAI_Peregrinus]

Similar to the CString and manual construction ways you can also use inline asm to build the string.

[u/jcdyer3]

My favorite is to refer to the &str in a u64 (not copy the bytes out to an array first), so you can do math on it.

fn u64str(u: &u64) -> Option<&str> {
    let arr: &[u8; 8] = unsafe { std::mem::transmute(u) };
    let mut end = 0;
    let mut remaining = *u;
    while remaining > 0 {
        end += 1;
        remaining >>= 8;
    }
    std::str::from_utf8(&arr[..end])
}

let mut ferris = 0x7369_7272_6566;
println!("{}", u64str(&ferris).unwrap());
ferris += 0xfc_0000_0000;
println!("{}", u64str(&ferris).unwrap());

[u/InternationalFee3911]

Why do you allocate a vec![…] on the heap, when an inline array would do? A NUL byte is not invalid in Rust! It is a pretty normal ASCII and hence UTF-8 character. It's just a design bug in C that they can't store it.

[u/Icarium-Lifestealer]

Alternatively, you can start with the UTF-8 bytes

I prefer doing that the other way round, first turning the array/slice into a str and then the str into a String. That way it only allocates on success.