Rust
문자열

소개

기본 문자열 조작

fn main() {
    // Statically allocated string slice
    let hello = "Hello world";

    // This is equivalent to the previous one
    let hello_again: &'static str = "Hello world";

    // An empty String
    let mut string = String::new();

    // An empty String with a pre-allocated initial buffer
    let mut capacity = String::with_capacity(10);

    // Add a string slice to a String
    string.push_str("foo");

    // From a string slice to a String
    // Note: Prior to Rust 1.9.0 the to_owned method was faster
    // than to_string. Nowadays, they are equivalent.      
    let bar = "foo".to_owned();
    let qux = "foo".to_string();

    // The String::from method is another way to convert a
    // string slice to an owned String.
    let baz = String::from("foo");

    // Coerce a String into &str with &
    let baz: &str = &bar;
}

참고 : String::new 및 String::with_capacity 메서드는 모두 빈 문자열을 만듭니다. 그러나 후자는 초기 버퍼를 할당하여 초기에는 느려지지만 후속 할당은 줄입니다. String의 최종 크기를 알고 있으면 String::with_capacity 가 선호됩니다.

문자열 분할

fn main() {
    let english = "Hello, World!";

    println!("{}", &english[0..5]); // Prints "Hello"
    println!("{}", &english[7..]);  // Prints "World!"
}

여기에 & 연산자를 사용해야합니다. 레퍼런스를 취하여 슬라이더 타입의 크기에 대한 정보를 컴파일러에 제공합니다. 참조없이 두 개의 println! 호출은 컴파일 타임 오류가됩니다.

경고 : 슬라이싱은 문자 오프셋이 아닌 바이트 오프셋으로 작동하며 경계가 문자 경계에 있지 않을 때 패닉이 발생합니다.

fn main() {
    let icelandic = "Halló, heimur!"; // note that “ó” is two-byte long in UTF-8

    println!("{}", &icelandic[0..6]); // Prints "Halló", “ó” lies on two bytes 5 and 6
    println!("{}", &icelandic[8..]);  // Prints "heimur!", the “h” is the 8th byte, but the 7th char
    println!("{}", &icelandic[0..5]); // Panics!
}

이것은 문자열이 간단한 색인 생성을 지원하지 않는 이유이기도합니다 (예 : icelandic[5] ).

문자열 분할

let strings = "bananas,apples,pear".split(",");

split 은 반복자를 반환합니다.

for s in strings {
  println!("{}", s)
}

그리고 Iterator::collect 메소드를 사용하여 Vec 에서 "수집"할 수 있습니다.

let strings: Vec<&str> = "bananas,apples,pear".split(",").collect(); // ["bananas", "apples", "pear"]

빌린에서 소유까지

// all variables `s` have the type `String`
let s = "hi".to_string();  // Generic way to convert into `String`. This works
                           // for all types that implement `Display`.

let s = "hi".to_owned();   // Clearly states the intend of obtaining an owned object

let s: String = "hi".into();       // Generic conversion, type annotation required
let s: String = From::from("hi");  // in both cases!

let s = String::from("hi");  // Calling the `from` impl explicitly -- the `From` 
                             // trait has to be in scope!

let s = format!("hi");       // Using the formatting functionality (this has some
                             // overhead)

format!() 외에도 위의 모든 메소드는 똑같이 빠릅니다.

긴 문자열 리터럴 깨짐

\ 문자가있는 일반 문자열 리터럴을 끊습니다.

let a = "foobar";
let b = "foo\
         bar";

// `a` and `b` are equal.
assert_eq!(a,b);

원본 문자열 리터럴을 분리하여 문자열을 분리하고 concat! 과 결합하십시오 concat! 매크로

let c = r"foo\bar";
let d = concat!(r"foo\", r"bar");

// `c` and `d` are equal.
assert_eq!(c, d);