Gõ code với ký hiệu đặc biệt hiệu quả
Nếu bạn là lập trình viên và chưa từng luyện gõ ký hiệu đặc biệt, bạn đang bỏ lỡ 30% tốc độ gõ code. Ký tự như `{`, `}`, `[`, `]`, `=>`, `<=` chiếm 25-40% code. Nhưng đa số dev chưa bao giờ luyện riêng chúng. Bài này chia sẻ cách luyện.
Ký hiệu đặc biệt trong code
Nhóm 1: Ngoặc
- `(` `)` - hàm, biểu thức.
- `{` `}` - block code, object.
- `[` `]` - array, index.
- `<` `>` - tag HTML, generic.
Nhóm 2: Phân tách
- `,` - phân tách tham số.
- `;` - kết thúc câu lệnh.
- `:` - object property, ternary.
- `.` - object access, method call.
Nhóm 3: Toán tử
- `=` `==` `===` - gán, so sánh.
- `+` `-` `*` `/` `%` - phép tính.
- `+=` `-=` `*=` `/=` - gán tổ hợp.
- `!` `!=` `!==` - phủ định.
Nhóm 4: Logic
- `&&` - AND.
- `||` - OR.
- `?` `:` - ternary.
- `??` - null coalescing.
Nhóm 5: Ký hiệu đặc biệt
- `"` `'` `` ` `` - chuỗi.
- `\` - escape.
- `#` `@` `$` - ký hiệu ngôn ngữ cụ thể.
- `->` `=>` - arrow function.
Tổng: hơn 30 ký hiệu cần thành thạo.
Vì sao dev thường gõ chậm ký hiệu?
Nguyên nhân 1: Không phải bàn phím QWERTY chuẩn
Bàn phím QWERTY được thiết kế cho văn bản, không code. Các ký hiệu nằm ở:
- Hàng trên (số).
- Bên phải (dấu phím).
- Kết hợp Shift.
Ngón phải với xa để gõ.
Nguyên nhân 2: Không luyện chuyên biệt
Trường học dạy gõ chữ. Không ai dạy gõ `{[({}])}`. Dev tự học, tự lóng ngóng.
Nguyên nhân 3: Ký hiệu khác nhau giữa ngôn ngữ
- JavaScript: `=>`, `===`
- Python: `:`, indent
- HTML/JSX: `<tag>`, `</tag>`
- Rust: `::`, `?`
Mỗi ngôn ngữ có bộ ký hiệu riêng.
Ngón nào cho ký hiệu nào?
Ngón út phải:
- `;` `:` (semicolon, colon)
- `'` `"` (nháy đơn, kép)
- `[` `]` (ngoặc vuông)
- `{` `}` (ngoặc nhọn - với Shift)
- `\` `|` (backslash, pipe)
- `Enter` `Backspace`
Ngón áp út phải:
- `.` `>` (chấm, greater than)
- `L` (cho các lệnh log, etc.)
Ngón giữa phải:
- `,` `<` (phẩy, less than)
- `K` `I` `8`
Ngón trỏ phải:
- `M` `N` `J` `H`
- `U` `Y` `6` `7`
Ngón cái phải:
- `Space`
- `Alt`, `Cmd` (tùy hệ)
Ngón trỏ trái:
- `F` `R` `V` `T` `G` `B`
- `4` `5`
Ngón út trái:
- `A` `Q` `Z`
- `1` `!` `~` `\``
- `Shift`, `Ctrl`, `Tab`, `CapsLock`
Ngón út phải làm việc rất nhiều trong code. Đây là ngón cần rèn nhất.
Bốn bài tập luyện ký hiệu
Bài tập 1: Ngoặc cơ bản (10 phút)
Gõ tuần tự các loại ngoặc:
```
() {} []
(a) [b] {c}
({[]}) ({[a]})
(){}[] {}[]() []{}()
```
Yêu cầu: chính xác 100%. Đúng ngón: `(` và `)` bằng ngón út phải (với Shift).
Bài tập 2: Ngoặc kết hợp (10 phút)
Bây giờ ngoặc lồng nhau như trong code thật:
```
function(a) { return a; }
const arr = [1, 2, 3];
if (x > 0) { y = 1; }
obj = { key: [1, 2, 3] };
```
Bài tập 3: Toán tử (7 phút)
```
a == b, a != b, a === b
a > b, a < b, a >= b, a <= b
a && b, a || b, !a
a += 1, b -= 2, c *= 3
```
Luyện các toán tử phổ biến.
Bài tập 4: Arrow function và template literal (7 phút)
Đặc biệt cho JavaScript modern:
```
const f = (x) => x * 2;
const g = async () => { await api(); };
const s = `Hello ${name}`;
const arr = [1, 2].map(x => x + 1);
```
Luyện gõ `=>` (bằng và lớn hơn liền nhau) và `` ` `` (backtick).
Kế hoạch 3 tuần
Đầu tư 15 phút/ngày:
Tuần 1: Bài tập 1 (ngoặc cơ bản). Focus chính xác 100%.
Tuần 2: Bài tập 2 (ngoặc kết hợp) + Bài tập 3 (toán tử). Chuyển sang tốc độ khi đã chính xác.
Tuần 3: Bài tập 4 + code thực. Áp dụng vào project.
Sau 3 tuần, ký hiệu trở nên phản xạ. Tốc độ gõ code tăng 30-40%.
Snippets - tăng tốc gõ ký hiệu
Đừng gõ ký hiệu từng cái. Dùng snippets trong IDE:
VS Code snippets ví dụ:
JavaScript arrow function:
```
"prefix": "af",
"body": "const $1 = ($2) => { $3 };"
```
Gõ "af" + Tab → template arrow function xuất hiện. Điền tên và tham số.
JSX component:
```
"prefix": "rfc",
"body": [
"const $1 = () => {",
" return (",
" <div>$2</div>",
" );",
"};",
"export default $1;"
]
```
Gõ "rfc" + Tab → template React component. 10 dòng code từ 3 ký tự.
Auto-close brackets
IDE hiện đại tự đóng ngoặc:
- Gõ `(` → tự thêm `)`.
- Gõ `{` → tự thêm `}`.
- Gõ `[` → tự thêm `]`.
Bật tính năng này. Tiết kiệm 50% gõ ngoặc.
VS Code: bật mặc định.
Vim: cài plugin auto-pairs.
IntelliJ: bật trong Settings.
Bàn phím phím tắt trong IDE
Comment code:
- Cmd/Ctrl + /: Comment/uncomment dòng.
- Cmd/Ctrl + Shift + /: Comment block.
Chọn text nhanh:
- Cmd/Ctrl + D: Chọn từ tiếp theo giống.
- Alt + Click: Multi-cursor.
Di chuyển:
- Cmd/Ctrl + F: Tìm.
- Cmd/Ctrl + Shift + F: Tìm workspace.
- Cmd/Ctrl + G: Đi đến dòng.
Format:
- Shift + Alt + F (VS Code): Format code.
Học 15-20 phím tắt, tiết kiệm hàng giờ mỗi tuần.
Bàn phím cho lập trình viên
Layout tối ưu:
- 60%: Cực gọn, thẩm mỹ. Nhưng không có phím F1-F12 riêng.
- 65%: Có arrow keys. Cân bằng.
- 75%: Có cả F keys. Recommend cho đa số dev.
Switch tối ưu:
- Cherry MX Brown: Tactile nhẹ. Phổ biến nhất.
- Cherry MX Red: Linear, gõ nhanh.
- Cherry MX Silent: Nếu làm ở nơi cần yên tĩnh.
Keycap:
- PBT thay ABS.
- Cherry profile cho gõ nhanh.
Đầu tư 2-3 triệu cho bàn phím tốt. Dev gõ 6-8 giờ/ngày, đây là đầu tư đáng.
Câu chuyện: mình học Vim
Cách đây 3 năm, mình bắt đầu học Vim mode trong VS Code. Ban đầu cực khó - phải nhớ nhiều lệnh.
Sau 3 tháng luyện đều:
- Di chuyển bằng h/j/k/l (không dùng arrow).
- `dd` xóa dòng nhanh.
- `yy p` copy paste dòng.
- `/text` tìm.
- `:wq` save và thoát.
Tốc độ editing tăng gấp 2. Ít dùng chuột hơn = ít mỏi vai gáy.
Không phải ai cũng cần Vim. Nhưng nếu bạn dev serious, đáng đầu tư 3 tháng.
Kết luận
Gõ code hiệu quả không chỉ là gõ nhanh chữ. Đây là kỹ năng chuyên biệt bao gồm:
1. Luyện ký hiệu chuyên biệt (3 tuần, 15 phút/ngày).
2. Dùng snippets trong IDE.
3. Auto-close brackets bật.
4. Học phím tắt IDE (1 tháng).
5. Bàn phím phù hợp (2-3 triệu).
6. Có thể thử Vim mode (3 tháng).
Với đầu tư này, tốc độ gõ code tăng 50-100%. Năng suất tăng tương ứng.
Đây là kỹ năng cốt lõi cho lập trình viên chuyên nghiệp. Đừng bỏ qua chỉ vì "biết code là đủ".
