Data Types

Scalar Types

Scalar type แทนค่าเดียว Rust มี scalar type หลักสี่ประเภท

Integers

Integer type ฝัง signedness และขนาดบิตไว้ในชื่อ

Signed	Unsigned	ขนาด
`i8`	`u8`	8-bit
`i16`	`u16`	16-bit
`i32`	`u32`	32-bit (ค่าเริ่มต้น)
`i64`	`u64`	64-bit
`i128`	`u128`	128-bit
`isize`	`usize`	ขนาด pointer

Integer type เริ่มต้นคือ i32 ใช้ usize สำหรับ index เข้าถึง array และ slice

Floating-Point Numbers

Rust มี f32 (single precision) และ f64 (double precision เป็นค่าเริ่มต้น) ควรใช้ f64 เสมอ เว้นแต่จะมีเหตุผลเฉพาะด้านหน่วยความจำหรือ precision ให้ใช้ f32

Booleans และ Characters

bool มีค่าเป็น true หรือ false char แทน Unicode scalar value เดียวและมีขนาด สี่ byte — รองรับ emoji, ตัวอักษร CJK และ Unicode codepoint อื่นๆ ทั้งหมด

fn main() {
    let flag: bool = true;
    let letter: char = 'R';
    let emoji: char = '\u{1F980}'; // crab emoji
    println!("flag={}, letter={}, emoji={}", flag, letter, emoji);
}

Compound Types

Tuples

Tuple จัดกลุ่มค่าที่อาจมี type ต่างกันเข้าเป็นค่าเดียว มีความยาวคงที่ เข้าถึงแต่ละ element ด้วย dot notation และ index ที่นับจาก 0

fn main() {
    let point: (i32, f64, bool) = (1, 2.5, false);
    println!("{} {} {}", point.0, point.1, point.2);

    // Destructuring tuple
    let (a, b, c) = point;
    println!("a={}, b={}, c={}", a, b, c);
}

Arrays

Array เก็บค่าจำนวนคงที่ที่มี type เดียวกัน annotation ของ type คือ [T; N] โดย T คือ element type และ N คือความยาว ทั้งสองรู้ที่ compile time ใช้ slice (&[T]) เมื่อต้องการ view ที่มีขนาดแบบ dynamic

fn main() {
    let arr: [i32; 4] = [10, 20, 30, 40];
    println!("first={}, last={}, len={}", arr[0], arr[3], arr.len());

    // Repeat initializer: [value; count]
    let zeros = [0_i32; 5];
    println!("zeros len = {}", zeros.len());
}

Type Inference

ระบบ type ของ Rust เป็น static — ทุกค่ามี type ที่รู้ที่ compile time — แต่คุณแทบไม่ต้องเขียน type ออกมาเอง คอมไพเลอร์อนุมาน type จาก context คุณต้องใส่ annotation เมื่อการอนุมานมีความคลุมเครือเท่านั้น

fn main() {
    let n = 42;         // อนุมานเป็น i32
    let f = 1.5;        // อนุมานเป็น f64
    let s = "hello";    // อนุมานเป็น &str

    // Suffix syntax บังคับให้ใช้ numeric type เฉพาะ
    let byte = 255_u8;
    println!("{} {} {} {}", n, f, s, byte);
}

Open in Rust Playground

fn main() {
    // Scalar types
    let n: i32 = -42;
    let f: f64 = 3.14;
    let b: bool = true;
    let c: char = 'R';

    println!("i32: {}, f64: {}, bool: {}, char: {}", n, f, b, c);

    // Tuple: fixed-length, mixed types
    let tup: (i32, f64, bool) = (1, 2.5, false);
    println!("tuple.0 = {}, tuple.1 = {}, tuple.2 = {}", tup.0, tup.1, tup.2);

    // Array: fixed-length, same type
    let arr: [i32; 4] = [10, 20, 30, 40];
    println!("arr[0] = {}, arr[3] = {}, len = {}", arr[0], arr[3], arr.len());

    // Type inference
    let inferred = 99_u8;
    println!("inferred u8: {}", inferred);
}