---
title: "Lập trình Rust Cơ Bản: Làm Chủ Error Handling với Result & Option"
description: "Lập trình Rust Cơ Bản: Làm Chủ Error Handling với Result & Option"
date: "2026-09-07"
author:
  name: "Nguyen Pham"
  role: "Xin chào. Mình thích lập trình và công nghệ. Đây là blog mình chia sẻ lại các kiến thức về lập trình, công nghệ."
  avatar: "http://0.gravatar.com/avatar/6fb61398e24046b34e13870dd6c357b9?s=128&d=mm&r=g"
category: "Blog"
tags: ["Blog"]
coverImage: "/blog/covers/lap-trinh-rust-co-ban-lam-chu-error-handling-voi-result-option.png"
featured: false
readingTime: "5 min read"
---

Trong **lập trình Rust** ngày càng phổ biến, việc *error handling* (xử lý lỗi) là một trong những kỹ năng quan trọng nhất mà mọi lập trình viên Rust cần nắm vững. Bài viết này sẽ dẫn bạn qua các khái niệm `Result` và `Option` – hai công cụ mạnh mẽ giúp bạn viết code Rust **an toàn** và **đáng tin cậy**.

## Giới thiệu nhanh về Result và Option

Rust không có `exception` như một số ngôn ngữ khác. Thay vào đó, nó sử dụng các enum `Result` và `Option` để biểu diễn các trạng thái có thể thất bại hoặc không có giá trị. Điều này giúp:

- Phát hiện lỗi tại thời gian biên dịch.
- Buộc người lập trình phải xử lý mọi trường hợp.
- Giữ cho chương trình luôn **an toàn** và **đáng tin cậy**.

## 1. Enum `Option` – Khi giá trị có thể *không tồn tại*

`Option` có hai biến thể: `Some(T)` và `None`. Đây là cách Rust biểu diễn “có hoặc không có” một giá trị.

### Cú pháp cơ bản

```
let maybe_number: Option<i32> = Some(42);
let absent: Option<String> = None;
```

### Ví dụ thực tế

Giả sử bạn đang đọc một phần tử từ một vector:

```
let numbers = vec![10, 20, 30];
let third = numbers.get(2); // trả về Option<i32>
match third {
    Some(value) => println!("Số thứ 3 là {}", value),
    None => println!("Không có phần tử thứ 3"),
}
```

## 2. Enum `Result` – Khi một hành động có thể *thất bại*

`Result` có hai biến thể: `Ok(T)` cho kết quả thành công và `Err(E)` cho lỗi.

### Cú pháp cơ bản

```
use std::fs::File;

fn open_file(path: &str) -> Result<File, std::io::Error> {
    File::open(path)
}
```

### Quản lý lỗi bằng `match`

```
match open_file("data.txt") {
    Ok(file) => println!("Mở file thành công: {:?}", file),
    Err(e) => eprintln!("Không thể mở file: {}", e),
}
```

### Sử dụng `?` operator

Để viết code ngắn gọn hơn, Rust cung cấp `?` operator, tự động trả về `Err` nếu có lỗi.

```
fn read_to_string(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}
```

## 3. Khi nào dùng `Option` và khi nào dùng `Result`?

- **Option**: Khi một giá trị có thể “không tồn tại” nhưng không phải là lỗi nghiêm trọng (ví dụ: tìm kiếm trong danh sách).
- **Result**: Khi một thao tác có thể thất bại và cần cung cấp thông tin chi tiết về lỗi (ví dụ: I/O, parsing, network).

## 4. Các phương pháp “chuyển đổi” giữa Option và Result

Rust cung cấp các hàm tiện ích giúp chuyển đổi dễ dàng:

- `Option::ok_or(err)` – chuyển `Option` thành `Result`.
- `Result::ok()` – lấy `Some` từ `Ok` hoặc `None` nếu là `Err`.
- `Result::err()` – ngược lại.

## 5. Mẹo tối ưu khi làm việc với Result & Option

- **Sử dụng `unwrap_or` và `unwrap_or_else`** để cung cấp giá trị mặc định hoặc logic tính toán khi `None`/`Err`.
- **Kết hợp `map`, `and_then` (hay `flat_map`)** để thực hiện chuỗi thao tác mà không cần viết `match` lặp đi lặp lại.
- **Document lỗi**: Khi trả về `Result`, luôn ghi chú `E` là loại lỗi nào (ví dụ: `std::io::Error`, `ParseIntError`).

## Kết luận

Việc **làm chủ error handling** trong *lập trình Rust* không chỉ giúp bạn viết code sạch hơn mà còn nâng cao độ tin cậy của ứng dụng. Bằng cách hiểu rõ `Option` và `Result`, bạn sẽ giảm thiểu lỗi runtime và tận dụng tối đa sức mạnh của Rust.

Hãy bắt đầu thực hành ngay: tạo một dự án mới, thử các ví dụ trên, và dần dần bạn sẽ cảm nhận được sự khác biệt khi code Rust trở nên “an toàn” hơn bao giờ hết.

Muốn biết thêm? Đọc thêm các bài viết về [Rust basics](https://doc.rust-lang.org/book/ch02-00-guessing-game-tutorial.html), [Error handling in Rust](https://doc.rust-lang.org/book/ch09-00-error-handling.html) và tham gia cộng đồng [Rust Users Forum](https://users.rust-lang.org/) để trao đổi kinh nghiệm.