String-Slicing und Bytes

fn main() {
    let s = "Hallo, Welt!";
    let a: &str = &s[..5];     // "Hallo"
    let b: &str = &s[7..];      // "Welt!"
    let c: &str = &s[..];       // "Hallo, Welt!"
    println!("{a} {b}");
}

fn main() {
    let s = "Müller";
    println!("Länge in Bytes: {}", s.len());           // 7 (nicht 6!)
    println!("Anzahl Zeichen: {}", s.chars().count()); // 6

    let h: &str = &s[..1];      // "M" — ok, M ist 1 Byte
    // let bad: &str = &s[..2];  // Panic! — Grenze mitten in 'ü'
    let ok: &str = &s[..3];     // "Mü" — ok, ü endet bei Byte 3
}

thread 'main' panicked at 'byte index 2 is not a char boundary;
it is inside 'ü' (bytes 1..3) of `Müller`'

fn sicher_slicen(s: &str, n: usize) -> &str {
    if s.is_char_boundary(n) {
        &s[..n]
    } else {
        ""
    }
}

let s = "Müller";
let teil: Option<&str> = s.get(0..2);    // None — keine gültige Grenze
let teil: Option<&str> = s.get(0..3);    // Some("Mü")

let s = "Müller";
let runter: usize = s.floor_char_boundary(2);    // 1 (eine Grenze davor)
let hoch: usize = s.ceil_char_boundary(2);       // 3 (eine Grenze danach)
let teil = &s[..runter];                          // "M"

let s = "Müller";
let bytes: &[u8] = s.as_bytes();
println!("{:?}", bytes);
// [77, 195, 188, 108, 108, 101, 114]

for &b in bytes {
    print!("{b:02x} ");
}
// 4d c3 bc 6c 6c 65 72

let bytes = b"Hallo";        // &[u8; 5]

// Validierende Konvertierung
let s: Result<&str, _> = std::str::from_utf8(bytes);
match s {
    Ok(text) => println!("{text}"),
    Err(e) => eprintln!("Kein UTF-8: {e}"),
}

// Unsicher (überspringt Validierung)
let unsafe_s: &str = unsafe { std::str::from_utf8_unchecked(bytes) };

let einzel: u8 = b'A';                    // 65
let array: &[u8; 5] = b"Hallo";           // [72, 97, 108, 108, 111]
let raw: &[u8; 4] = b"\xDE\xAD\xBE\xEF";  // binäre Bytes

// Bytestring kann nur ASCII (oder Hex-Escapes) enthalten
// let umlaut = b"Müller";  // Fehler — kein UTF-8 in Byte-Literalen

let s = "Café";
let pos = s.find('f');             // Some(2) — Byte-Index nach 'C' und 'a'
let pos2 = s.find('é');             // Some(3) — Byte-Index nach 'Caf'

// Mit Slicing zusammen — funktioniert immer korrekt,
// weil find() garantiert eine gültige char-Grenze liefert
if let Some(p) = s.find('f') {
    println!("Davor: {}", &s[..p]);    // "Ca"
    println!("Ab dort: {}", &s[p..]);   // "fé"
}

fn split_pfad_query(url: &str) -> (&str, Option<&str>) {
    match url.find('?') {
        Some(pos) => (&url[..pos], Some(&url[pos + 1..])),
        None => (url, None),
    }
}

fn main() {
    let url = "/users/42?include=email&fields=name";
    let (pfad, query) = split_pfad_query(url);
    assert_eq!(pfad, "/users/42");
    assert_eq!(query, Some("include=email&fields=name"));
}

fn truncate_an_grenze(s: &str, max_bytes: usize) -> &str {
    if s.len() <= max_bytes {
        return s;
    }
    let mut i = max_bytes;
    while !s.is_char_boundary(i) {
        i -= 1;
    }
    &s[..i]
}

fn main() {
    let lang = "Ich bin ein längerer Text mit Umlauten äöü";
    let kurz = truncate_an_grenze(lang, 12);
    println!("{kurz}");          // Garantiert valides UTF-8
}

fn parse_header(zeile: &str) -> Option<(&str, &str)> {
    let pos = zeile.find(':')?;
    let name = zeile[..pos].trim();
    let wert = zeile[pos + 1..].trim();
    Some((name, wert))
}

fn main() {
    let h = "Content-Type: text/html; charset=utf-8";
    if let Some((name, wert)) = parse_header(h) {
        assert_eq!(name, "Content-Type");
        assert_eq!(wert, "text/html; charset=utf-8");
    }
}

fn erkenne_format(daten: &[u8]) -> &'static str {
    if daten.starts_with(b"\x89PNG\r\n\x1a\n") { return "PNG"; }
    if daten.starts_with(&[0xFF, 0xD8, 0xFF])  { return "JPEG"; }
    if daten.starts_with(b"GIF87a") || daten.starts_with(b"GIF89a") { return "GIF"; }
    "unbekannt"
}