ชนิดข้อมูล
ทุกค่าใน Rust มี_ชนิดข้อมูล_ (data type) กำกับอยู่เสมอ ซึ่งบอกให้ Rust ทราบว่าข้อมูลนั้นเป็นข้อมูลชนิดใด เพื่อที่จะได้รู้วิธีจัดการกับข้อมูลนั้นได้อย่างถูกต้อง เราจะมาทำความรู้จักกับกลุ่มชนิดข้อมูลหลัก 2 กลุ่ม ได้แก่ สเกลาร์ (scalar) และคอมพาวด์ (compound)
โปรดจำไว้ว่า Rust เป็นภาษาที่_กำหนดชนิดข้อมูลแบบสแตติก_ (statically typed) ซึ่งหมายความว่าคอมไพเลอร์จำเป็นต้องทราบชนิดข้อมูลของตัวแปรทั้งหมดตั้งแต่ตอนคอมไพล์ โดยทั่วไปแล้ว คอมไพเลอร์สามารถอนุมานชนิดข้อมูลที่เหมาะสมได้เองจากค่าของข้อมูลและบริบทการใช้งาน แต่ในกรณีที่ค่านั้นสามารถตีความได้หลายชนิด เช่น ตอนที่เราแปลง String ไปเป็นตัวเลขด้วย parse ในหัวข้อ “การเปรียบเทียบคำทายกับตัวเลขลับ” ในบทที่ 2 เราจำเป็นต้องระบุชนิดข้อมูลกำกับไว้อย่างชัดแจ้ง ดังนี้:
#![allow(unused)]
fn main() {
let guess: u32 = "42".parse().expect("Not a number!");
}
หากเราไม่ได้ระบุชนิดข้อมูล : u32 ดังเช่นในโค้ดข้างต้น Rust จะแสดงข้อความแจ้งข้อผิดพลาดต่อไปนี้ เพื่อบอกว่าคอมไพเลอร์ต้องการข้อมูลเพิ่มเติมจากเราว่าต้องการใช้ชนิดข้อมูลใดกันแน่:
$ cargo build
Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0284]: type annotations needed
--> src/main.rs:2:9
|
2 | let guess = "42".parse().expect("Not a number!");
| ^^^^^ ----- type must be known at this point
|
= note: cannot satisfy `<_ as FromStr>::Err == _`
help: consider giving `guess` an explicit type
|
2 | let guess: /* Type */ = "42".parse().expect("Not a number!");
| ++++++++++++
For more information about this error, try `rustc --explain E0284`.
error: could not compile `no_type_annotations` (bin "no_type_annotations") due to 1 previous error
คุณจะได้เห็นรูปแบบการระบุชนิดข้อมูลอื่นๆ เพิ่มเติมเมื่อพบกับชนิดข้อมูลชนิดถัดไป
ชนิดสเกลาร์
ชนิดข้อมูลแบบ_สเกลาร์_ (scalar) ใช้แทนค่าเดี่ยวเพียงค่าเดียว โดย Rust มีชนิดข้อมูลสเกลาร์พื้นฐาน 4 ชนิด ได้แก่ จำนวนเต็ม (integer), จำนวนทศนิยม (floating-point number), บูลีน (boolean) และอักขระ (character) ซึ่งคุณอาจคุ้นเคยกับสิ่งเหล่านี้มาจากภาษาโปรแกรมอื่นๆ มาดูกันว่าแต่ละชนิดทำงานอย่างไรใน Rust
ชนิดจำนวนเต็ม
จำนวนเต็ม (integer) คือตัวเลขที่ไม่มีเศษส่วน เราได้ลองใช้ชนิดจำนวนเต็มไปแล้วหนึ่งชนิดในบทที่ 2 นั่นคือ u32 โดยการประกาศชนิดนี้บ่งบอกว่าค่าดังกล่าวเป็นจำนวนเต็มแบบไม่มีเครื่องหมาย (unsigned integer) ที่ใช้พื้นที่จัดเก็บ 32 บิต ส่วนชนิดจำนวนเต็มแบบมีเครื่องหมาย (signed integer) จะขึ้นต้นด้วยตัวอักษร i แทน u ตารางที่ 3-1 แสดงชนิดจำนวนเต็มพื้นฐานทั้งหมดที่มีใน Rust ซึ่งเราสามารถเลือกใช้ชนิดใดก็ได้เหล่านี้ในการประกาศชนิดของค่าจำนวนเต็ม
ตารางที่ 3-1: ชนิดจำนวนเต็มใน Rust
| ความยาว | มีเครื่องหมาย | ไม่มีเครื่องหมาย |
|---|---|---|
| 8 บิต | i8 | u8 |
| 16 บิต | i16 | u16 |
| 32 บิต | i32 | u32 |
| 64 บิต | i64 | u64 |
| 128 บิต | i128 | u128 |
| ขึ้นอยู่กับสถาปัตยกรรม | isize | usize |
แต่ละชนิดมีทั้งแบบมีเครื่องหมายและไม่มีเครื่องหมาย และมีขนาดระบุไว้อย่างชัดเจน การระบุว่า_มีเครื่องหมาย_ (signed) หรือ_ไม่มีเครื่องหมาย_ (unsigned) หมายถึงตัวเลขนั้นสามารถมีค่าติดลบได้หรือไม่ กล่าวคือ ตัวเลขนั้นจำเป็นต้องมีเครื่องหมายบอกความเป็นบวกหรือลบ (signed) หรือเป็นค่าบวกเสมอจึงแสดงได้โดยไม่ต้องมีเครื่องหมาย (unsigned) เปรียบเหมือนการเขียนตัวเลขบนกระดาษ เมื่อเครื่องหมายมีความสำคัญ ตัวเลขจะถูกเขียนพร้อมเครื่องหมายบวกหรือลบ แต่เมื่อมั่นใจได้ว่าเป็นค่าบวกเสมอ ก็สามารถเขียนตัวเลขลอยๆ ได้โดยไม่ต้องใส่เครื่องหมาย ทั้งนี้ ตัวเลขแบบมีเครื่องหมายจะจัดเก็บข้อมูลโดยใช้รูปแบบ two’s complement
ชนิดข้อมูลแบบมีเครื่องหมายแต่ละชนิดสามารถเก็บตัวเลขได้ตั้งแต่ −(2n − 1) ไปจนถึง 2n − 1 − 1 (นับรวมขอบเขตทั้งสองฝั่ง) โดยที่ n คือจำนวนบิตของชนิดข้อมูลนั้นๆ ดังนั้น i8 จึงสามารถเก็บตัวเลขได้ตั้งแต่ −(27) ถึง 27 − 1 ซึ่งเท่ากับ −128 ถึง 127 ส่วนชนิดข้อมูลแบบไม่มีเครื่องหมายสามารถเก็บตัวเลขได้ตั้งแต่ 0 ไปจนถึง 2n − 1 ส่งผลให้ u8 เก็บตัวเลขได้ตั้งแต่ 0 ถึง 28 − 1 ซึ่งเท่ากับ 0 ถึง 255
นอกจากนี้ ชนิด isize และ usize จะมีขนาดขึ้นอยู่กับสถาปัตยกรรมของคอมพิวเตอร์ที่โปรแกรมกำลังทำงานอยู่ โดยจะมีขนาด 64 บิตบนสถาปัตยกรรม 64-bit และมีขนาด 32 บิตบนสถาปัตยกรรม 32-bit
คุณสามารถเขียนลิเทอรัลของจำนวนเต็มได้หลากหลายรูปแบบตามตารางที่ 3-2 โดยลิเทอรัลตัวเลขที่สามารถตีความได้หลายชนิด สามารถใส่คำต่อท้ายชนิดข้อมูลเพื่อระบุชนิดที่ต้องการได้โดยตรง เช่น 57u8 และยังสามารถใช้เครื่องหมายขีดล่าง _ เป็นตัวคั่นเพื่อช่วยให้อ่านตัวเลขได้ง่ายขึ้น เช่น 1_000 ซึ่งมีค่าเท่ากับ 1000 ทุกประการ
ตารางที่ 3-2: ลิเทอรัลจำนวนเต็มใน Rust
| ลิเทอรัลตัวเลข | ตัวอย่าง |
|---|---|
| ทศนิยม | 98_222 |
| เลขฐานสิบหก | 0xff |
| เลขฐานแปด | 0o77 |
| เลขฐานสอง | 0b1111_0000 |
ไบต์ (เฉพาะ u8) | b'A' |
แล้วเราควรเลือกใช้จำนวนเต็มชนิดใดดี? หากคุณไม่แน่ใจ ค่าเริ่มต้นของ Rust ถือเป็นจุดเริ่มต้นที่ดีเสมอ โดยจำนวนเต็มจะมีค่าเริ่มต้นเป็น i32 ส่วนกรณีหลักที่คุณจะได้ใช้งาน isize หรือ usize คือเมื่อต้องการใช้เป็นดัชนี (index) เพื่อเข้าถึงข้อมูลในคอลเลกชัน
การล้นของจำนวนเต็ม
สมมติว่าคุณมีตัวแปรชนิด
u8ซึ่งเก็บค่าได้ระหว่าง 0 ถึง 255 หากคุณพยายามกำหนดค่าที่อยู่นอกช่วงดังกล่าว เช่น 256 จะเกิดสภาวะที่เรียกว่า_การล้นของจำนวนเต็ม_ (integer overflow) ซึ่งจะแสดงพฤติกรรมแตกต่างกันตามโหมดการคอมไพล์: เมื่อคุณคอมไพล์ในโหมดดีบัก Rust จะเพิ่มการตรวจสอบการล้นของจำนวนเต็มเข้าไปด้วย ซึ่งจะทำให้โปรแกรมของคุณ_แพนิก_ (panic) ในขณะรันไทม์หากเกิดกรณีนี้ขึ้น โดย Rust ใช้คำว่า_การแพนิก_ (panicking) เพื่อสื่อถึงสภาวะที่โปรแกรมยุติการทำงานกะทันหันเนื่องจากพบข้อผิดพลาดร้ายแรง เราจะกล่าวถึงการแพนิกอย่างละเอียดในหัวข้อ “ข้อผิดพลาดที่กู้คืนไม่ได้ด้วยpanic!” ในบทที่ 9แต่เมื่อคุณคอมไพล์ในโหมดรีลีสด้วยแฟล็ก
--releaseRust จะ_ไม่_ได้ใส่การตรวจสอบการล้นที่ทำให้เกิดการแพนิกมาให้ หากเกิดการล้นขึ้น Rust จะใช้วิธี_การหมุนวนรอบแบบ two’s complement_ (two’s complement wrapping) อธิบายให้เข้าใจง่ายคือ ค่าที่เกินกว่าขีดจำกัดสูงสุดจะ “วนกลับ” ไปเริ่มต้นที่ค่าต่ำสุดที่ชนิดข้อมูลนั้นเก็บได้ ในกรณีของu8ค่า 256 จะกลายเป็น 0, ค่า 257 จะกลายเป็น 1 และวนไปเรื่อยๆ โปรแกรมจะไม่เกิดการแพนิก แต่ตัวแปรจะมีค่าที่คลาดเคลื่อนไปจากที่คุณคาดหวังอย่างแน่นอน การเขียนโค้ดโดยพึ่งพาพฤติกรรมการหมุนวนของการล้นของตัวเลขจึงถือเป็นข้อผิดพลาดที่ไม่ควรทำเพื่อรับมือกับโอกาสที่จะเกิดการล้นอย่างรัดกุม คุณสามารถเรียกใช้กลุ่มเมธอดที่ไลบรารีมาตรฐานจัดเตรียมไว้สำหรับชนิดข้อมูลตัวเลขพื้นฐานได้ดังนี้:
- หมุนวนค่าในทุกโหมดการคอมไพล์ด้วยกลุ่มเมธอด
wrapping_*เช่นwrapping_add- ส่งคืนค่า
Noneหากเกิดการล้นด้วยกลุ่มเมธอดchecked_*- ส่งคืนค่าผลลัพธ์พร้อมค่าบูลีนที่ระบุว่าเกิดการล้นหรือไม่ด้วยกลุ่มเมธอด
overflowing_*- ตรึงค่าไว้ที่ขีดจำกัดต่ำสุดหรือสูงสุดด้วยกลุ่มเมธอด
saturating_*
ชนิดจำนวนทศนิยม
Rust มีชนิดข้อมูลพื้นฐาน 2 ชนิดสำหรับ_จำนวนทศนิยม_ (floating-point numbers) นั่นคือ f32 และ f64 ซึ่งมีขนาด 32 บิตและ 64 บิตตามลำดับ โดยชนิดเริ่มต้นของจำนวนทศนิยมคือ f64 เนื่องจากบนหน่วยประมวลผล (CPU) ยุคใหม่ f64 ทำงานได้รวดเร็วเทียบเท่ากับ f32 แต่ให้ความละเอียดแม่นยำของตัวเลขที่สูงกว่า ทั้งนี้ ชนิดจำนวนทศนิยมทั้งหมดใน Rust จะเป็นแบบมีเครื่องหมายเสมอ
ตัวอย่างการใช้งานจำนวนทศนิยม:
ชื่อไฟล์: src/main.rs
fn main() {
let x = 2.0; // f64
let y: f32 = 3.0; // f32
}
จำนวนทศนิยมใน Rust จัดเก็บตามมาตรฐานสากล IEEE-754
การดำเนินการทางคณิตศาสตร์
Rust รองรับการคำนวณทางคณิตศาสตร์พื้นฐานทั่วไปสำหรับชนิดตัวเลขทั้งหมด ได้แก่ การบวก การลบ การคูณ การหาร และการหารเอาเศษ (modulo) โดยการหารจำนวนเต็มจะปัดเศษทิ้งเข้าหาศูนย์ไปยังจำนวนเต็มที่ใกล้ที่สุด โค้ดต่อไปนี้แสดงการใช้งานตัวดำเนินการทางคณิตศาสตร์แต่ละแบบในคำสั่ง let:
ชื่อไฟล์: src/main.rs
fn main() {
// addition
let sum = 5 + 10;
// subtraction
let difference = 95.5 - 4.3;
// multiplication
let product = 4 * 30;
// division
let quotient = 56.7 / 32.2;
let truncated = -5 / 3; // Results in -1
// remainder
let remainder = 43 % 5;
}
แต่ละนิพจน์ในคำสั่งเหล่านี้จะคำนวณผ่านตัวดำเนินการทางคณิตศาสตร์และประเมินค่าออกมาเป็นค่าเดี่ยว แล้วจึงผูกค่านั้นเข้ากับตัวแปร สามารถดูรายการตัวดำเนินการทั้งหมดที่ Rust รองรับได้จากภาคผนวก B
ชนิดบูลีน
เช่นเดียวกับภาษาโปรแกรมส่วนใหญ่ ชนิดข้อมูลบูลีน (boolean) ใน Rust มีค่าที่เป็นไปได้ 2 ค่า คือ true และ false โดยใช้พื้นที่จัดเก็บขนาด 1 ไบต์ และใช้คำว่า bool ในการระบุชนิดข้อมูล ตัวอย่างเช่น:
ชื่อไฟล์: src/main.rs
fn main() {
let t = true;
let f: bool = false; // with explicit type annotation
}
ประโยชน์หลักของการใช้ค่าบูลีนคือการนำไปใช้ตรวจสอบเงื่อนไข (conditions) เช่นในนิพจน์ if ซึ่งเราจะได้เรียนรู้การทำงานของนิพจน์ if ใน Rust ในหัวข้อ “การควบคุมโฟลว์”
ชนิดอักขระ
ชนิดข้อมูล char ของ Rust เป็นชนิดตัวอักษรพื้นฐานที่สุดของภาษา ตัวอย่างการประกาศค่า char:
ชื่อไฟล์: src/main.rs
fn main() {
let c = 'z';
let z: char = 'ℤ'; // with explicit type annotation
let heart_eyed_cat = '😻';
}
สังเกตว่าเราจะเขียนลิเทอรัลของ char ให้อยู่ภายในเครื่องหมายอัญประกาศเดี่ยว (single quote) ต่างจากสตริงลิเทอรัล (string literal) ที่ต้องใช้เครื่องหมายอัญประกาศคู่ (double quote) โดยชนิด char ของ Rust มีขนาด 4 ไบต์ และเป็นตัวแทนของค่าสเกลาร์ยูนิโค้ด (Unicode scalar value) ซึ่งหมายความว่ามันสามารถเก็บอักขระได้หลากหลายมากกว่าแค่รหัส ASCII ทั่วไป ไม่ว่าจะเป็นอักษรที่มีเครื่องหมายกำกับเสียง ตัวอักษรภาษาจีน ญี่ปุ่น เกาหลี สัญลักษณ์อีโมจิ ตลอดจนอักขระความกว้างศูนย์ ล้วนเป็นค่า char ที่ถูกต้องใน Rust ทั้งสิ้น โดยค่า Unicode scalar value มีช่วงตั้งแต่ U+0000 ถึง U+D7FF และ U+E000 ถึง U+10FFFF ครอบคลุมทั้งสองฝั่ง อย่างไรก็ตาม คำว่า “อักขระ” ในความรู้สึกทั่วไปของมนุษย์อาจไม่ได้ตรงกับนิยามของ Unicode หรือสิ่งที่ char เป็นใน Rust เสมอไป เราจะเจาะลึกประเด็นนี้กันในหัวข้อ “เก็บข้อความที่เข้ารหัส UTF-8 ด้วยสตริง” ในบทที่ 8
ชนิดคอมพาวด์
ชนิดข้อมูลแบบ_คอมพาวด์_ (compound) สามารถรวบรวมหลายๆ ค่าไว้ด้วยกันภายในชนิดข้อมูลเดียว โดย Rust มีชนิดข้อมูลคอมพาวด์พื้นฐาน 2 ชนิด ได้แก่ ทูเพิล (tuple) และอาร์เรย์ (array)
ชนิดทูเพิล
ทูเพิล (tuple) เป็นวิธีทั่วไปในการรวมกลุ่มข้อมูลหลายค่าที่มีชนิดข้อมูลแตกต่างกันเข้าไว้ด้วยกันเป็นหนึ่งเดียว ทูเพิลมีความยาวคงที่ เมื่อประกาศสร้างขึ้นมาแล้ว จะไม่สามารถเพิ่มหรือลดขนาดได้อีก
เราสร้างทูเพิลได้โดยเขียนรายการค่าที่คั่นด้วยเครื่องหมายจุลภาคไว้ภายในวงเล็บ โดยแต่ละตำแหน่งในทูเพิลจะมีชนิดข้อมูลของตนเอง และไม่จำเป็นต้องมีชนิดข้อมูลเหมือนกัน เราได้เพิ่มการระบุชนิดข้อมูลแบบเจาะจงไว้ในตัวอย่างนี้:
ชื่อไฟล์: src/main.rs
fn main() {
let tup: (i32, f64, u8) = (500, 6.4, 1);
}
ตัวแปร tup จะผูกเข้ากับทูเพิลทั้งก้อน เนื่องจากทูเพิลถือเป็นหน่วยข้อมูลคอมพาวด์ชิ้นเดียว หากต้องการดึงค่าแต่ละตัวออกมาใช้งาน เราสามารถใช้การจับคู่รูปแบบ (pattern matching) เพื่อแยกโครงสร้างข้อมูลของทูเพิลออกมาได้ ดังนี้:
ชื่อไฟล์: src/main.rs
fn main() {
let tup = (500, 6.4, 1);
let (x, y, z) = tup;
println!("The value of y is: {y}");
}
โปรแกรมนี้เริ่มต้นด้วยการสร้างทูเพิลแล้วผูกไว้กับตัวแปร tup จากนั้นใช้รูปแบบร่วมกับคำสั่ง let เพื่อแยกค่าใน tup ออกเป็นตัวแปรย่อย 3 ตัว ได้แก่ x, y และ z กระบวนการนี้เรียกว่า_การแยกโครงสร้างข้อมูล_ (destructuring) เพราะเป็นการกระจายทูเพิลเดี่ยวออกเป็นส่วนย่อยๆ และสุดท้าย โปรแกรมจะพิมพ์ค่าของ y ออกมา ซึ่งก็คือ 6.4
นอกจากนี้ เรายังสามารถเข้าถึงค่าในทูเพิลได้โดยตรงผ่านเครื่องหมายจุด (.) แล้วตามด้วยดัชนีของตำแหน่งที่ต้องการเข้าถึง เช่น:
ชื่อไฟล์: src/main.rs
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;
}
โปรแกรมนี้สร้างทูเพิล x แล้วเข้าถึงค่าในแต่ละตำแหน่งตามลำดับดัชนี และเช่นเดียวกับภาษาโปรแกรมส่วนใหญ่ ดัชนีตัวแรกของทูเพิลจะเริ่มต้นที่ 0 เสมอ
ทูเพิลที่ไม่มีค่าใดๆ บรรจุอยู่เลยจะมีชื่อเรียกเฉพาะว่า unit โดยทั้งตัวค่าและชนิดข้อมูลจะเขียนแทนด้วยวงเล็บว่างเปล่า () ซึ่งทำหน้าที่แทนค่าว่างหรือชนิดที่ส่งค่ากลับแบบว่าง (empty return type) ทั้งนี้ นิพจน์ใดๆ ใน Rust จะส่งค่า unit กลับมาโดยปริยาย หากนิพจน์นั้นไม่ได้ส่งค่าอื่นใดกลับมา
ชนิดอาร์เรย์
อีกหนึ่งวิธีในการจัดเก็บคอลเลกชันของหลายค่าคือการใช้_อาร์เรย์_ (array) โดยสิ่งที่ทำให้อาร์เรย์ต่างจากทูเพิลคือ ทุกองค์ประกอบในอาร์เรย์จะต้องเป็นชนิดข้อมูลเดียวกันทั้งหมด และต่างจากอาร์เรย์ในบางภาษาตรงที่ อาร์เรย์ใน Rust จะมีความยาวคงที่เสมอ
เราสร้างอาร์เรย์โดยเขียนรายการค่าที่คั่นด้วยเครื่องหมายจุลภาคไว้ภายในวงเล็บเหลี่ยม (square brackets):
ชื่อไฟล์: src/main.rs
fn main() {
let a = [1, 2, 3, 4, 5];
}
อาร์เรย์มีประโยชน์เมื่อคุณต้องการจัดเก็บข้อมูลไว้บนหน่วยความจำสแตก (stack) เช่นเดียวกับชนิดข้อมูลอื่นๆ ที่เราได้เห็นมา แทนที่จะเป็นหน่วยความจำฮีป (heap) (เราจะพูดถึงสแตกและฮีปเพิ่มเติมในบทที่ 4) หรือเมื่อต้องการรับประกันว่าจำนวนข้อมูลจะมีขนาดคงที่แน่นอนเสมอ อย่างไรก็ดี อาร์เรย์จะมีความยืดหยุ่นน้อยกว่าชนิดเวกเตอร์ (vector) ซึ่งเป็นคอลเลกชันอีกชนิดหนึ่งที่ไลบรารีมาตรฐานจัดเตรียมไว้ให้ โดยเวกเตอร์จะ_สามารถ_ปรับเพิ่มลดขนาดได้อย่างอิสระเนื่องจากข้อมูลถูกจัดสรรไว้บนฮีป หากคุณไม่แน่ใจว่าจะเลือกใช้อาร์เรย์หรือเวกเตอร์ดี โดยส่วนใหญ่แล้วเวกเตอร์มักเป็นตัวเลือกที่ตอบโจทย์ได้มากกว่า ซึ่งเราจะได้เรียนรู้เรื่องเวกเตอร์อย่างละเอียดในบทที่ 8
อย่างไรก็ตาม อาร์เรย์จะมีประโยชน์อย่างยิ่งเมื่อคุณทราบจำนวนองค์ประกอบที่แน่นอนและไม่มีความจำเป็นต้องเปลี่ยนแปลง เช่น หากต้องการเก็บรายชื่อเดือนทั้ง 12 เดือนในโปรแกรม การเลือกใช้อาร์เรย์จะเหมาะสมกว่าเวกเตอร์ เพราะทราบขนาดที่แน่นอนว่าจะต้องมี 12 องค์ประกอบเสมอ:
#![allow(unused)]
fn main() {
let months = ["January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"];
}
คุณสามารถระบุชนิดข้อมูลของอาร์เรย์ได้โดยใช้วงเล็บเหลี่ยมที่ระบุชนิดขององค์ประกอบ คั่นด้วยเครื่องหมายเซมิโคลอน แล้วตามด้วยจำนวนองค์ประกอบในอาร์เรย์ ดังนี้:
#![allow(unused)]
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
}
ในที่นี้ i32 คือชนิดข้อมูลของแต่ละองค์ประกอบ และตัวเลข 5 หลังเซมิโคลอนบ่งบอกว่าอาร์เรย์นี้มีขนาด 5 องค์ประกอบ
นอกจากนี้ คุณยังสามารถกำหนดค่าเริ่มต้นให้อาร์เรย์มีค่าซ้ำกันในทุกองค์ประกอบได้ง่ายๆ โดยระบุค่าเริ่มต้น คั่นด้วยเซมิโคลอน แล้วตามด้วยความยาวของอาร์เรย์ภายในวงเล็บเหลี่ยม ดังนี้:
#![allow(unused)]
fn main() {
let a = [3; 5];
}
อาร์เรย์ชื่อ a จะมี 5 องค์ประกอบ โดยทุกตัวมีค่าเริ่มต้นเป็น 3 ซึ่งเทียบเท่ากับการเขียน let a = [3, 3, 3, 3, 3]; แต่มีความกระชับกว่ามาก
การเข้าถึงองค์ประกอบของอาร์เรย์
อาร์เรย์คือบล็อกหน่วยความจำก้อนเดียวที่มีขนาดคงที่และทราบขนาดล่วงหน้าอย่างแน่นอน ซึ่งสามารถจัดสรรไว้บนสแตกได้อย่างมีประสิทธิภาพ คุณสามารถเข้าถึงข้อมูลในแต่ละองค์ประกอบของอาร์เรย์ได้ผ่านการระบุดัชนี ดังนี้:
ชื่อไฟล์: src/main.rs
fn main() {
let a = [1, 2, 3, 4, 5];
let first = a[0];
let second = a[1];
}
ในตัวอย่างนี้ ตัวแปร first จะได้ค่า 1 เนื่องจากเป็นค่าที่อยู่ที่ดัชนี [0] ของอาร์เรย์ และตัวแปร second จะได้ค่า 2 จากดัชนี [1]
การเข้าถึงองค์ประกอบของอาร์เรย์ที่ไม่ถูกต้อง
มาดูกันว่าจะเกิดอะไรขึ้นหากคุณพยายามเข้าถึงองค์ประกอบในตำแหน่งที่เกินขอบเขตความยาวของอาร์เรย์ สมมติว่าคุณรันโปรแกรมนี้ ซึ่งคล้ายกับเกมทายตัวเลขในบทที่ 2 เพื่อรับค่าดัชนีของอาร์เรย์มาจากผู้ใช้:
ชื่อไฟล์: src/main.rs
use std::io;
fn main() {
let a = [1, 2, 3, 4, 5];
println!("Please enter an array index.");
let mut index = String::new();
io::stdin()
.read_line(&mut index)
.expect("Failed to read line");
let index: usize = index
.trim()
.parse()
.expect("Index entered was not a number");
let element = a[index];
println!("The value of the element at index {index} is: {element}");
}
โค้ดนี้คอมไพล์ผ่านได้อย่างเรียบร้อย หากคุณสั่งรันโปรแกรมด้วย cargo run แล้วป้อนเลข 0, 1, 2, 3 หรือ 4 โปรแกรมจะพิมพ์ค่าที่อยู่ในดัชนีนั้นๆ ออกมา แต่หากคุณป้อนตัวเลขที่เกินความยาวของอาร์เรย์ เช่น 10 คุณจะพบข้อความผลลัพธ์ดังนี้:
thread 'main' panicked at src/main.rs:19:19:
index out of bounds: the len is 5 but the index is 10
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
โปรแกรมเกิดข้อผิดพลาดขึ้นในขณะรันไทม์ ณ จุดที่มีการใช้ดัชนีที่ไม่ถูกต้อง โปรแกรมจึงยุติการทำงานลงทันทีพร้อมแจ้งข้อผิดพลาด และไม่ได้ทำคำสั่ง println! ตัวสุดท้ายต่อ เมื่อคุณพยายามเข้าถึงข้อมูลในอาร์เรย์ผ่านดัชนี Rust จะตรวจสอบเสมอว่าดัชนีที่คุณระบุมีค่าน้อยกว่าความยาวจริงของอาร์เรย์หรือไม่ หากดัชนีมากกว่าหรือเท่ากับความยาวของอาร์เรย์ Rust จะเกิดการแพนิกทันที ซึ่งการตรวจสอบนี้จำเป็นต้องทำขณะรันไทม์ โดยเฉพาะในกรณีนี้เนื่องจากคอมไพเลอร์ไม่สามารถล่วงรู้ล่วงหน้าได้ว่าผู้ใช้จะพิมพ์เลขใดเข้ามา
นี่คือตัวอย่างเชิงประจักษ์ของหลักการความปลอดภัยของหน่วยความจำในภาษา Rust ในภาษาโปรแกรมระดับล่างหลายภาษา การตรวจสอบขอบเขตเช่นนี้มักไม่ถูกกระทำ และเมื่อคุณระบุดัชนีที่ไม่ถูกต้อง โปรแกรมอาจแอบเข้าถึงหน่วยความจำส่วนอื่นที่ไม่ได้อนุญาตได้ Rust ปกป้องคุณจากช่องโหว่ร้ายแรงประเภทนี้โดยสั่งยุติการทำงานทันที แทนที่จะปล่อยให้โค้ดเข้าถึงหน่วยความจำส่วนนั้นแล้วทำงานต่อไปอย่างผิดพลาด ในบทที่ 9 เราจะได้เรียนรู้การจัดการข้อผิดพลาดใน Rust เพิ่มเติม เพื่อเขียนโค้ดที่ทั้งปลอดภัยและไม่หยุดทำงานกะทันหัน