Tour of Rust - Ch.1 - The Basics

Published on

เขียนวันที่ : April 12, 2022

tour-of-rust/chapter1
Discord

บันทึกการเรียน Tour Of Rust บทเรียนที่ 1 - Tour of Rust - Chapter 1 - The Basics

Chapter 1 - The Basics 🦀

Variables (ตัวแปร)

  • การประกาศตัวแปร ใช้ let
  • โดยปกติ Rust จะ infer type ให้อยู่แล้วส่วนใหญ่ แต่ถ้าให้ดี แนะนำระบุ type ด้วยจะดีกว่า
  • shadowing คือการประกาศตัวแปร และ assign ค่าให้มันหลายๆครั้ง - Shadowing และ Scope and Shadowing
  • naming convention ของการตั้งชื่อตัวแปร คือใช้ snake_case
fn main() {
  // infer type ของ x โดยที่เราไม่ต้องระบุ type ตัว rust จะรู้ว่าคือ integer
  let x = 10;

  // แบบระบุ type
  let x: i32 = 10;
  let y: f32 = 3.14;

  // shadowing
  let x = 10;
  let x = 15;
  let x = 20;

  // ใช้ snake_case ในการตั้งชื่อ
  let this_is_score = 10;
}

Changing variables

  • ตัวแปรใน Rust ปกติจะเป็น immutable by default ครับ คือเปลี่ยนแปลงค่าไม่ได้
  • ถ้าจะให้ตัวแปรเปลี่ยนแปลงค่าได้ (mutable) ก็ใช้ mut นำหน้า
let mut x = 1;
x = 2;

Basic Types

ถ้าเราแบ่งชนิดของ Types ก็จะได้เป็น 2 แบบ Rust Book - Data Types คือ

  • Scalar Types - เป็น single value พวก integer, float, boolean และ char
  • Compound Types - คือพวก multiple values คือ tuple และ arrays,

Types :

  • bool - สำหรับ Boolean มีค่า true หรือ false
  • u8, u16, u32, u64, u128 - unsigned integers สำหรับจำนวนเต็มที่ไม่ต้องการค่าติดลบ
  • i8, i16, i32, i64, i128 - signed integers จำนวนเต็ม (ทั้งปกติและค่าติดลบ)
  • f32, f64 - floating point - จำนวนที่มีจุดทศนิยม
LengthSignedUnsigned
8-biti8u8
16-biti16u16
32-biti32u32
64-biti64u64
28-biti128u128
archisizeusize
  • Tuple - สำหรับข้อมูล collection ที่เรียงลำดับ ใน stack ข้างในมี types ต่างกันได้
  • Array - คล้ายๆ tuple แต่ข้างในเป็น type เดียวกัน และ fixed length ทำให้รู้ขนาดแน่นอน ตั้งแต่ตอน compile
  • slices - เหมือน array แต่ไม่รู้ขนาด ตอน compile
  • str(string slice) - ข้อความที่รู้ขนาดที่แน่นอนตอน runtime
  • พวก integer เราสามารถระบุ type ต่อท้ายตัวเลขได้ เช่น 10u32, 20u32
// tuple
let my_tuple = (1u16, 2u16, 'a', true);

// arrays
let arr: [i32;5] = [1, 2, 3, 4, 5];

// string
let mut hello = String::from("Hello, ");
hello.push_str("World!");

// 10u32
let a: u32 = 10;

Basic Type Conversion

เราไม่สามารถ บวก ลบ คูณ หาร type integer ที่ต่างกันได้ ถึงแม้จะเป็น integer เหมือนกัน เช่น u8 กับ u32 ต้องทำการแปลงก่อน โดยใช้ as

let a = 10u8;
let b = 50u32;
let c = a as u32 + b;

Constrants

Constants หรือค่าคงที่ คือตัวแปรที่เรากำหนดค่าให้มันตั้งแต่แรก และไม่สามารถเปลี่ยนค่าได้ naming convention ใช้ SCREAMING_SNAKE_CASE

Arrays

Array คือ collection แบบ fixed lengh (ระบุจำนวนที่แน่นอน) มีรูปแบบ:

  • [T;N] - T คือ type ของ element และ N คือ จำนวนของ element (length)
let arr = [i32: 3] = [1, 2, 3];
println!("{:?", arr);
println!("{}", arr[1]);

Function

  • function ไม่มี parameter หรือจะมีกี่ตัวก็ได้
  • ชื่อ function นิยมตั้งเป็น snake_case
  • ถ้าต้องการ return expression เราสามารถใช้แบบไม่ต้องมี return และก็เอา semicolon (;) ออกได้
  • ใน function เราเรียก data ที่รับมาว่า parameters และเรียกค่าที่เราส่งไปใน function ว่า arguments.
// ไม่ใช้ semicolon เป็นการ return แบบ expression
fn add(x: 32, y: i32) -> i32 {
    x + y
}

fn main() {
    // 5 และ 10 เราเรียกมันว่า arguemnts.
    // ส่วน x และ y ใน function add เราเรียก parameter.
    let sum = add(5, 10);
}

Multiple Return Values

  • functionเราสามารถ return ค่าหลายค่าได้ โดยการ return เป็น tuple
  • ใช้ index ในการอ้างอิง เข้าถึงตัว element ใน tuple
  • สามารถใช้ destructuring เพื่อแยก element ไปเป็นตัวแปร
// return หลายค่า แบบ tuple
fn swap(x: i32, y: i32) -> (i32, i32) {
    return (y, x);
}

let my_tuples = (1, 2);

// แบบปกติ
let first = my_tuples.0;
let second = my_tuples.1;

// แบบ desstructuring
let (first, second) = (1, 2);

Returing Nothing

  • ปกติ ถ้าไม่ได้ return ค่าใดๆ ใน function มันคือการ return empty tuple (unit)
  • () หมายถึง emtpy tuple
// เหมือนกับ `make_nothing2`
fn make_nothing() -> () {
    return ();
}

// the return type is implied as ()
// return type รู้ว่า มันคือการ return empty tuple
fn make_nothing2() {
}

สรุป บทที่ 1

ไม่มีอะไรมาก ถ้าหากเขียนโปรแกรมภาษาอื่นๆ มาก่อน ก็จะเป็นเรื่องพื้นฐานทั่วๆไปที่ควรรู้อยู่แล้ว แต่อาจต่างกันตรงรายละเอียดบ้างเล็กน้อย Data Types, Variables สิ่งที่ต่างจากหลายๆภาษา ก็มีแค่ Shadowing บางภาษาก็ห้าม declare ซ้ำเลย เรื่องของ mutable และก็ array / tuple และก็ function ที่สามารถ return ได้หลายค่า

แหล่งข้อมูลเพิ่มเติม

Discord