Rust 슬라이스

/*
//enumerate사용법
fn main() {
    let s = String::from("hello");

    return_char(&s);
}

fn return_char(s: &String) -> usize
{
    let bytes = s.as_bytes();

    enumerate()함수는 튜플을 반환한다.
    for (i,&item) in bytes.iter().enumerate(){
        println!("i : {}, item : {}",i,item);
        if item == b' '{
            return i;
        }
    }

    s.len()
    
} */

/*
//문자열 슬라이스
fn main()
{
    let s = String::from("hello world");

    let hello = &s[0..5];
    let world = &s[6..11];
}

*/

/*
//수정된 first_word함수
fn main()
{
    let s1 = String::from("hello world");
    
    let words = first_word(&s1);

    
    //s1.clear(); //<- 에러남 이미 다른이에게 빌려줬음

    println!("words : {}",words);


}

fn first_word(s1 : &String) -> &str
{
    for (i,&item) in s1.as_bytes().iter().enumerate(){
        if item == b' '{
            return &s1[0..i]
        }
    };

    &s1[0..]
}*/

/*
//리터럴 문자열은 이미 슬라이스가 되어있다.
fn main()
{
    let my_string = String::from("hello world");

    println!("my_string : {}",my_string);
    //first_word 함수에 String 타입으로 부터 생성한 문자열 슬라이스를 전달한다.
    let word = first_word(&my_string[..]);

    println!("word1 : {}",word);
    let my_string_literal = "hello world";
    println!("my_String_literal : {}",my_string_literal);
    //first_word함수에 문자열 리터럴의 슬라이스를 전달한다.
    let word = first_word(&my_string_literal[..]);
    println!("word2 : {}",word);
    //문자열 리터럴은 이미 문자열 슬라이스이기 때문에
    //아래의 코드는 슬라이스 문법 없이도 정상적으로 동작한다.
    let word = first_word(my_string_literal);
    println!("word3 : {}",word);
}

fn first_word(s:&str)->&str
{
    &s[..]
}
*/

/*
//다른 타입의 슬라이스
fn main()
{
    let array = [1,2,3,4,5,6];

    let integer_slice = &array[..4];
    
    for (i,&item) in integer_slice.iter().enumerate(){

        println!("integer_slice[{}] = {}",i,item);
    }

    
}
*/