---
title: "1 Byte = 8 Bit: 1 Byte Bằng Bao Nhiêu Bit & Tên Bạn Tốn Bao Nhiêu Byte?"
description: "1 byte bằng bao nhiêu bit? 1 byte = 8 bit. Hướng dẫn trực quan về bit, byte, mã ASCII và UTF-8 thông qua mô hình bãi đỗ xe và cách tính dung lượng ký tự."
pubDate: "2025-12-27"
updatedDate: "2026-09-22"
lang: "vi"
slug: "bits-bytes-characters-encoding"
url: "https://hoangyell.com/vi/bits-bytes-characters-encoding/"
author: "HoangYell"
translation_en: "https://hoangyell.com/bits-bytes-characters-encoding/"
categories: ["Software Craft"]
tags: ["encoding", "unicode"]
heroImage: "https://raw.githubusercontent.com/HoangGeek/store/main/webp/photo-1720166671019-744dcef65d05.webp"
---

<iframe data-testid="embed-iframe" style="border-radius:12px" src="https://open.spotify.com/embed/episode/1mftwJyC5F5v8aVDFEZiU8/video?utm_source=generator" width="100%" height="351" frameborder="0" allowfullscreen="" allow="autoplay; clipboard-write; encrypted-media; fullscreen; picture-in-picture" loading="lazy" title="open.spotify.com embed"></iframe>

## TL;DR

> **Hộp Trả Lời Nhanh (Google Search Featured Snippet):**
> - **1 byte bằng bao nhiêu bit?** Chính xác **1 byte = 8 bit** (`1 Byte = 8 Bits`). Mỗi bit là một chữ số nhị phân (0 hoặc 1), cho phép 1 byte biểu diễn được `2^8 = 256` giá trị khác nhau (từ 0 đến 255).
> - **Tên của bạn tốn bao nhiêu byte?** Trong bảng mã ASCII / UTF-8 tiêu chuẩn, mỗi chữ cái tiếng Anh không dấu tốn đúng **1 byte** (8 bit). Ví dụ, tên "Hoang" (5 chữ cái) tốn đúng 5 byte (40 bit). Các ký tự có dấu tiếng Việt (như "à", "ế") tốn 2 đến 3 byte trong UTF-8, và emoji tốn 4 byte.
> - **Công thức quy đổi**: `Số Byte = Số Bit / 8`.

Tôi từng nói chuyện với một đồng nghiệp có thể đọc vanh vách **"1 byte = 8 bit"** ngay cả khi đang mơ ngủ, nhưng lại đứng hình khi bị hỏi: *"Tên của mày tốn bao nhiêu byte?"*

Giờ thì ta xử lý câu hỏi đó.

## Mô hình Bãi Đỗ Xe

Hãy tưởng tượng một bãi đỗ xe có 8 ô. Mỗi ô hoặc trống (0) hoặc có xe (1). Cả bãi đó chính là một byte.

| Ô # | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
|-----|---|---|---|---|---|---|---|---|
| Giá | $128 | $64 | $32 | $16 | $8 | $4 | $2 | $1 |

- **1 byte** = 1 bãi đỗ với 8 ô
- **1 bit** = 1 ô (trống = 0, có xe = 1)
- Mỗi ô có một **mức giá** theo vị trí: ô 0 giá \$1, ô 1 giá \$2, ô 7 giá \$128
- Tổng doanh thu = tổng mức giá của các ô đang có xe

_Đây là trực quan hóa cấu trúc của một byte:_

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar2.webp)

00000001 → chỉ ô cuối có xe → doanh thu = 1

00000010 → ô kế bên có xe → doanh thu = 2

11111111 → cả 8 ô đều đầy → doanh thu = 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255

Con số (0–255) chỉ phụ thuộc vào việc ô nào có xe.

## ASCII

Vì sao máy tính lại nhóm **8 bit** (2³) thành 1 byte? Sao không phải 6 hay 10?

Câu trả lời ngắn: **8 bit là kích thước “vừa đẹp” cho văn bản.** 🐧

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar4.webp)

### ASCII Character Set

Để lưu văn bản, máy tính cần ánh xạ ký tự → số. Với **8 bit**, bạn có **256** giá trị (0–255). Chừng đó đủ chứa mọi chữ cái tiếng Anh (a-z, A-Z), chữ số và ký hiệu, còn dư chỗ.

Hãy nghĩ 256 giá trị này như 256 cấu hình bãi đỗ xe khác nhau. Mỗi cấu hình tương ứng với một ký tự.

**Nhưng có một cú twist:** ASCII chuẩn thực ra chỉ cần **7 bit** (128 giá trị).

Vậy sao lại 8? Thực tế là một hỗn hợp của lựa chọn phần cứng “hên xui” thời kỳ đầu và nhu cầu có một “đơn vị” chuẩn hóa để chứa nhiều thứ hơn là chỉ văn bản đơn giản.

_Đây là trực quan hóa cách ký tự được phân bố trong byte:_

### ASCII Encoding

Vậy làm sao chuyển qua lại giữa ký tự và byte như hình minh họa ở trên?

Lấy ví dụ mã hóa chữ "Y" (trong YELL).

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar6.webp)

**Bước 1: [Character set](#ascii-character-set) Ký tự → Số**

Tra bảng [ASCII](https://www.ascii-code.com/): Y = 89

**Bước 2: [Encoding](#ascii-encoding) Số → Nhị phân**

Đây là chỗ nhiều người kẹt. Hãy dùng **phương pháp thử-bit (bit-test)**. Thuộc lòng dãy: `128, 64, 32, 16, 8, 4, 2, 1`

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar5.webp)

Bắt đầu với 89 và đi từ trái sang phải:
- 89 ≥ 128? ❌ → 0
- 89 ≥ 64? ✅ → 1 (89 − 64 = 25)
- 25 ≥ 32? ❌ → 0
- 25 ≥ 16? ✅ → 1 (25 − 16 = 9)
- 9 ≥ 8? ✅ → 1 (9 − 8 = 1)
- 1 ≥ 4? ❌ → 0
- 1 ≥ 2? ❌ → 0
- 1 ≥ 1? ✅ → 1

```
128 | 64 | 32 | 16 | 8 | 4 | 2 | 1
  0 |  1 |  0 |  1 | 1 | 0 | 0 | 1
```

Kết quả: `01011001`. Đó là **một byte**.

_Cũng có cách “chia 2 liên tục” để đổi thập phân sang nhị phân, nhưng cá nhân tôi thấy hơi mệt và hiếm khi dùng._

> **Chuyển đổi tư duy:**
>
> - Con người nghĩ theo **ký tự**
> - Máy tính nghĩ theo **byte**
> - Encoding là lớp phiên dịch giữa hai thế giới

## Lớn Hơn ASCII

ASCII ổn với tiếng Anh. Nhưng còn 🦈, 你, ộ, hay ắ?

256 giá trị là không đủ. Ta cần một thứ “to hơn”.

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar7.webp)

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar8.webp)

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar9.webp)

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar10.webp)

### Bộ ký tự Unicode

Hỏi: Unicode có giống ASCII nhưng “bự hơn” không?

Đáp: Cũng gần đúng, nhưng chưa đủ chính xác.

ASCII có 2 phần:
- Bộ ký tự (character set): đổi ký tự → số thập phân
- Encoding: đổi số thập phân → nhị phân

Unicode chỉ là một **bộ ký tự (character set)**. Nó gán một số duy nhất (**code point**) cho mỗi ký tự, nhưng không bắt bạn phải lưu số đó dưới dạng bit như thế nào.

| Ký tự | Code Point | Thập phân |
|------|------------|----------|
| 🦈 | U+1F988 | 129,416 |
| 你 | U+4F60 | 20,320 |
| ộ | U+1EC7 | 7,879 |
| ắ | U+1EA5 | 7,845 |

Unicode 17.0 có hơn 150.000 code point.

Phần “encoding” (lưu bằng byte ra sao)? Đó là lúc **UTF-8** xuất hiện.

### UTF-8 Encoding

Code point → byte. Làm thế nào?

Với ASCII, chuyện rất đơn giản: một ký tự = một byte.

Nhưng 🦈 là 129,416 (vượt xa 255). Một bãi đỗ (một byte) không chứa nổi.

Vậy làm sao phân bố “xe” qua nhiều bãi đỗ để biểu diễn số lớn?

Ta cần **nhiều bãi đỗ hơn**.

#### UTF-8: Hệ thống xâu chuỗi nhiều bãi

Xâu chuỗi nhiều bãi tạo ra một vấn đề: máy tính biết đâu là điểm kết thúc của một ký tự và bắt đầu của ký tự kế tiếp?

UTF-8 giải quyết bằng **khuôn byte (byte templates)**. Vài bit đầu cho biết bạn cần đọc bao nhiêu byte.

| Số byte | Khuôn |
|--------|-------|
| 1 | `0xxxxxxx` |
| 2 | `110xxxxx 10xxxxxx` |
| 3 | `1110xxxx 10xxxxxx 10xxxxxx` |
| 4 | `11110xxx 10xxxxxx 10xxxxxx 10xxxxxx` |

Các tiền tố (`110`, `1110`, `11110`) nói với máy tính: “Tôi là ký tự nhiều byte, hãy đọc thêm X byte nữa.”

**Ví dụ: mã hóa 🦈**

1. **Tìm code point**: 🦈 = U+1F988 = 129,416
2. **Kiểm tra khoảng**: 129,416 nằm trong 65,536 – 1,114,111 → cần 4 byte
3. **Đổi sang nhị phân**: biểu diễn code point ở dạng nhị phân (21 bit)
4. **Nhét vào khuôn**: phân phối các bit đó vào khuôn 4 byte

#### Áp dụng với Python

Trong Python, **text** (`str`) và **raw bytes** (`bytes`) là hai kiểu khác nhau.

- `str` là Unicode text (chuỗi các code point)
- `encode("utf-8")` biến text đó thành đúng các byte sẽ được lưu/truyền đi

```py
>>> char = "🦈"

>>> char.encode("utf-8")
b'\xf0\x9f\xa6\x88'

>>> list(char.encode("utf-8"))
[240, 159, 166, 136]

>>> char.encode("utf-8").hex()
'f09fa688'
```

Bạn đang thấy gì ở đây:

- `b'...'` nghĩa là: **đây là bytes, không phải text**
- Mỗi `\x..` là **một byte viết ở dạng hex** (`f0`, `9f`, `a6`, `88`)
- Cùng các byte đó ở dạng thập phân là `240, 159, 166, 136`
- Nó tốn 4 byte vì 🦈 nằm ngoài ASCII, nên UTF-8 dùng khuôn 4 byte

Và bạn luôn có thể decode ngược lại thành text:

```py
>>> b'\xf0\x9f\xa6\x88'.decode('utf-8')
'🦈'
```

#### UTF-8 BOM

BOM (Byte Order Mark) là một chuỗi byte tùy chọn đặt ở đầu file để báo encoding (và với UTF‑16/UTF‑32 còn để chỉ thứ tự byte).

UTF-8 **không cần** BOM. Nhưng đôi khi một số tool/editor vẫn lưu file theo kiểu “UTF‑8 with BOM”, tức là nó chèn thêm 3 byte ở ngay đầu file:

- BOM (hex): `EF BB BF`
- Nếu decode ra text, nó tương ứng với ký tự Unicode `U+FEFF`

Phần lớn trường hợp thì vô hại. Nhưng nó hay gây lỗi khi parser “khó tính” mong byte đầu tiên phải là một ký tự cụ thể (ví dụ JSON phải bắt đầu bằng `{`), trong khi file lại bắt đầu bằng BOM.

Kiểm tra/xử lý nhanh:

```bash
# xem 3 byte đầu của file
xxd -g 1 -l 3 file.json
```

```py
# bỏ BOM cho file text
open("file.json", "r", encoding="utf-8-sig").read()
```

#### Tham khảo nhanh

| Khoảng code point | Kích thước | Ví dụ | Code Point | Thập phân | UTF-8 bytes (thập phân) |
|------------------|-----------|------|------------|----------|--------------------------|
| 0 – 127 (ASCII) | 1 byte | Y | U+0059 | 89 | 89 |
| 128 – 2,047 | 2 byte | é | U+00E9 | 233 | 195, 169 |
| 2,048 – 65,535 | 3 byte | 你 | U+4F60 | 20,320 | 228, 189, 160 |
| 65,536 – 1,114,111 | 4 byte | 🦈 | U+1F988 | 129,416 | 240, 159, 166, 136 |

**Kết luận:** cái hay của UTF-8 không chỉ là hỗ trợ emoji. Nó vẫn tương thích ASCII *và* mở rộng được ra toàn bộ không gian Unicode.

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar12.webp)

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar13.webp)

## Máy tính lượng tử (Bonus)

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/bitbytechar14.webp)

Giờ ta phá luật vật lý của bãi đỗ xe một chút.

Một bit cổ điển thì rất đơn giản: ô hoặc **trống (0)** hoặc **có xe (1)**.

Một **quantum bit (qubit)** thì… lạ. Chiếc xe bước vào trạng thái **chồng chập (superposition)**.

- **Chồng chập (superposition)**: chiếc xe ở trạng thái “ma”, vừa như có xe *vừa như không* cùng lúc.
- **Đo (measurement)**: khi bạn nhìn/đo, chiếc xe bị ép phải “chọn phe”. Nó lập tức sụp về 0 hoặc 1 bình thường.

Nó giống “Ô đỗ xe của Schrödinger”. Rùng rợn? Có. Nhưng nhờ đó, máy tính lượng tử có thể tính toán rất nhiều khả năng song song.

Với tình trạng “lúc vui lúc buồn” đó, qubit dùng cho việc khác, không phải để lưu trữ như cách cổ điển.

![Image](https://raw.githubusercontent.com/HoangGeek/store/main/webp/sum.webp)
