---
title: "Lập trình Rust Cơ Bản: Khám Phá Trait – Tái Sử Dụng Hành Vi và Đa Hình"
description: "Lập trình Rust Cơ Bản: Khám Phá Trait - Tái Sử Dụng Hành Vi và Đa Hình"
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-kham-pha-trait-tai-su-dung-hanh-vi-va-da-hinh.png"
featured: false
readingTime: "6 min read"
---

*Đối tượng: lập trình viên mới bắt đầu với Rust, những người muốn hiểu cách trait giúp tái sử dụng hành vi và thực hiện đa hình trong Rust.*

## Giới thiệu

Trong **lập trình Rust cơ bản**, `trait` là một trong những khái niệm quan trọng nhất. Nếu bạn đã quen với *interface* trong Java hay *protocol* trong Swift, thì **trait** của Rust sẽ cảm thấy khá thân thuộc – nhưng cũng có những điểm mạnh độc đáo.

Bài viết này sẽ:

- Giải thích **trait là gì** và tại sao nó quan trọng trong Rust.
- Hướng dẫn cách **tái sử dụng hành vi** bằng trait.
- Minh họa cách thực hiện **đa hình** (polymorphism) trong Rust.
- Đưa ra các ví dụ thực tế và mẹo tối ưu SEO cho nội dung Rust.

## Trait là gì? – Khái niệm nền tảng

Trong Rust, một `trait` định nghĩa một tập hợp các phương thức (methods) mà một kiểu dữ liệu (type) có thể **implement**. Nó giống như một hợp đồng: nếu một struct hoặc enum “implement” một trait, nó phải cung cấp các phương thức được khai báo trong trait.

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

```
trait GiaoDien {
    fn ten(&self) -> &str;
    fn mo_ta(&self) -> String {
        format!("Đối tượng: {}", self.ten())
    }
}
```

Ở ví dụ trên, `GiaoDien` là một trait với một phương thức bắt buộc `ten` và một phương thức mặc định `mo_ta`.

## Tái Sử Dụng Hành Vi với Trait

Trait cho phép bạn viết **hành vi chung** một lần và áp dụng cho nhiều kiểu dữ liệu. Điều này giảm thiểu lặp lại mã và tăng tính bảo trì.

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

Giả sử chúng ta có các struct `XeMay` và `XeHoi` đều có phương thức `di_chuyen`. Thay vì viết lại, chúng ta tạo một trait `DiChuyen`:

```
trait DiChuyen {
    fn di_chuyen(&self);
}

struct XeMay {
    ten: String,
}

struct XeHoi {
    ten: String,
    so_ghe: u8,
}

impl DiChuyen cho XeMay {
    fn di_chuyen(&self) {
        println!("{} đang lái xe máy.", self.ten);
    }
}

impl DiChuyen cho XeHoi {
    fn di_chuyen(&self) {
        println!("{} đang lái xe hơi với {} ghế.", self.ten, self.so_ghe);
    }
}
```

Bây giờ, bất kỳ hàm nào nhận một tham chiếu đến `dyn DiChuyen` đều có thể làm việc với cả `XeMay` và `XeHoi` – đây chính là **đa hình** trong Rust.

## Đa Hình (Polymorphism) trong Rust

Rust không có kế thừa lớp truyền thống, nhưng **đa hình** được thực hiện thông qua trait objects (`dyn Trait`) hoặc generic constraints. Hai cách phổ biến:

- **Trait Object**: Dùng `Box<dyn Trait>` hoặc `&dyn Trait` để lưu trữ bất kỳ kiểu nào implement trait.
- **Generics + Trait Bound**: Hàm generic nhận bất kỳ kiểu nào thỏa mãn trait bound.

### Trait Object Example

```
fn chay_di_chuyen(thiet_bi: &dyn DiChuyen) {
    thiet_bi.di_chuyen();
}

fn main() {
    let xe_may = XeMay { ten: "Honda".into() };
    let xe_hoi = XeHoi { ten: "Toyota".into(), so_ghe: 5 };

    chay_di_chuyen(&xe_may);
    chay_di_chuyen(&xe_hoi);
}
```

### Generic Example

```
fn chay_di_chuyen_generic(thiet_bi: &T) {
    thiet_bi.di_chuyen();
}
```

## Mẹo SEO cho Bài Viết Rust

Để nội dung **lập trình Rust cơ bản** của bạn đạt thứ hạng cao trên Google, hãy chú ý:

- Đặt từ khóa **“trait Rust”**, **“tái sử dụng hành vi”** và **“đa hình Rust”** trong tiêu đề, mô tả meta và ít nhất 3‑4 lần trong nội dung.
- Sử dụng thẻ `<h2>`, `<h3>` để chia đoạn và chèn từ khóa phụ như “lập trình Rust cơ bản”.
- Thêm liên kết nội bộ hoặc ngoại bộ tới tài liệu chính thức Rust ([Rust Book – Traits](https://doc.rust-lang.org/book/ch10-02-traits.html)).
- Chèn đoạn code ngắn trong `<pre><code>` để tăng thời gian người dùng ở lại trang.

## Kết luận

Trait là “cốt lõi” của **lập trình Rust cơ bản** khi nói đến *tái sử dụng hành vi* và *đa hình*. Bằng cách định nghĩa các hành vi chung trong trait và implement chúng cho các struct, bạn có thể viết code ngắn gọn, an toàn và dễ bảo trì.

Hãy thử tạo một trait riêng cho dự án của bạn, thực hiện nó trên nhiều kiểu dữ liệu, và cảm nhận sức mạnh của Rust trong việc xây dựng phần mềm mạnh mẽ.

Đọc thêm về [Rust Programming Language](https://doc.rust-lang.org/book/) để nâng cao kỹ năng và khám phá các tính năng nâng cao khác như `async/await`, `ownership`, và `lifetimes`.