Tổng Hợp Kiểu Dữ Liệu Trong Rust

Đây là bảng tổng hợp đầy đủ các kiểu dữ liệu trong Rust. Bảng bao gồm từ các kiểu cơ bản như số nguyên, số thực cho đến các kiểu phức tạp như collections và smart pointers.

1. Kiểu Số Nguyên (Integer Types)

Kiểu	Size	Range	Giải thích	Ví dụ
i8	8 bit	-128 đến 127	Số nguyên có dấu 8-bit	let x: i8 = -42;
i16	16 bit	-32,768 đến 32,767	Số nguyên có dấu 16-bit	let x: i16 = -1000;
i32	32 bit	-2,147,483,648 đến 2,147,483,647	Số nguyên có dấu 32-bit (mặc định)	let x = 42; // i32
i64	64 bit	-9,223,372,036,854,775,808 đến 9,223,372,036,854,775,807	Số nguyên có dấu 64-bit	let x: i64 = 1_000_000;
i128	128 bit	-(2^127) đến 2^127-1	Số nguyên có dấu 128-bit	let x: i128 = 123456789012345678901234567890;
isize	Phụ thuộc kiến trúc	32-bit hoặc 64-bit tùy hệ thống	Số nguyên có dấu theo kiến trúc CPU	let x: isize = -100;
u8	8 bit	0 đến 255	Số nguyên không dấu 8-bit	let x: u8 = 255;
u16	16 bit	0 đến 65,535	Số nguyên không dấu 16-bit	let x: u16 = 65000;
u32	32 bit	0 đến 4,294,967,295	Số nguyên không dấu 32-bit	let x: u32 = 3_000_000_000;
u64	64 bit	0 đến 18,446,744,073,709,551,615	Số nguyên không dấu 64-bit	let x: u64 = 18_000_000_000_000_000_000;
u128	128 bit	0 đến 2^128-1	Số nguyên không dấu 128-bit	let x: u128 = 340282366920938463463374607431768211455;
usize	Phụ thuộc kiến trúc	32-bit hoặc 64-bit tùy hệ thống	Số nguyên không dấu theo kiến trúc CPU	let x: usize = 100;

2. Kiểu Số Thực (Floating-Point Types)

Kiểu	Size	Range	Giải thích	Ví dụ
f32	32 bit	±1.18 × 10^-38 đến ±3.40 × 10^38	Số thực độ chính xác đơn (IEEE 754)	let x: f32 = 3.14;
f64	64 bit	±2.23 × 10^-308 đến ±1.80 × 10^308	Số thực độ chính xác kép (mặc định)	let x = 3.141592653589793; // f64

3. Kiểu Boolean

Kiểu	Size	Range	Giải thích	Ví dụ
bool	1 byte	true hoặc false	Kiểu logic chỉ có 2 giá trị	let is_active: bool = true;

4. Kiểu Ký Tự (Character Type)

Kiểu	Size	Range	Giải thích	Ví dụ
char	4 bytes	Unicode scalar values (U+0000 đến U+D7FF và U+E000 đến U+10FFFF)	Ký tự Unicode, không phải ASCII	let c: char = ‘🦀’; let c2: char = ‘A’;

5. Kiểu Tuple

Kiểu	Size	Range	Giải thích	Ví dụ
()	0 bytes	Chỉ có 1 giá trị: ()	Unit type – tuple rỗng	let unit: () = ();
(T1, T2, …)	Tổng size của các thành phần	Tùy thuộc vào các kiểu thành phần	Nhóm các giá trị có kiểu khác nhau	let tup: (i32, f64, char) = (42, 6.4, ‘A’);

6. Kiểu Array

Kiểu	Size	Range	Giải thích	Ví dụ
[T; N]	size_of::<T>() * N	N phần tử cùng kiểu T	Mảng có kích thước cố định tại compile time	let arr: [i32; 5] = [1, 2, 3, 4, 5];

7. Kiểu Slice

Kiểu	Size	Range	Giải thích	Ví dụ
&[T]	2 * usize (con trỏ + độ dài)	Tham chiếu đến một phần của array/vector	View chỉ đọc vào dữ liệu liên tiếp	let slice: &[i32] = &[1, 2, 3];
&mut [T]	2 * usize	Tham chiếu có thể thay đổi	View có thể thay đổi vào dữ liệu	let slice: &mut [i32] = &mut [1, 2, 3];

8. Kiểu String

Kiểu	Size	Range	Giải thích	Ví dụ
&str	2 * usize	String slice, UTF-8	Tham chiếu đến chuỗi, thường là string literals	let s: &str = “Hello, world!”;
String	3 * usize	Chuỗi có thể thay đổi kích thước	Chuỗi sở hữu dữ liệu, có thể thay đổi	let s: String = String::from(“Hello”);

9. Kiểu Con Trỏ (Pointer Types)

Kiểu	Size	Range	Giải thích	Ví dụ
&T	usize	Địa chỉ bộ nhớ	Tham chiếu bất biến	let x = 5; let y = &x;
&mut T	usize	Địa chỉ bộ nhớ	Tham chiếu có thể thay đổi	let mut x = 5; let y = &mut x;
Box<T>	usize	Địa chỉ heap	Con trỏ thông minh đến heap	let b = Box::new(5);
*const T	usize	Địa chỉ bộ nhớ	Con trỏ thô không thể thay đổi	let ptr: *const i32 = &5;
*mut T	usize	Địa chỉ bộ nhớ	Con trỏ thô có thể thay đổi	let mut x = 5; let ptr: *mut i32 = &mut x;

10. Kiểu Function

Kiểu	Size	Range	Giải thích	Ví dụ
fn(T1, T2, …) -> R	usize	Con trỏ hàm	Con trỏ đến function	`let f: fn(i32) -> i32 =

11. Kiểu Never

Kiểu	Size	Range	Giải thích	Ví dụ
!	0 (không có giá trị)	Không có giá trị nào	Kiểu không bao giờ trả về giá trị	fn panic_fn() -> ! { panic!(“This never returns”); }

12. Kiểu Option và Result

Kiểu	Size	Range	Giải thích	Ví dụ
Option<T>	size_of::<T>() + padding	Some(T) hoặc None	Biểu diễn giá trị có thể không tồn tại	let x: Option<i32> = Some(42);
Result<T, E>	max(size_of::<T>(), size_of::<E>()) + tag	Ok(T) hoặc Err(E)	Biểu diễn kết quả có thể thành công hoặc lỗi	let result: Result<i32, String> = Ok(42);

13. Kiểu Vector và Collections

Kiểu	Size	Range	Giải thích	Ví dụ
Vec<T>	3 * usize	Mảng động	Mảng có thể thay đổi kích thước	let v: Vec<i32> = vec![1, 2, 3];
HashMap<K, V>	Phức tạp	Key-value pairs	Bảng băm	use std::collections::HashMap; let mut map = HashMap::new();
HashSet<T>	Phức tạp	Unique values	Tập hợp không trùng lặp	use std::collections::HashSet; let set: HashSet<i32> = HashSet::new();

14. Một số lưu ý quan trọng:

• Kiểu mặc định: i32 cho số nguyên, f64 cho số thực
• Overflow: Debug mode sẽ panic, release mode sẽ wrap around
• Type inference: Rust có thể tự suy luận kiểu trong nhiều trường hợp
• Zero-cost abstractions: Nhiều kiểu phức tạp có cùng performance với kiểu cơ bản sau khi compile
• Memory safety: Rust đảm bảo memory safety mà không cần garbage collector

Print

---