Variable

let

๊ธฐ๋ณธ์ ์œผ๋กœ ๋ณ€์ˆ˜๋Š” let ์œผ๋กœ ์„ ์–ธํ•˜๊ณ  ๋ถˆ๋ณ€์ด๋ฉฐ, mut์œผ๋กœ ๊ฐ€๋ณ€์œผ๋กœ ์„ ์–ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค

fn main() {
    let junny = 1;
    let mut mutableJunny = 2;
    
    junny = 4; // error: cannot assign twice to immutable variable `junny`
    mutableJunny = 4;// ok
}

const

์ƒ์ˆ˜๋Š” ๋ถˆ๋ณ€์„ฑ์„ ๋„๊ณ  mut์ด ํ—ˆ์šฉ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค

fn main() {
    const JUNNY:str = *"land";
    const AGE:i32 = 20;
}

Shadowing

๊ฐ™์€ ์ด๋ฆ„์˜ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•  ์ˆ˜ ์žˆ๊ณ  ๊ฐ’์€ ๋ฎ์–ด์”Œ์›Œ์ง‘๋‹ˆ๋‹ค.

fn main() {
    let x = 5;
    let x = x + 1;
    let x = x * 3;
    print!("value : {}", x);
}
> value : 18

Type

Rust๋Š” ์ •์  ํƒ€์ž… ์–ธ์–ด๋กœ, ์ปดํŒŒ์ผ ํƒ€์ž„์— ๋ชจ๋“  ๋ณ€์ˆ˜์˜ ํƒ€์ž…์ด ๊ฒฐ์ •๋ฉ๋‹ˆ๋‹ค. Rust์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์€ ํฌ๊ฒŒ ๋‘ ๊ฐ€์ง€ ๋ฒ”์ฃผ๋กœ ๋‚˜๋‰ฉ๋‹ˆ๋‹ค

์Šค์นผ๋ผ ํƒ€์ž…

์Šค์นผ๋ผ ํƒ€์ž…์€ ํ•˜๋‚˜์˜ ๊ฐ’์œผ๋กœ ํ‘œํ˜„๋˜๋Š” ํƒ€์ž…์ž…๋‹ˆ๋‹ค. Rust์—์„œ๋Š” 4๊ฐ€์ง€ ๊ธฐ๋ณธ ์Šค์นผ๋ผ ํƒ€์ž…์ด ์žˆ์Šต๋‹ˆ๋‹ค.

a. ์ •์ˆ˜ํ˜•(Integer): ์ •์ˆ˜ํ˜•์€ ๋ถ€ํ˜ธ ์žˆ๋Š” i8, i16, i32, i64, i128 ๋ฐ ๋ถ€ํ˜ธ ์—†๋Š” u8, u16, u32, u64, u128 ํƒ€์ž…์ด ์žˆ์Šต๋‹ˆ๋‹ค. ์ˆซ์ž๋Š” ํฌ๊ธฐ์— ๋”ฐ๋ผ ํ‘œํ˜„ ๋ฒ”์œ„๊ฐ€ ๋‹ค๋ฆ…๋‹ˆ๋‹ค.

b. ๋ถ€๋™ ์†Œ์ˆ˜์ (Floating-Point): ๋ถ€๋™ ์†Œ์ˆ˜์  ํƒ€์ž…์€ ์‹ค์ˆ˜๋ฅผ ํ‘œํ˜„ํ•ฉ๋‹ˆ๋‹ค. Rust์—์„œ๋Š” ๋‘ ๊ฐ€์ง€ ๋ถ€๋™ ์†Œ์ˆ˜์  ํƒ€์ž…์ด ์žˆ์Šต๋‹ˆ๋‹ค f32์™€ f64. ์ด ๋‘ ํƒ€์ž…์€ ๊ฐ๊ฐ 32๋น„ํŠธ์™€ 64๋น„ํŠธ๋กœ ํ‘œํ˜„๋˜๋ฉฐ, ๋‹จ์ •๋„์™€ ๋ฐฐ์ •๋„ ๋ถ€๋™ ์†Œ์ˆ˜์ ์„ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค.

c. ๋ถˆ๋ฆฌ์–ธ(Boolean): ๋ถˆ๋ฆฌ์–ธ ํƒ€์ž…์€ ์ฐธ(true) ๋˜๋Š” ๊ฑฐ์ง“(false)์˜ ๊ฐ’์„ ๊ฐ–์Šต๋‹ˆ๋‹ค. ๋ถˆ๋ฆฌ์–ธ ํƒ€์ž…์€ bool๋กœ ํ‘œํ˜„๋ฉ๋‹ˆ๋‹ค.

d. ๋ฌธ์ž(Character): ๋ฌธ์ž ํƒ€์ž…์€ ๋‹จ์ผ ์œ ๋‹ˆ์ฝ”๋“œ ์Šค์นผ๋ผ ๊ฐ’์„ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค. Rust์˜ ๋ฌธ์ž ํƒ€์ž…์€ char๋กœ ํ‘œํ˜„๋˜๋ฉฐ, ์ž‘์€ ๋”ฐ์˜ดํ‘œ๋กœ ๋ฌถ์ž…๋‹ˆ๋‹ค.

๋ณตํ•ฉ ํƒ€์ž…

๋ณตํ•ฉ ํƒ€์ž…์€ ์—ฌ๋Ÿฌ ๊ฐ’์„ ํ•˜๋‚˜์˜ ํƒ€์ž…์œผ๋กœ ๋ฌถ์Šต๋‹ˆ๋‹ค Rust์—์„œ๋Š” ํŠœํ”Œ(tuple)๊ณผ ๋ฐฐ์—ด(array)์ด ์ฃผ์š” ๋ณตํ•ฉ ํƒ€์ž…์ž…๋‹ˆ๋‹ค.

a. ํŠœํ”Œ(Tuple): ํŠœํ”Œ์€ ์—ฌ๋Ÿฌ ๊ฐ’์˜ ๊ณ ์ •๋œ ๊ธธ์ด์˜ ์ˆœ์„œ ์žˆ๋Š” ๋ชฉ๋ก์ž…๋‹ˆ๋‹ค. ๊ฐ ๊ฐ’์€ ์„œ๋กœ ๋‹ค๋ฅธ ํƒ€์ž…์„ ๊ฐ€์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํŠœํ”Œ์€ ๊ด„ํ˜ธ ()์™€ ์‰ผํ‘œ ,๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ •์˜๋˜๋ฉฐ, ํŠœํ”Œ์˜ ์š”์†Œ์— ์ ‘๊ทผํ•˜๋ ค๋ฉด ์  .์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

fn main() {
    let my_tuple = (1, "hello", 3.14);
    println!("The first element of my_tuple is: {}", my_tuple.0);
}

b. ๋ฐฐ์—ด(Array): ๋ฐฐ์—ด์€ ๋™์ผํ•œ ํƒ€์ž…์˜ ์—ฌ๋Ÿฌ ๊ฐ’์˜ ๊ณ ์ •๋œ ๊ธธ์ด์˜ ์ˆœ์„œ ์žˆ๋Š” ๋ชฉ๋ก์ž…๋‹ˆ๋‹ค ๋ฐฐ์—ด์€ ๋Œ€๊ด„ํ˜ธ []๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ •์˜๋˜๋ฉฐ, ์ธ๋ฑ์Šค๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐฐ์—ด์˜ ์š”์†Œ์— ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

rustCopy codefn main() {
    let my_array: [i32; 5] = [1, 2, 3, 4, 5];
    println!("The second element of my_array is: {}", my_array[1]);
}

์‚ฌ์šฉ์ž ์ •์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…

Rust๋Š” ์‚ฌ์šฉ์ž ์ •์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ๋งŒ๋“œ๋Š” ๋ฐ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๋ช‡ ๊ฐ€์ง€ ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค. ๊ตฌ์กฐ์ฒด(struct)์™€ ์—ด๊ฑฐํ˜•(enum)์€ ๋‘ ๊ฐ€์ง€ ์ฃผ์š” ์‚ฌ์šฉ์ž ์ •์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์ž…๋‹ˆ๋‹ค.

a. ๊ตฌ์กฐ์ฒด(Struct): ๊ตฌ์กฐ์ฒด๋Š” ์‚ฌ์šฉ์ž ์ •์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ๋งŒ๋“œ๋Š” ๋ฐ ์‚ฌ์šฉ๋˜๋ฉฐ, ์—ฌ๋Ÿฌ ํ•„๋“œ๋ฅผ ๋ฌถ์–ด ํ•˜๋‚˜์˜ ํƒ€์ž…์œผ๋กœ ์ •์˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ตฌ์กฐ์ฒด๋Š” struct ํ‚ค์›Œ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ •์˜ํ•ฉ๋‹ˆ๋‹ค.

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };
    println!("The point is at ({}, {})", p.x, p.y);
}

b. ์—ด๊ฑฐํ˜•(Enum): ์—ด๊ฑฐํ˜•์€ ์„œ๋กœ ๋‹ค๋ฅธ ํƒ€์ž…์˜ ์—ฌ๋Ÿฌ ๊ฐ’ ์ค‘ ํ•˜๋‚˜๋ฅผ ๊ฐ€์งˆ ์ˆ˜ ์žˆ๋Š” ์‚ฌ์šฉ์ž ์ •์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์ž…๋‹ˆ๋‹ค. ์—ด๊ฑฐํ˜•์€ enum ํ‚ค์›Œ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ •์˜๋˜๋ฉฐ, ๊ฐ๊ฐ์˜ ๊ฐ’์€ ์—ด๊ฑฐํ˜•์˜ ํ•œ ๋ฉค๋ฒ„์ž…๋‹ˆ๋‹ค.

enum Direction {
    North,
    South,
    East,
    West,
}

Rust์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๊ธฐ๋ณธ ๊ตฌ์„ฑ ์š”์†Œ๋กœ, ๋‹ค์–‘ํ•œ ๊ฐ’์„ ํšจ๊ณผ์ ์œผ๋กœ ์ €์žฅํ•˜๊ณ  ์ฒ˜๋ฆฌํ•˜๋Š” ๋ฐ ํ•„์š”ํ•œ ๋„๊ตฌ๋ฅผ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ์ดํ•ดํ•˜๊ณ  ์‚ฌ์šฉํ•˜๋ฉด ์ฝ”๋“œ์˜ ์•ˆ์ „์„ฑ๊ณผ ๊ฐ€๋…์„ฑ์„ ๋†’์ผ ์ˆ˜ ์žˆ์œผ๋ฉฐ, Rust์˜ ๊ฐ•๋ ฅํ•œ ํƒ€์ž… ์‹œ์Šคํ…œ์„ ์ตœ๋Œ€ํ•œ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. Rust์—์„œ ์ œ๊ณตํ•˜๋Š” ๊ธฐ๋ณธ ๋ฐ์ดํ„ฐ ํƒ€์ž… ์™ธ์—๋„, ์‚ฌ์šฉ์ž ์ •์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ์‚ฌ์šฉํ•˜์—ฌ ํ”„๋กœ์ ํŠธ์— ํ•„์š”ํ•œ ๋ณต์žกํ•œ ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋ฅผ ํ†ตํ•ด ์ฝ”๋“œ์˜ ๊ตฌ์กฐ๋ฅผ ๋ช…ํ™•ํ•˜๊ฒŒ ํ•˜๊ณ , ๊ด€๋ฆฌ ๋ฐ ์œ ์ง€ ๋ณด์ˆ˜๊ฐ€ ์‰ฌ์šด ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์„ ๊ฐœ๋ฐœํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค

ํƒ€์ž… ์ถ”๋ก 

Rust์˜ ํƒ€์ž… ์ถ”๋ก  ์‹œ์Šคํ…œ์€ ์ฝ”๋“œ ์ž‘์„ฑ์„ ๋” ๊ฐ„๊ฒฐํ•˜๊ฒŒ ๋งŒ๋“ค์–ด์ฃผ๋Š” ์ค‘์š”ํ•œ ๊ธฐ๋Šฅ์ž…๋‹ˆ๋‹ค. ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ๋Œ€๋ถ€๋ถ„์˜ ๊ฒฝ์šฐ ๋ณ€์ˆ˜์˜ ํƒ€์ž…์„ ์ž๋™์œผ๋กœ ์ถ”๋ก ํ•  ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ, ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•  ๋•Œ๋งˆ๋‹ค ๋ช…์‹œ์ ์œผ๋กœ ํƒ€์ž…์„ ์ง€์ •ํ•  ํ•„์š”๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๋ช…ํ™•ํ•œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•˜๊ฑฐ๋‚˜ ์ปดํŒŒ์ผ๋Ÿฌ์˜ ํƒ€์ž… ์ถ”๋ก ์„ ๋„์™€์ฃผ๊ธฐ ์œ„ํ•ด ํƒ€์ž…์„ ๋ช…์‹œ์ ์œผ๋กœ ์ง€์ •ํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค.

fn main() {
    let a = 42; // i32๋กœ ์ถ”๋ก ๋ฉ๋‹ˆ๋‹ค.
    let b: u32 = 42; // ๋ช…์‹œ์ ์œผ๋กœ u32 ํƒ€์ž…์œผ๋กœ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค.
}

Rust์˜ ์ œ๋„ค๋ฆญ์„ ์‚ฌ์šฉํ•˜๋ฉด ๋‹ค์–‘ํ•œ ํƒ€์ž…์— ๋™์ž‘ํ•˜๋Š” ํ•จ์ˆ˜๋‚˜ ๊ตฌ์กฐ์ฒด๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ œ๋„ค๋ฆญ์€ ํƒ€์ž…์— ๋Œ€ํ•œ ์ผ๋ฐ˜ํ™”๋ฅผ ๊ฐ€๋Šฅํ•˜๊ฒŒ ํ•˜์—ฌ ์ฝ”๋“œ์˜ ์ค‘๋ณต์„ ์ค„์ด๊ณ  ์žฌ์‚ฌ์šฉ์„ฑ์„ ๋†’์ด๋Š” ๋ฐ ๋„์›€์ด ๋ฉ๋‹ˆ๋‹ค.

Last updated

Was this helpful?