ลองเขียน Rust แบบงงๆ

สวัสดีครับ หลังจากผมได้ลองศึกษาเกี่ยวกับภาษา Rust มาพักนึง (พักเล็กๆๆ) บอกเลยว่างงจริง 555 ที่ว่ากันว่า Rust มี learning curve ที่สูงนั้นจริงไหม (จริงงงง) เดี๋ยวจะมาเล่ากันแบบงงๆ นะ ครับ

Rust?

สำหรับใครคือยังไม่รู้จัก Rust นะครับ Rust นั้นเป็น ภาษา Programming ภาษาหนึ่งที่เป็น Strongly type language และ Asynchronous language ที่พัฒนาโดยบริษัท Mozilla ขึ้นชื่อเรื่องความปลอดภัย, การทำ Concurrency, การจัดการ memory และที่สำคัญ เร็วว!!!!!

If you’re looking to start writing asynchronous, you’ve come to the right place….. (Rust กล่าวไว้)

Rust นั้นมี Syxtax ที่คล้าย C++ อยู่บ้าง ละก็ยังมี Syxtax ที่ดูแล้วอิหยังวะ อยู่ด้วย 555555 มี learning curve สูงสมชื่อจริงๆ

งานส่วนใหญ่ที่ใช้ Rust ก็จะมีพวก cryptocurrency, blockchain หรืองานที่ต้องการความปลอดภัย (rust ทำ WebAssembly ได้ด้วยนะ)

ที่สำคัญสำหรับ Rust ต้องเป็น snake_case และมี ; นะ

โอเคครับ เพื่อให้เป็นการไม่เสียเวลา มาดู keyword สำคัญกันเลยดีกว่า

Cargo

เจ้า Cargo นี้คือ Package Manager ของ Rust นั้นเอง สามารถ new project, run project, build project, install dependecis ได้ง่ายๆ ด้วยปลายนิ้ว

# new project
cargo new my_project

# run project
cargo run

# build project
cargo build

ส่วนวิธีการเพิ่ม dependency ก็ง่ายแค่แก้ไขไฟล์ Cargo.toml

[dependencies]
tokio = { version = "1", features = ["full"] }

Variable

เนื่องจาก Rust จะเป็นรูปแบบ stronge type ซึ่งหมายความว่าถ้าเรา defind variable มาแล้วจะไม่สามารถ assign ค่าใหม่เข้าไปได้ ซึ้งถ้าต้องการให้ variable นั้นสามารถ reassign ค่าได้ต้อง defind เป็น mutable variable

let num1: i32 = 100;
num1 = 120; // error: Cannot assign twice to immutable variable

let mut num2: i32 = 200;
num2 = 200; // no error

Constant

การประกาศ constant ใน Rust จะต้องเป็น UPPER_CASE เท่านั้นและ จะประกาศไว้นอก fn (คล้ายๆ global var)

const APP_NAME: &str = "Hello Rust";

fn main() {
    println!("{}", APP_NAME);
}

Type

Type ใน Rust นั้นมีอยู่มากมาก ผมขอยกตัวอย่างเฉพาะ type ที่ใช้บ่อยๆ ในชีวิตประจำวันแล้วกัน

String

สำหรับผู้ที่เริ่มต้นศึกษา Rust อาจจะรู้สึกงงๆ กับเจ้า String กับ &str (string literal) ว่าคืออะไร เดี๋ยวผมจะอธิบายๆง่ายให้ฟัง

String เป็น struct หนึ่งใน Rust ซึ่งจะเก็บค่าไว้ใน Heap

let hello = String::from("Hello, world!");

แต่ &str เป็น string เก็บค่าไว้ใน Stack

let hello = "Hello, world!";

สามารถศึกษาเรื่อง Stack กับ Heap ของ Rust เพิ่มเติมได้ที่

The Rust Programming Language

Char

char ใน rust สามารถ defind ได้โดยการใช้ ‘ (single quote)

let char = 'A';

Boolean

boolean ใน rust สามารถ defind ได้โดยการใช้ true, false

let boolean = true;

Number

number ใน rust จะมีเป็น u8, i8, u16, i16, u32, i32, u64, i64, u128, i128, usize, isize, f32, f64 (ตัวเลขคือจำนวน byte)

นอกจากการกำหนด type ไว้ข้างหลังชื่อตัวแปรร let x: i8 = 10
เราสามารถกำหนด type ไว้ข้างหลัง value ได้ด้วย แบบนี้ let x = 10i8
ซึ่งทั้งสองมีความมายเหมือนกัน คือ x = 10 มี type เป็น i8

ซึ่งหากเราประกาศตัวเลขแบบไม่ได้กำหนด type จะมี default อยู่ที่ i32 สำหรับจำนวนเต็ม และ f64 สำหรับทศนิยม (ในกรณีที่เราประกาศ value ที่มี byte มากกว่า default จะได้ error จาก compiler)

เราสามารถใช้ _ คั่นใน value ได้โดยที่ value จะไม่มีการเปลี่ยนแปลงใดๆ (สามารถนำมาใช้แทน , ให้อ่านตัวเลขได้ง่ายมากๆ หรือนำมาใช้กับพวกเลขฐาน 2 ก็ได้)

let x: i8 = 10; // i8
let y = 10i8; // i8
let age = 32; // i32
let sc = -10; // i32
let uage: u32 = 32; // u32
let amount: i64 = 9387592743847; // i64
let value = 10.05; // f64

let one_m = 1_000_000; // i32: 1000000
let ten_m = 10_000_000; // i32: 10000000

let hex = 0x_1234; // i32: Hex
let dec = 0b1110_0110_0111; // i32: Dec

Function

function ใน Rust จะเขียนด้วย fn และ return type ของ function จะต่อจาก ->

(การ return ค่า ตอนจบ function จะใช้บรรทัดสุดท้าย (โดยไม่ต้องใส่ semicolon))

fn sum(a: i32,b: i32) -> i32 {
   return a + b;
}

fn sum(a: i32,b: i32) -> i32 {
   a + b
}

เราสามารถทำเป็น asynchronous ได้โดยการใส่ async ข้างหน้าและ return เป็น Result

async fn foo() -> Result<(), Box<dyn std::error::Error>> {
       return match dosomething() {
        Ok(_) => Ok(()),
        Err(e) => Err(e),
        _ => Ok(()),
    }
}

การทำงานของ rust นั้นจะเริ่มต้นจาก fn main ครับ (เหมือน Go เลย)

ปล. เราสามารถทำให้ fn main กลายเป็น async ได้โดยใช้ tokio

If-Else

ในส่วน if else จะเหมือนๆกับ ภาษาอื่นเลย

let x = true;

if x {
  println!("x is true");
} else {
  println!("x is false");
}

Switch case

ในส่วนของ swich case จะใช้ match แทน

let name = "John";

match name {
    "john" => println!("name is john"),
    "jack" => println!("name is jack"),
     _ => {
        // default
     }
}

Loop

การ loop ใน Rust สามารถทำได้ทั้ง for, while และ loop

// -- for in range --
// `n` will take the values: 1, 2, ..., 100 in each iteration
for n in 1..101 {
        
}

// -- while -- 
let mut n2 = 1;

// Loop while `n` is less than 101
while n2 < 101 {
      n2 += 1;
}

let mut count = 0u32;

println!("Let's count until infinity!");

// Infinite loop
loop {
   count += 1;

   if count == 3 {
        println!("three");

        // Skip the rest of this iteration
        continue;
   }

   println!("{}", count);

   if count == 5 {
       println!("OK, that's enough");

       // Exit this loop
       break;
   }
}

โอเคครับ คงพอหอมปากหอมครับกับ Rust เบื้องต้น (แบบงงๆ 555) กันนะครับ ไว้โอกาสหน้าจะมาอัพเดท การลองเขียน Rust แบบงงๆ ใหม่นะครับ ขอบคุณครับ

Reference

Learn Rust

Rust By Example

The Rust Programming Language

Asynchronous Programming in Rust