문자열 method(계속 추가)

선언

//선언
let mut tmp = String::from("");

 

문자열 casting

let mut s = String::from("");
let mut c = 'c';
s = c.to_string();
println!("char to string : [{}]", s);

let mut i = 1;
s = i.to_string();
println!("i32 to string : [{}]", s);

let mut f = 1.0;
s = f.to_string();
println!("f64 to string : [{}]", s);

i = s.parse().unwrap();
println!("string to i32 : [{}]", i);

f = s.parse().unwrap();
println!("string to i64 : [{}]", f);

c = s.parse().unwrap();
println!("string to char : [{}]", c);

//string to diff type
let d = s.parse<T>().unwrap();

 

문자열 reverse

//reverse
tmp = tmp.chars().rev().collect::<String>();

 

문자열 indexing(rust의 문자열은 index로 접근 불가능)

//문자열 인덱싱
let word_arr : Vec<char>= word.chars().collect();
println!("{}", word_arr[0]);

 

문자열 iterator

for c in str.chars(){
   println!("{}",c);
}

 

문자열 to byte

struct StringMethod{
    s : String
}

impl StringMethod{
    fn new(input_string: String) -> Self{
        StringMethod{
            s : String::from(input_string)
        }
    }
    fn byte_method(&mut self){
        //Bytes type으로 반환
        let mut byte = self.s.bytes();
        println!("{:?}", byte);
        while let Some(b) = byte.next(){
            println!("{}", b);
        }
    }
    fn as_byte_method(&mut self){
        //u8를 참조하는 배열로 반환
        let mut bytes = self.s.as_bytes();
        println!("{:?}", bytes);
    }
}

문자열 io

fn io(){
    let mut buffer = String::new();
    let mut stdin = io::stdin();
    stdin.read_line(&mut buffer).expect("failure");
    println!("{}", buffer);
}

 

문자열 sub

fn sub_str(str: String, start: usize, end: usize) -> String{
    String::from(&str[start..end])
}