เรียน Rust ผ่าน Rustlings วันที่ 3

Rust Mar 29, 2023

สวัสดีครับ ต่อจากบล็อกที่แล้ว กับการเรียน Rust ผ่าน Rustlings ตอนที่ 3 นะครับ

เรียน​ Rust ผ่าน Rustlings ตอนที่ 2
สวัสดีครับ วันนี้เป็นบันทึกการเรียน Rust ผ่านการฝึกด้วย Rustlings วันที่ 2 นะครับ วันนี้นั่งฝึกทบทวน (รอบที่ เท่าไหร่แล้วจำไม่ได้ ไม่ได้ใช้จริงๆจังๆ ก็ลืมหมด) วิธีการเรียนของผมคือ 1. แก้โจทย์

Exercises ของ Rustlings วันนี้คือ


สรุปจาก Rustlings แต่ละ Exercises และการอ่านเพิ่มเติมจาก Rust Book

Primitive Types

หลักๆ แบ่งออกเป็น 2 แบบคือ

  • Scalar Type คือพวก integers, float, number, boolean และก็ char
  • Compound Type คือ Tuple กับ Array

Scalar Type

Integer จะมี signed และ unsigned เช่น i32 = signed 32 bit , u32 = unsigned 32-bit

let d = 98_222 // decimal
let h = 0xff // hex
let o = 0o77 // octal
let b =	0b1111_0000 // binary
let bb = b'A' // bytes

Floating-point จะมี f32 และ f64

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

Boolean type ( bool) มีค่าได้ true กับ false

fn main() {
    let t = true;

    let f: bool = false; // with explicit type annotation
}

Character type ใช้ single quote ถ้า String จะใช้ double quote

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // with explicit type annotation
    let heart_eyed_cat = '😻';
}

Compound Type

Tuple คือกลุ่มข้อมูล คล้ายๆ array แต่ว่าในกลุ่มเป็นคนละ type กันได้

  • fixed length - เมื่อ declare แล้ว ไม่สามารถ เพิ่ม ลดได้
fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}
  • destructure tuple ทำคล้ายๆ JavaScript (เปลี่ยนจาก {} เป็น ()
fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {y}");
}
  • เข้าถึง element ของ tuple ผ่าน index ได้ด้วยการใช้ . (อย่าง JS ใช้ [index]
  • index แรก คือ 0
  • tuple ที่ไม่มีค่า เราเรียกว่า unit หรือก็คือ () นั่นเอง (function ที่ไม่ reutrn อะไร)
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;
}

Array คล้ายๆกับภาษาอื่นๆ เป็นกลุ่มข้อมูล ในภาษา Rust ข้อมูลใน array ต้องเป็น type เดียวกัน และก็ fixed length

fn main() {
    let a = [1, 2, 3, 4, 5];
}
  • Array มีประโยชน์ ถ้าเรารู้จำนวน element (ไม่งั้นไปใช้ Vector)
  • ตัวอย่างการกำหนด array ขนาด 5 และมี type เป็น i32
let a: [i32; 5] = [1, 2, 3, 4, 5];

// initial array ด้วย value เดียวกัน จำนวน 5 ครั้ง
let a = [3; 5];
  • เข้าถึง element ของ array ด้วย index (start index = 0)
fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

Vectors

Vector เหมือนกับ Array เพียงแต่ว่า มันสามารถ เพิ่ม ลด ขนาดได้

  • สร้าง empty vector (ต้องใส่ type ให้ด้วย)
 let v: Vec<i32> = Vec::new();
  • Vector รองรับ Generic Type ด้วย
  • สามารถ initial vector ด้วย macro vec! ตัว Rust จะทำการ infer ตามค่าให้
 let v = vec![1, 2, 3];
 
 // Rust รู้ว่า v = Vec<i32>
  • ใช้ push() เพื่อเพิ่มค่าใน vector (ต้องกำหนด mut ให้กับ vector เพราะเรากำลังจะแก้ไขข้อมูล)
let mut v = Vec::new();

v.push(5);
v.push(6);
  • เข้าถึง element ของ Vector ได้ 2 วิธีคือ index (start index 0) หรือ get() method
let v = vec![1, 2, 3, 4, 5];

let third: &i32 = &v[2];
println!("The third element is {third}");

let third: Option<&i32> = v.get(2);
match third {
    Some(third) => println!("The third element is {third}"),
    None => println!("There is no third element."),
}
  • แบบ index เราใช้ &v หมายถึง reference ถึงตัวแปร v
  • แบบ v.get(2) จะ return ค่าเป็น Option<&i32>
  • การ iterate element ใน vector
let v = vec![100, 32, 57];
for i in &v {
    println!("{i}");
}
  • iterate แล้วเปลี่ยนค่า (กำหนด mut)
let mut v = vec![100, 32, 57];
for i in &mut v {
    *i += 50;
}
  • หรือใช้ iter_mut
let x = &mut [1, 2, 4];
for elem in x.iter_mut() {
    *elem += 2;
}
assert_eq!(x, &[3, 4, 6]);
  • * คือ dereference operator

จบวันที่ 3 🎉

Tags

Chai Phonbopit

เป็น Web Dev ทำงานมา 10 ปีหน่อยๆ ด้วยภาษา JavaScript, Node.js, React, Vue และปัจจุบันกำลังสนใจ Web3, Crypto และ Blockchain เขียนบล็อกที่ https://devahoy.com