Rust 기본 개념

변수와 가변성

let으로 불변성 변수 선언

값 변경을 시도하면 에러가 발생 합니다.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

error[E0384]: re-assignment of immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         - first assignment to `x`
3 |     println!("The value of x is: {}", x);
4 |     x = 6;
  |     ^^^^^ re-assignment of immutable variable​

 

mut으로 가변성 변수 선언

값을 변경해도 에러발생 안합니다.

fn main() {
    let mut x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30 secs
     Running `target/debug/variables`
The value of x is: 5
The value of x is: 6

 

const로 상수 선언

상수는 불변성이며 오직 상수 표현식만 가능합니다. 함수 리턴값이나 실행 중에 결정되는 값이 설정 될 수 없습니다.

const MAX_POINTS: u32 = 100_000;

 

shadowing

mut과 shadowing의 차이는 값의 유형을 변경 할 수 있다는 점입니다.

let spaces = "   ";
let spaces = spaces.len();

첫 spaces 변수가 문자열 유형이고 두 번째 spaces 변수는 첫 번째 것과 동일한 이름을 가진 새롭게 정의된 숫자 유형의 변수입니다.

let mut spaces = "   ";
spaces = spaces.len();

하지만 mut으로 선언하면 변수의 유형을 변경할 수 없다는 에러가 발생합니다.

error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
3 |     spaces = spaces.len();
  |              ^^^^^^^^^^^^ expected &str, found usize
  |
  = note: expected type `&str`
             found type `usize`

 

데이터 타입

타입 명시( :u32 )를 하지 않으면 Rust는 에러를 발생합니다.

let guess: u32 = "42".parse().expect("Not a number!");

error[E0282]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let guess = "42".parse().expect("Not a number!");
  |         ^^^^^
  |         cannot infer type for `_`
  |         consider giving `guess` a type

 

튜플

튜플은 다양한 타입의 숫자를 집합시켜 하나의 복합 타입으로 만듭니다. 튜플 값의 타입이 동일할 필요가 없습니다.

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

 

배열

배열의 모든 요소는 모두 같은 타입이여야 합니다.

배열의 끝을 넘어선 요소에 접근하려해도 컴파일 에러는 발생하지 않습니다. 실행결과는 성공적으로 종료되지 못했다고 나옵니다.

fn main() {
    let a = [1, 2, 3, 4, 5];
    let index = 10;

    let element = a[index];

    println!("The value of element is: {}", element);
}

$ cargo run
   Compiling arrays v0.1.0 (file:///projects/arrays)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs
     Running `target/debug/arrays`
thread '<main>' panicked at 'index out of bounds: the len is 5 but the index is
 10', src/main.rs:6
note: Run with `RUST_BACKTRACE=1` for a backtrace.

색인을 사용하여 요소에 접근하려고 하면 Rust는 지정한 색인이 배열 길이보다 작은지 확인합니다. 색인이 길이보다 길면 Rust는 프로그램이 오류와 함께 종료 될 때 Rust가 사용하는 용어인 *패닉(panic)*합니다.

 

함수

 Rust는 함수의 위치를 신경쓰지 않습니다, 어디든 정의만 되어 있으면 됩니다.

fn main() {
    another_function(5, 6);
}

fn another_function(x: i32, y: i32) {
    println!("The value of x is: {}", x);
    println!("The value of y is: {}", y);
}

 

표현식

let x = 5; 은 구문입니다:

함수 정의는 또 하나의 구문입니다. 구문은 값을 반환하지 않습니다. 그러니, let 구문을 사용해서는 다른 변수에 값을 대입(let x = (let y = 6); )할 수 없습니다.

함수를 호출하는 것은 표현식입니다. 새로운 범위를 생성하는데 사용하는 block { let x = 3; x + 1 };은 표현식입니다.

표현식 x + 1 줄의 마지막이 세미콜론으로 끝나지 않습니다. 표현식은 종결을 나타내는 세미콜론을 사용하지 않습니다.

만약 세미콜론을 표현식 마지막에 추가하면, 이는 구문으로 변경되고 반환 값이 아니게 됩니다.

fn main() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1
    };

    println!("The value of y is: {}", y);
}

 

반환값을 갖는 함수

plus_one 함수의 반환값은 x + 1  이고 반환타입을 i32로 합니다.

fn main() {
    let x = plus_one(5);

    println!("The value of x is: {}", x);
}

fn plus_one(x: i32) -> i32 {
    x + 1
}

 

제어문

조건은 반드시 bool이어야 합니다. Rust는 boolean 타입이 아닌 것을 boolean 타입으로 자동 변환하지 않습니다.

fn main() {
    let number = 3;

    if number {
        println!("number was three");
    }
}

 

반복문

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("the value is: {}", element);
    }
}

 

range를 역순하는 rev메소드를 사용하는 카운트다운

fn main() {
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");
}

3!
2!
1!
LIFTOFF!!!