Hướng dẫn chi tiết cách tạo và quản lý SSH Key cho Git (GitHub, GitLab), cấu hình nhiều tài khoản và bảo mật Server/VPS.

Hướng dẫn toàn tập về SSH Key: Git, Multiple Accounts & Server Security

Install UbuntuServer Error

Docker

Proxy Server

Get AI Gemini Free

Xử lí bất đồng bộ

TypeScript basic

Fast SSH to Raspberry Pi by Tailscale for System

Fast SSH to Raspberry Pi by Tailscale

OOP Javascript

JavaScript & NodeJS

Fix lỗi màn 180hz trên Linux(Ubuntu)

Cách kết nối tới Postgresql

Tìm hiểu về Static Site Generation (SSG) trong Next.js và cách nó giúp tối ưu performance cho blog.

Next.js và Static Site Generation

Học cách sử dụng Markdown để viết blog một cách hiệu quả và chuyên nghiệp.

Hướng dẫn viết Markdown


# Hướng dẫn toàn tập về SSH Key

Trong quá trình làm việc với Git (GitHub, GitLab) hay quản trị Server (VPS), việc sử dụng **SSH Key** là tiêu chuẩn bắt buộc để đảm bảo bảo mật và sự tiện lợi. Bài viết này sẽ hướng dẫn bạn từ cơ bản đến nâng cao: tạo key, cấu hình nhiều tài khoản (ví dụ: tài khoản cá nhân và công ty trên cùng một máy), và bảo mật Server để không cần nhập mật khẩu.

## 1. Tại sao nên dùng SSH Key?

- **Bảo mật hơn**: SSH Key khó bị tấn công brute-force hơn mật khẩu truyền thống.
- **Tiện lợi**: Không cần nhập username/password mỗi lần push code hay login vào server.
- **Quản lý dễ dàng**: Có thể thu hồi quyền truy cập bằng cách xóa public key mà không cần đổi mật khẩu.

## 2. Tạo SSH Key (Chuẩn Ed25519)

Hiện nay, thuật toán **Ed25519** được khuyên dùng thay thế cho RSA vì nó an toàn hơn và nhanh hơn.

Mở terminal (hoặc Git Bash trên Windows) và chạy lệnh sau:

```bash
ssh-keygen -t ed25519 -C "your_email@example.com"
```

- `-t ed25519`: Chọn thuật toán Ed25519.
- `-C "..."`: Comment để định danh key (thường dùng email).

Hệ thống sẽ hỏi nơi lưu file. Mặc định là `~/.ssh/id_ed25519`.
- Nếu bạn chỉ dùng 1 key duy nhất: Nhấn Enter.
- Nếu bạn muốn tạo key riêng cho công ty (để tách biệt): Nhập đường dẫn mới, ví dụ: `/home/user/.ssh/id_ed25519_company`.

Sau đó, bạn có thể đặt **passphrase** (mật khẩu cho key) để tăng bảo mật, hoặc để trống nếu muốn login nhanh.

## 3. Cấu hình cho Git (GitHub, GitLab)

### Bước 1: Lấy nội dung Public Key

Chạy lệnh sau để xem và copy public key:

```bash
cat ~/.ssh/id_ed25519.pub
# Hoặc key công ty
cat ~/.ssh/id_ed25519_company.pub
```

Kết quả sẽ bắt đầu bằng `ssh-ed25519 ...`. Hãy copy toàn bộ chuỗi này.

### Bước 2: Thêm vào GitHub/GitLab

- **GitHub**: Vào Settings -> SSH and GPG keys -> New SSH key.
- **GitLab**: Vào Preferences -> SSH Keys -> Add new key.

Dán nội dung vừa copy vào và lưu lại.

### Bước 3: Kiểm tra kết nối

```bash
ssh -T git@github.com
# Hoặc
ssh -T git@gitlab.com
```

Nếu thấy thông báo `Hi username! You've successfully authenticated...` là thành công.

## 4. Cấu hình nâng cao: Nhiều tài khoản (Personal vs Company)

Đây là vấn đề nhiều người gặp phải: Làm sao để dùng tài khoản GitHub cá nhân cho dự án riêng và tài khoản GitHub công ty cho dự án công việc trên cùng một máy?

Giải pháp là sử dụng file `config` của SSH.

### Bước 1: Tạo file config

Tạo hoặc chỉnh sửa file `~/.ssh/config`:

```bash
nano ~/.ssh/config
```

### Bước 2: Thêm cấu hình

Giả sử bạn có 2 key:
1. `~/.ssh/id_ed25519` (Cá nhân)
2. `~/.ssh/id_ed25519_company` (Công ty)

Thêm nội dung sau vào file config:

```ssh
# Tài khoản Cá nhân (Mặc định)
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519

# Tài khoản Công ty (Custom Host)
Host github-company
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519_company
```

### Bước 3: Sử dụng

- **Với dự án cá nhân**: Clone bình thường.
  ```bash
  git clone git@github.com:username/repo.git
  ```

- **Với dự án công ty**: Thay `github.com` bằng `github-company` (tên Host bạn đã đặt trong file config).
  ```bash
  git clone git@github-company:company-org/project.git
  ```

**Lưu ý**: Nếu dự án đã clone rồi, bạn có thể sửa remote url:
```bash
git remote set-url origin git@github-company:company-org/project.git
```

## 5. Bảo mật Server/VPS (SSH Hardening)

Để bảo mật VPS, chúng ta sẽ làm 2 việc:
1. Copy SSH Key lên server để login không cần mật khẩu.
2. Tắt chức năng đăng nhập bằng mật khẩu (Password Authentication) để chặn hacker brute-force.

### Bước 1: Copy SSH Key lên Server

Từ máy cá nhân của bạn, chạy lệnh:

```bash
ssh-copy-id -i ~/.ssh/id_ed25519 root@ip-server-cua-ban
```

Nhập mật khẩu root lần cuối. Sau khi xong, thử login lại: `ssh root@ip-server`. Nếu vào thẳng được là thành công.

### Bước 2: Tắt đăng nhập bằng mật khẩu

SSH vào server, sau đó sửa file cấu hình SSH:

```bash
sudo nano /etc/ssh/sshd_config
```

Tìm và sửa các dòng sau (nếu chưa có thì thêm vào):

```ssh
# Tắt login bằng mật khẩu
PasswordAuthentication no

# Chỉ cho phép dùng Key
PubkeyAuthentication yes

# (Tùy chọn) Tắt login quyền root nếu bạn đã tạo user sudo riêng
# PermitRootLogin no
```

### Bước 3: Khởi động lại SSH service

```bash
sudo service ssh restart
# Hoặc
sudo systemctl restart sshd
```

**Quan trọng**: Đừng thoát phiên SSH hiện tại ngay. Hãy mở một terminal mới và thử login lại (`ssh root@ip-server`) để chắc chắn mọi thứ hoạt động. Nếu login được thì mới thoát phiên cũ.

---

## 6. Trường hợp ngược lại: Tạo Key trên Server và lấy về máy

Đôi khi bạn cần tạo key trên server (ví dụ: để server này truy cập vào GitHub/GitLab hoặc server khác) và bạn muốn lưu private key về máy cá nhân để backup hoặc sử dụng.

### Bước 1: Tạo Key trên Server

SSH vào server và chạy lệnh tạo key như bình thường:

```bash
ssh-keygen -t ed25519 -C "server-key" -f ~/.ssh/id_ed25519_server
```

### Bước 2: Lấy Private Key về máy cá nhân

Từ **máy cá nhân** của bạn (không phải trên server), sử dụng lệnh `scp` (Secure Copy) để tải file về:

```bash
# Cú pháp: scp user@ip-server:path-to-remote-file path-to-local-destination
scp root@ip-server:~/.ssh/id_ed25519_server ~/.ssh/
```

### Bước 3: Phân quyền và sử dụng

Sau khi tải về, bạn cần set quyền chỉ đọc cho chủ sở hữu (bắt buộc với SSH key):

```bash
chmod 600 ~/.ssh/id_ed25519_server
```

Bây giờ bạn có thể dùng key này để SSH vào server (nếu đã add public key vào `authorized_keys` của server) hoặc dùng cho các mục đích khác.

```bash
ssh -i ~/.ssh/id_ed25519_server root@ip-server
```

## 7. Hiểu về `authorized_keys` và Cấu hình thủ công

Lệnh `ssh-copy-id` thực chất chỉ là một cách tự động để thêm public key của bạn vào file `~/.ssh/authorized_keys` trên server. Nếu bạn không dùng được `ssh-copy-id` (ví dụ server không có lệnh này hoặc bạn muốn hiểu rõ bản chất), bạn có thể làm thủ công.

### File `authorized_keys` là gì?

Đây là file nằm trong thư mục `~/.ssh/` của user trên server. Nó chứa danh sách các **Public Key** được phép đăng nhập vào user đó. Mỗi dòng là một public key.

### Cách thêm thủ công (Manual)

1.  **Trên máy cá nhân**: Copy nội dung public key.
    ```bash
    cat ~/.ssh/id_ed25519.pub
    ```
    Copy toàn bộ chuỗi bắt đầu bằng `ssh-ed25519 ...`.

2.  **Trên Server**:
    - Tạo thư mục `.ssh` (nếu chưa có):
      ```bash
      mkdir -p ~/.ssh
      chmod 700 ~/.ssh
      ```
    - Tạo hoặc sửa file `authorized_keys`:
      ```bash
      nano ~/.ssh/authorized_keys
      ```
    - Dán public key vào một dòng mới.
    - Lưu lại.

3.  **Quan trọng: Phân quyền (Permissions)**
    SSH rất khó tính về quyền truy cập. Nếu bạn để quyền quá lỏng lẻo (ví dụ ai cũng đọc được), SSH sẽ từ chối cho login.
    
    ```bash
    chmod 700 ~/.ssh
    chmod 600 ~/.ssh/authorized_keys
    ```

    - `700` cho thư mục: Chỉ chủ sở hữu được đọc, ghi, truy cập.
    - `600` cho file: Chỉ chủ sở hữu được đọc, ghi.

## Tổng kết

Với các bước trên, bạn đã thiết lập một môi trường làm việc chuyên nghiệp và bảo mật:
1. Sử dụng **Ed25519** key hiện đại.
2. Quản lý tách biệt code **Cá nhân** và **Công ty**.
3. Bảo vệ **Server/VPS** trước các cuộc tấn công dò mật khẩu.

Chúc các bạn thành công!



## Giới thiệu

Mình đã gặp lỗi khi cố tải UbuntuServer mà nó cứ báo lỗi như ảnh dưới

![Error](/images/posts/install-ubuntuserver-error/error.png)

![Error](/images/posts/install-ubuntuserver-error/image.png)

Lỗi này nguyên nhân là do ổ bị khóa như ảnh trên

## Cách fix

Dùng LiveUSB tải GParted về (dùng Rufus để cài ISO)  
Tất cả các ổ không có biểu tượng chìa khóa giống ảnh bên trên thì sẽ rất dễ để format nhưng riêng với ổ bị khóa phải dùng lệnh sau

```bash
sudo swapoff -a

sudo vgchange -an
```

Sau đó vào menu Device → Create Partition Table → Chọn “gpt”, sau đó nhấn “Apply” để xóa sạch mọi metadata cũ

**Tags:**  
**Danh mục:** Tutorial  
**Ngày tạo:** 2025-11-18



# Docker

## Phân biệt image và container

- Image là một khuôn mẫu có sẵn bao gồm các thư viện, cấu hình, mã nguồn, hệ điều hành, lệnh khời chạy(CMD) định hình cho container

  - Chỉ đọc(Read-only), được build và lưu trữ,, đóng gói ứng dụng và môi trường của nó - giống như một class

- Container được tạo ra từ khuôn image và từ một image có thể tạo ra nhiều container

  - Có thể chỉnh sửa, chạy trên một khuôn mẫu(image), được tạo-chạy-dừng-xóa, chạy và cô lập ứng dụng, - tương tự như object

## Mount

### Mount cùng một volume

- Dùng docker quản lí trên một thư mục ổ đĩa "ảo" với cách này chúng ta phải stop và xóa container đi (docker rm ten_file) và build lại container mỗi khi file thay đổi
- Sử dụng lệnh docker run -d -p 8080:80 -v /duong_dan_toi_folder_can_chay:/duong_dan_toi_container --name ten_container ten_image
  - -d - chạy ở chế độ nền tách ra khỏi terminal, -p - chạy ở cổng nào, -v - viết tắt cho volume, --name - tên container
  - Ví dụ: docker run -d -p 8080:80 -v ~/DevOps/shared-app:/usr/share/nginx/html --name web1 nginx

### Mount bind

- Dùng thư mục thật trên host cho container, tự động thay đổi dữ liệu bên trong container khi dữ liệu trên máy host thay đổi
- docker run -d -p 8080:80 -v $(pwd):/usr/share/nginx/html --name myweb nginx
  - /usr/share/nginx/html trong container sẽ trỏ đến thư mục hiện tại trên host

### Phần 1

Nội dung phần 1...

### Phần 2

Nội dung phần 2...

## Kết luận

Tóm tắt và kết luận...



# Proxy Server

## Nội dung chính

Proxy có nhiệm vụ chuyển tiếp và kiểm soát thông tin giữa client và server phía back end  
Proxy gồm 1 IP và 1 port để truy cập cố định

### Forward Proxy

- Là proxy server được dùng phía clinent

- Luồng hoạt động như sau: Client -> Forward Proxy -> Internet

- Tác dụng:
  - Ẩn địa chỉ IP của Client trước khi truy cập vào Internet
  - Truy cập vào các nội dung bị chặn bởi công ty, chính phủ
  - Dùng làm catching server để tăng tốc độ

### Reverse Proxy

- Là proxy dùng phía server tức là request sau khi đi qua Internet sẽ đi qua Reverse Proxy định hướng tiếp đi về server backend nào
- Tác dụng
  - Load balancing: giúp điều phối requests tới các servers backend để cân bằng tải, ngoài ra nó còn giúp hệ thống đạt tính sẵn sàng cao khi lỡ không may có server bị ngỏm thì nó sẽ chuyển request tới một server còn sống để thực thi.
  - Increased Security: Reverse Proxy còn đóng vai trò là một lớp bảo vệ cho các servers backend. Nó giúp cho chúng ta có thể ẩn đi địa chỉ và cấu trúc thực của server backend.
  - Logging: Tất cả các requests tới các servers backend đều phải đi qua reverse proxy nên việc quản lý log của access tới từng server và endpoint sẽ dễ dàng hơn rất nhiều so với việc kiểm tra trên từng server một.
  - Encrypted Connection: Bằng việc mã hóa kết nối giữa client và reverse proxy với TLS, users sẽ được hưởng lợi từ việc mã hóa dữ liệu và bảo mật với HTTPS.

### Catching server

### Firewall

### Load Balancer

## Kết luận

Tóm tắt và kết luận...



## Bước 1

**Xóa sạch toàn bộ dữ liệu trang web để web sạch nhất**

**Cài đặt extention Urban VPN và đổi VPN sang Mỹ**

## Bước 2

Vào link https://gemini.google/students và kiểm tra tài khoản gg đó có offer student không?
Nếu có click vào offer như hình dưới

![Gemini Student Offer](/images/posts/google-student-ai-free/image.png)

Nếu không thì làm tương tự trên tài khoản khác cho đến khi được<br>
_Có thể tạo tài khoản mới nhưng không nhất thiết là tài khoản sinh viên_

## Bước 3

Copy toàn bộ đường dẫn khi vào được trang xác thực và sau đó lên tele tìm bot id là sheeridverify_bot gõ lệnh: /verify `đường dẫn vừa copy`.

**Ví dụ:**  
/verify `https://services.sheerid.com/verify/67c8c14f5f17a83b745e3f82/?verificationId=68d9ec442d23380c673aa8d9&utm_source=gemini&utm_medium=web&utm_campaign`

Đợi cho bot chạy như ảnh bên dưới là được

![Verify Gemini Student Offer](/images/posts/google-student-ai-free/verify_success.png)

Bot chỉ chạy free được 1 lần nên muốn chạy tiếp thì nạp thêm vào, giá chỉ 1k/1 lần và sử dụng lệnh /nap

Ví dụ: Muốn nạp 6000 để chạy 6 lần verify

`/nap 6000`

## Bước 4

Add thẻ visa (không nạp tiền vào thẻ này)

## Bước 5

Lụm !



Trong JS các hàm sẽ không đợi nhau để trả về kết quả mà sẽ bỏ qua và chạy sự kiện phía sau và đợi các sự kiện khác phía trước phản hồi sau

### 1, Callback

```jsx
function doHomework(subject, callback) {
  alert(`Starting my ${subject} homework.`)
  callback()
}

doHomework("math", function () {
  alert("Finished my homework")
})
```

Sử dụng callback lồng trong hàm để chạy nhưng có thể tách callback ra một hàm riêng để có thể tường minh và dễ sửa chữa bảo trì hơn

```jsx
function doHomework(subject, callback) {
  alert(`Starting my ${subject} homework.`)
  callback()
}
function alertFinished() {
  alert("Finished my homework")
}
doHomework("math", alertFinished)
```

### 2, Promise

Promise là một đối tượng trong JavaScript đại diện cho một tác vụ bất đồng bộ có thể hoàn thành trong tương lai. Nó giống như một lời hứa: "Tôi hứa sẽ trả kết quả cho bạn khi tác vụ hoàn thành".

Một Promise có thể ở một trong ba trạng thái sau:

- Pending (đang chờ): trạng thái ban đầu, chưa hoàn thành hoặc bị từ chối.
- Fulfilled (hoàn thành): tác vụ đã hoàn thành thành công.
- Rejected (bị từ chối): tác vụ đã thất bại.

```jsx
// Khoi tao 1 promise

const myPromise = new Promise((resolve, reject) => {
  resolve(ket_qua)

  reject(loi)
})

// Set timeout cho promise

const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    const success = true
    if (success) {
      resolve("Success!")
    } else {
      reject("Failed!")
    }
  }, 1000)
})

//Trong ví dụ này, sau 1 giây, Promise sẽ được hoàn thành với kết quả "Success!" hoặc bị từ chối với "Failed!".
```

Sau đó là xử lí kết quả với promise

Để nhận kết quả từ một Promise, bạn có thể sử dụng phương thức `.then()` và `.catch()`.

- .then(onFulfilled): được gọi khi Promise được hoàn thành.
- .catch(onRejected): được gọi khi Promise bị từ chối.

```jsx
promise
  .then((result) => {
    console.log(result) // "Success!"
  })
  .catch((error) => {
    console.error(error) // "Failed!"
  })
```

Nối chuỗi promise lại với nhau

```jsx
firstPromise()
  .then((result1) => {
    return secondPromise(result1)
  })
  .then((result2) => {
    console.log(result2)
  })
  .catch((error) => {
    console.error(error)
  })

// Trả ra kết quả nếu result 1,2 trả về dữ liệu, còn không sẽ trả ra lỗi
```

Nhưng trong code thực tế sẽ vận dụng lí thuyết của Promise để tạo ra một phương thức khác dễ sử dụng và bảo trì sửa chữa dễ dàng hơn đó là Async/await

```jsx
const promise1 = fetchData1()
const promise2 = fetchData2()

Promise.all([promise1, promise2])
  .then(([result1, result2]) => {
    console.log(result1, result2)
  })
  .catch((error) => {
    console.error(error)
  })

// Gọi đồng thời hai API để trả về dữ liệu
```

### 3, Async/await

Là một tính năng của JS giúp xử lí code bất đồng bộ trở nên “đồng bộ” hơn trong mắt các lập trình viên, như đã nói ở trên, async/await được xây dựng dựa trên promise và nó sẽ tương thích với tất cả promise dựa trên API

Cách dùng: khai báo async ở đầu các hàm để JS biết đây là một hàm xử lí bất đồng bộ và sau đó chỉ await được xử dụng trong hàm async

```jsx
async function fetchData() {
  try {
    const response = await fetch("https://jsonplaceholder.typicode.com/users")
    const data = await response.json()
    console.log("Result:", data)
  } catch (error) {
    console.error("Err:", error)
  }
}

fetchData()
```

Async/await cũng thực hiện theo khối lệnh try/catch tức là sẽ trả kết quả nếu có dữ liệu khi gọi API còn nếu một trong các API nằm trong try bị lỗi thì nó sẽ nhảy sang catch và trả về lỗi, điều này rất dễ để coder có thể phát hiện lỗi và sửa chữa

Note: Tuy nhiên không phải lúc nào async/await cũng hoàn hảo đôi lúc những API cần gọi đồng thời với nhau thì nó sẽ làm chậm đáng kể vì phải chờ đợi API đầu tiên trả về rồi lần lượt, như thế sẽ rất mất thời gian- lúc này promise.all sẽ phát huy tác dụng, chúng ta phải linh hoạt khi sử dụng Promise và Async/await



### **1. Kiểu dữ liệu cơ bản (Basic Types)**

Đây là những kiểu dữ liệu nguyên thủy nhất.

- **`boolean`**: Giá trị `true` hoặc `false`.
- **`number`**: Tất cả các loại số (nguyên, thực, bát phân, thập lục phân).
- **`string`**: Chuỗi ký tự, có thể dùng dấu nháy đơn (`'`), nháy kép (`"`) hoặc backticks (```) cho template string.
- **`array`**: Mảng các giá trị cùng kiểu. Có hai cách khai báo: `let list: number[] = [1, 2, 3];` hoặc `let list: Array<number> = [1, 2, 3];`.
- **`tuple`**: Mảng có số lượng phần tử cố định và mỗi phần tử có một kiểu dữ liệu xác định.
- **`any`**: Kiểu "thần kỳ" cho phép bạn gán bất kỳ giá trị nào. Nên hạn chế sử dụng vì nó làm mất đi lợi ích của TypeScript.
- **`unknown`**: Tương tự `any` nhưng an toàn hơn. Bạn không thể thực hiện thao tác trên một biến `unknown` cho đến khi kiểm tra kiểu của nó.
- **`void`**: Thường dùng cho các hàm không trả về giá trị nào.
- **`null` & `undefined`**: Đại diện cho giá trị rỗng hoặc chưa được khởi tạo.

```jsx
// Ví dụt tổng quát về các kiểu dữ liệu

let isDone: boolean = false
let age: number = 30
let fullName: string = `John Doe`
let numbers: number[] = [1, 2, 3]

// Tuple: Mảng có kiểu dữ liệu cố định cho từng vị trí
let person: [string, number] = ["Alice", 25]

// any: Bỏ qua kiểm tra kiểu, nên tránh dùng
let notSure: any = 4
notSure = "maybe a string instead"

console.log(`Họ và tên: ${fullName}, Tuổi: ${age}`)
```

### **2. Interface & Type Alias**

Cả hai đều dùng để định nghĩa cấu trúc của một đối tượng.

- **`interface`**: Là một cách mạnh mẽ để định nghĩa "hợp đồng" cho một đối tượng. Interface có thể được `implement` bởi các `class` và có thể `extends` từ các interface khác.
- **`type` Alias**: Dùng từ khóa `type` để tạo một tên mới (bí danh) cho một kiểu dữ liệu. Nó linh hoạt hơn, có thể dùng cho các kiểu nguyên thủy, union, tuple.

**Khi nào dùng cái nào?**

- Dùng **`interface`** khi bạn định nghĩa cấu trúc của một đối tượng hoặc một lớp.
- Dùng **`type`** khi bạn muốn định nghĩa union, literal, hoặc các kiểu phức tạp khác.

```jsx
// Interface định nghĩa cấu trúc của một User
interface User {
    readonly id: number; // Thuộc tính chỉ đọc
    name: string;
    email: string;
    age?: number; // Thuộc tính tùy chọn
}

// Type Alias cho một kiểu dữ liệu cụ thể
type UserID = string | number;

let user: User = {
    id: 1,
    name: "Jane Doe",
    email: "jane.doe@example.com"
};

let userId: UserID = "user-123";
```

### **3. Function Types**

Định nghĩa kiểu dữ liệu cho một hàm, bao gồm kiểu của các tham số và kiểu giá trị trả về.

```jsx
// Định nghĩa kiểu cho một hàm nhận 2 số và trả về 1 số
type MathOperation = (x: number, y: number) => number

const add: MathOperation = (a, b) => {
  return a + b
}

const subtract: MathOperation = (a, b) => {
  return a - b
}

console.log(`Tổng: ${add(5, 3)}`) // Output: Tổng: 8
console.log(`Hiệu: ${subtract(5, 3)}`) // Output: Hiệu: 2
```

### **4. Union & Literal Types**

- **Union Type (`|`)**: Cho phép một biến có thể là một trong nhiều kiểu dữ liệu.
- **Literal Type**: Cho phép giới hạn giá trị của một biến trong một tập hợp các giá trị cụ thể.

```jsx
// Union Type: id có thể là string hoặc number
function printId(id: string | number) {
  console.log(`Your ID is: ${id}`)
}

printId(101) // OK
printId("202") // OK

// Literal Type: alignment chỉ có thể là 'left', 'right', hoặc 'center'
type Alignment = "left" | "right" | "center"

let textAlign: Alignment = "center"
// textAlign = "justify"; // Lỗi: Type '"justify"' is not assignable to type 'Alignment'.
```

### **5. Enum (Enumeration)**

Enum là một cách để định nghĩa một tập hợp các hằng số có tên. Theo mặc định, enum sẽ gán giá trị số bắt đầu từ 0.

```jsx
enum Direction {
Up,    // 0
Down,  // 1
Left,  // 2
Right  // 3
}

enum ResponseStatus {
Success = 200,
NotFound = 404,
Error = 500
}

let move: Direction = Direction.Left;
console.log(move); // Output: 2

let status: ResponseStatus = ResponseStatus.Success;
console.log(status); // Output: 200
```

### **6. Class & Tính chất OOP**

TypeScript hỗ trợ đầy đủ lập trình hướng đối tượng (OOP) với `class` và các tính chất như kế thừa, đóng gói, đa hình.

- **`public`**: Truy cập được từ mọi nơi (mặc định).
- **`private`**: Chỉ truy cập được bên trong lớp đó.
- **`protected`**: Truy cập được bên trong lớp đó và các lớp con kế thừa từ nó.

```tsx
class Animal {
  protected name: string

  constructor(name: string) {
    this.name = name
  }

  public move(distance: number): void {
    console.log(`${this.name} moved ${distance}m.`)
  }
}

class Dog extends Animal {
  // Kế thừa từ class Animal
  constructor(name: string) {
    super(name) // Gọi constructor của lớp cha
  }

  public bark() {
    console.log("Woof! Woof!")
  }
}

const myDog = new Dog("Buddy")
myDog.bark() // Output: Woof! Woof!
myDog.move(10) // Output: Buddy moved 10m.
// console.log(myDog.name); // Lỗi: Property 'name' is protected and only accessible within class 'Animal' and its subclasses.
```

### **7. Generic (Kiểu tổng quát)**

Generic cho phép tạo ra các thành phần (hàm, lớp, interface) có thể hoạt động với nhiều kiểu dữ liệu khác nhau mà không làm mất đi sự an toàn về kiểu.

```tsx
// Một hàm generic nhận vào một đối số và trả về chính nó
// 'T' là một biến kiểu (type variable) đại diện cho kiểu dữ liệu sẽ được truyền vào
function identity<T>(arg: T): T {
  return arg
}

let output1 = identity<string>("myString") // Kiểu của output1 là 'string'
let output2 = identity<number>(123) // Kiểu của output2 là 'number'

// Generic với mảng
function getFirstElement<T>(arr: T[]): T | undefined {
  return arr[0]
}

let firstNum = getFirstElement([1, 2, 3]) // Kiểu là number
let firstStr = getFirstElement(["a", "b", "c"]) // Kiểu là string
```

### **8. Type Inference (Suy luận kiểu tự động)**

Khi bạn không khai báo kiểu rõ ràng, TypeScript sẽ cố gắng _suy luận_ kiểu dữ liệu dựa trên giá trị được gán.

```jsx
let luckyNumber = 7 // TypeScript tự suy luận kiểu là 'number'
// luckyNumber = 'seven'; // Lỗi: Type 'string' is not assignable to type 'number'.

let languages = ["JavaScript", "TypeScript", "Python"] // TypeScript suy luận kiểu là string[]
```

### **9. Type Assertion (Ép kiểu)**

Đôi khi, bạn biết rõ về kiểu của một giá trị hơn là TypeScript. Type Assertion cho phép bạn truyền tới compiler về kiểu của một biến. Có hai cú pháp: `as` và `<>` (khuyến khích dùng `as` để tránh nhầm lẫn với cú pháp JSX trong React).2

```jsx
let someValue: unknown = "this is a string";

// Dùng 'as'
let strLength: number = (someValue as string).length;

// Dùng cú pháp '<>'
let strLength2: number = (<string>someValue).length;

console.log(strLength); // Output: 16
```

### **10. Non-null Assertion Operator (`!`)**

Toán tử `!` ở cuối một biểu thức cho TypeScript biết rằng bạn chắc chắn giá trị đó không phải là `null` hay `undefined`.

```jsx
function printName(name: string | null | undefined) {
// Dùng '!' để khẳng định 'name' không null/undefined ở đây
const nameLength = name!.length;
console.log(`Độ dài tên: ${nameLength}`);
}

printName("John Doe"); // Output: Độ dài tên: 8
// printName(null); // Sẽ gây lỗi ở runtime: "TypeError: Cannot read properties of null (reading 'length')"
```



## I, Tạo tài khoản Tailscale

- Truy cập https://tailscale.com/ và đăng ký một tài khoản miễn phí (có thể dùng tài khoản Google, Microsoft, GitHub).

## II, Kết nối vào Pi trên local

- Chạy lệnh sau trong Terminal của Pi để cài đặt Tailscale:
  `curl -fsSL https://tailscale.com/install.sh | sh`
- Sau khi cài xong, chạy lệnh sau để kết nối Pi vào mạng của bạn:
  `sudo tailscale up`
- Lệnh này sẽ đưa ra một đường link. Hãy sao chép đường link đó, dán vào trình duyệt trên máy tính chính của bạn, đăng nhập và xác nhận để thêm Raspberry Pi vào mạng.

Khi hiện các dòng như ở dưới là thành công

`sudo tailscale up`

`To authenticate, visit:`

[`https://login.tailscale.com/a/18a29b......`](https://login.tailscale.com/a/18a29b84013c0f)

`Success.`

Lấy đường link vào trình duyệt để yêu cầu đăng nhập vào tài khoản Tailscale (tài khoản Google/Microsoft... mà bạn đã dùng để đăng ký

## III, Kết nối từ xa

- Mở lại trang quản trị Tailscale trên trình duyệt: https://login.tailscale.com/admin/machines
- Bạn sẽ thấy danh sách các máy của mình. Hãy tìm Raspberry Pi và **sao chép địa chỉ IP** của nó (sẽ có dạng **`100.x.x.x`**).
- Mở Terminal (hoặc PowerShell/CMD trên Windows) và dùng lệnh `ssh` với địa chỉ IP mới này:
  `ssh pi@<địa-chỉ-IP-của-Tailscale>`

## IV, Share với người khác

![image.png](attachment:baf0f77a-4c00-415c-bf5d-daced17f3da7:image.png)

Click vào Share và nhập email của người muốn share là sẽ được truy cập vào

Thanks!



## I, OOP là gì

OOP ( Viết tắt của Object Oriented Progamming ) - Lập trình hướng đối tượng là một phương pháp lập trình dựa trên khái niệm lớp và đối tượng. OOP tập trung hơn vào cái đối tượng hơn là khai thác logic để thao tác chúng, giúp code dẽ quản lý, tái sử dụng được và dễ bảo trì

OOP là lập trình hướng đối tượng gồm 4 thuộc tính là

### 1, Tính đóng gói

```java
public class Person {
  private String name; // Ẩn thuộc tính name
  private int age;     // Ẩn thuộc tính age

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  // Phương thức công khai để lấy giá trị
  public String getName() {
    return name;
  }

  public int getAge() {
    return age;
  }

  // Phương thức công khai để thay đổi giá trị
  public void setAge(int age) {
    if (age >= 0) {
      this.age = age;
    }
  }
}

```

- Tính đóng gói không cho truy cập vào và thay đổi từ bên ngoài lớp giúp bảo vệ tính toàn vẹn dữ liệu
- Các thuộc tính thường được khai báo là **private** hoặc **protected** để không bị truy cập trực tiếp từ bên ngoài. Thay vào đó lớp sẽ cung cấp các phương thức công khai để truy xuất hoặc cập nhật các thuộc tính đó (getter/setter).
- Ở ví dụ trên, các thuộc tính **`name`** và **`age`** không thể truy cập trực tiếp từ bên ngoài mà phải thông qua các phương thức **`getName()`**, **`getAge()`**, và **`setAge()`**.

```jsx
// Lớp trừu tượng (thể hiện tính trừu tượng)
class Vehicle {
constructor(name) {
if (this.constructor === Vehicle) {
throw new Error("Không thể tạo đối tượng trực tiếp từ lớp trừu tượng Vehicle");
}
[this.name](http://this.name/) = name;
}

// Phương thức trừu tượng
move() {
throw new Error("Phương thức move() phải được override ở lớp con");
}
}

// Lớp con kế thừa Vehicle (kế thừa)
class Car extends Vehicle {
constructor(name, brand) {
super(name);
this.brand = brand;
}

// Ghi đè phương thức move (đa hình)
move() {
console.log(`${this.brand} ${this.name} đang chạy trên đường.`);
}
}

class Boat extends Vehicle {
constructor(name) {
super(name);
}

// Ghi đè phương thức move (đa hình)
move() {
console.log(`${this.name} đang di chuyển trên mặt nước.`);
}
}

// Tạo các đối tượng
const car1 = new Car("Sedan", "Toyota");
const boat1 = new Boat("Thuyền buồm");

car1.move();  // Toyota Sedan đang chạy trên đường.
boat1.move(); // Thuyền buồm đang di chuyển trên mặt nước.
```

### 2, Tính kế thừa

- Tính kế thừa là khả năng một lớp (class con) có thể kế thừa các thuộc tính và phương thức từ một lớp khác (class cha). Lớp con có thể sử dụng lại, bổ sung hoặc ghi đè các thuộc tính/method của lớp cha mà không cần phải định nghĩa lại.

Ví dụ :

**`Car`** và **`Boat`** kế thừa **`Vehicle`** (tính kế thừa).

### 3, Tính đa hình

- Tính đa hình cho phép các đối tượng thuộc các lớp khác nhau có thể được sử dụng thông qua cùng một giao diện chung hoặc lớp cha, nhưng tương tác thực tế có thể khác nhau tùy thuộc vào lớp cụ thể của đối tượng đó.
- **Đa hình tại thời gian biên dịch (Overloading):** Phương thức có cùng tên nhưng khác tham số. (Tùy thuộc ngôn ngữ hỗ trợ.)
- **Đa hình tại thời gian chạy (Overriding):** Lớp con định nghĩa lại (ghi đè) phương thức của lớp cha để thay đổi hành vi riêng.

Ví dụ :

**`Car`** và **`Boat`** ghi đè phương thức **`move()`** thành các hành vi riêng (tính đa hình).

### 4, Tính trừu tượng

- Tính trừu tượng là quá trình chỉ để lộ ra những tính năng cần thiết của một đối tượng và ẩn đi những chi tiết nội bộ không cần thiết. Trong OOP, thông thường sử dụng các class trừu tượng hoặc interface để định nghĩa giao diện làm việc chung, còn chi tiết cài đặt sẽ do lớp con thực hiện.

Ví dụ :

**`Vehicle`** là lớp trừu tượng (không thể tạo đối tượng trực tiếp), cung cấp giao diện **`move()`** chưa định nghĩa (bắt buộc lớp con ghi đè).

_Hiện nay OOP được áp dụng vào rất nhiều các ngôn ngữ trong đó có JS và đặc biệt hơn là cho Design Pattern để quản lí dự án để dễ bảo trì và mở rộng sau này_

## II, Class, Constructor, Instance, Properties, Methods, Getter/ setter

- Có thể nói rằng Class là khai báo ra một khuôn mẫu, lớp bọc cho các object, constructor để khai báo các object mới dựa trên class hoặc contructor function( khi một đối tượng được tạo bằng `new` thì constructor sẽ được gọi và gán giá trị đây chính là instance ), properties là thuộc tính, tạo hình cho class, còn methods là cách truy cập vào đối tượng qua class hoặc instance function
- Getter và setter dùng để lấy giá trị và gán giá trị cho các thuộc tính của đối tượng một cách an toàn và có kiểm soát

### 1. Khai báo

```
class ClassName {
  constructor() { ... }
  method_1() { ... } // method_1(x) {...} thêm tham số cho method
  method_2() { ... }
  method_3() { ... }
}
```

Class được khởi tạo phải có constructor, có thể thêm các method nếu cần thiết và kèm với đó là tham số( parameters ) cho method đó tùy vào trường hợp sử dụng, như ví dụ dưới

```jsx
class Car {
  constructor(name, year) {
    this.name = name
    this.year = year
  }
  age(x) {
    return x - this.year
  }
}
/* Ở đây chúng ta có thể truyền vào tham số cho age(method) dể lấy ra được
tuổi đời của chiếc xe
*/

const date = new Date()
let year = date.getFullYear()

const myCar = new Car("Xe1", 2014)
console.log(myCar.age(year))
```

### 2, Kế thừa class

```jsx
class Car {
  constructor(brand) {
    this.carname = brand
  }
  present() {
    return "I have a " + this.carname
  }
}

class Model extends Car {
  constructor(brand, mod) {
    super(brand)
    this.model = mod
  }
  show() {
    return this.present() + ", it is a " + this.model
  }
}

let myCar = new Model("Ford", "Mustang")

console.log(myCar.show()) // Output: I have a Ford, it is a Mustang
```

Khi kế thừa class bắt buộc phải dùng super để truy cập vào thuộc tính và phương thức của lớp cha

```jsx
// Getter/Setter
class Car {
  constructor(brand, model) {
    this.carname = brand;
    this.carmodel = model;
  }
  get cnam() {
    return this.carname;
  }
  set cnam(x) {
    this.carname = x;
  }
  get cmode() {
    return "hello"+ this.carmodel;
  }
  set cmode(x) {
    this.carmodel = x;
  }
}

const myCar = new Car("Ford", "M");

console.log(myCar.cnam) // Ford
myCar.cnam= "Toyota"; // Setter
console.log(myCar) // Car { carname : 'Ford' }
console.log(myCar.cnam); // Toyota - Getter
console.log(myCar.cmode);Ford // helloM - Getter

/* Getter và setter thực hiện lấy giá trị và gán giá trị cho brand và model
qua cách tạo mới new Car gán this.carname = 'Ford' và this.carmodel = 'M'
Hàm setter chỉ được sử dụng khi gán giá trị mới
*/

/* Theo quy ước các lập trình viên hay đặt thì sẽ đặt dấu _ trước tên thuộc tính
và đặt tránh với tên của phương thức getter/setter để tránh rơi vào vòng lặp
vô hạn và gây ra lỗi  */
get carname(){
	return this._carname;
}
```

### 3, Constructor và constructor function

3.1, Constructor

Được lồng vào bên trong class để khai báo các obj mới dựa trên class và trong 1 class chỉ được có 1 constructor duy nhất

```jsx
class Car {
  constructor(brand) {
    this._carname = brand
  }
}

// Ví dụ đây là 1 constructor trong class
```

3.2, Constructor function

Được sử dụng bên ngoài cùng cấp và giống như một class, tạo mới một đối tượng cũng dùng lệnh new

```jsx
function Person(
  first = "Unknown",
  last = "Unknown",
  age = 0,
  eyecolor = "Brown"
) {
  this.firstName = first
  this.lastName = last
  this.age = age
  this.eyeColor = eyecolor
  this.nationality = "Vietnamese"
}

const p1 = new Person() // Tất cả lấy mặc định
const p2 = new Person("Nguyen", "Tan") // Còn lại lấy mặc định
```

### 4, Instance

4.1, Khởi tạo bằng toán tử new

Dùng các phương thức hoặc tên class đặt cùng với new để tạo ra 1 instance

Tuy nhiên không phải phương thức nào đặt cùng new cũng hợp lệ ví dụ như Symbol

```jsx
new Symbol()
//Uncaught TypeError: Symbol is not a constructor...
Symbol("foo")
//Symbol(foo)
```

Hoặc có những đối tượng không cần sử dụng new cũng cho ra kết quả tương tự như Function,

Array, Error, RexExp(RegExp (viết tắt của Regular Expression, hay biểu thức chính quy) là một công cụ dùng để mô tả các mẫu (pattern) trong chuỗi ký tự, giúp tìm kiếm, kiểm tra, phân tích, và thay thế các đoạn văn bản theo các quy tắc cú pháp nhất định)

```jsx
Array(1, 2, 3)
//[1, 2, 3]
new Array(1, 2, 3)
//[1, 2, 3]
```

4.2, Khởi tạo bằng Reflect

```jsx
*Reflect*.construct(target, [argumentsList], newTarget)
```

target và newTarget đều có constructor riêng của nó

argumentsList là danh sách các đối số truyền vào

```jsx
class A {
  constructor() {
    this.message = function () {
      console.log("message from A")
    }
  }
}
class B {
  constructor() {}
  message() {
    console.log("message from B")
  }
  data() {
    console.log("data from B")
  }
}
obj = Reflect.construct(A, [], B)

console.log(obj.message())
// message from A
// Do constructor của A là một function chuyên biệt nhận message riêng của A
/* Còn nếu message không nằm trong constuctor mà nằm bên ngoài cùng cấp
thì nó sẽ bị thay bởi B.prototype 
Lúc đó output sẽ là message from BB
*/
console.log(obj.data())
// data from B
console.log(obj instanceof B)
// true
```

4.3, Khởi tạo bằng Object.create

```jsx
class Car {
  constructor(brand) {
    this.brand = brand
  }
}

obj = Object.create(new Car("Ford"), {
  data: {
    value: function () {
      return "hello " + this.brand
    },
  },
})

console.log(obj.data())
// hello Ford
```

### 5, Properties

```jsx
const person = {
  firstName: "John",
  lastName: "Doe",
  age: 50,
  eyeColor: "blue",
}
// Ví dụ thuộc tính của person là firstName, ....
// Truy cập vào thuộc tính thông qua cú pháp
let fname = person.firstName
```

### 7, Methods

```jsx
const person = {
  firstName: "John",
  lastName: "Doe",
  id: 5566,
  fullName: function () {
    return this.firstName + " " + this.lastName
  },
}
// fullName là một method sử dụng thuộc tính của person

console.log(person.fullName()) // John Doe
console.log(person.fullName) // function() { return this.firstName + " " + this.lastName; }

// Chúng ta có thể thêm method bên ngoài dựa trên thuộc tính obj có sẵn

person.name = function () {
  return this.firstName
}

console.log("My first name is: " + person.name())
// My first name is: John
```



### I, Khai báo biến và phân loại đặc điểm về các biến trong JS

Trong JS có 3 từ khóa để khai báo biến là `var`, `let`, `const` nhưng chúng có những đặc điểm khác nhau như sau

1, Phạm vi ( Scope )

`var` có phạm vi toàn cục ( global scope ) và phạm vi hàm ( function scope )

`let` và `const` có phạm vi khối ( block scope )

```jsx
if (true) {
  var x = 10
  let y = 20
  const z = 30
}
console.log(x) // 10
console.log(y) // ReferenceError
console.log(z) // ReferenceError
```

2, Hoisting

- `var` được hoisted (lên đầu phạm vi) và được khởi tạo với giá trị `undefined`
  `console.log(a); // undefined
var a = 5;`
- `let` và `const` cũng được hoisted nhưng không được khởi tạo, nó tạo ra “`temporal dead zone`”

**Temporal dead zone**: là khoảng thời gian mà biến được khai báo nhưng chưa được khởi tạo, trong thời gian này, nếu truy cập biến sẽ gây ra lỗi `ReferenceError`. Khi chương trình thực thi đến dòng khai báo biến, biến sẽ được khởi tạo và có thể truy cập.

```jsx
function example() {
  console.log(myVar) // ReferenceError: Cannot access 'myVar' before initialization
  let myVar = 10
  console.log(myVar) // 10
}
example()
```

3, Gán lại giá trị

- var và let có khả năng gán lại giá trị
- const không có khả năng gán lại giá trị

```jsx
;`var a = 1;
a = 2; // Hợp lệ``let b = 3;
b = 4; // Hợp lệ``const c = 5;
c = 6; // TypeError`
```

4, Khai báo lại

- `var` có thể khai báo lại trong cùng một phạm vi
- `let` và `const` không thể khai báo lại trong cùng một phạm vi

```jsx
;`var x = 1;
var x = 2; // Hợp lệ``let y = 3;
let y = 4; // SyntaxError``const z = 5;
const z = 6; // SyntaxError`
```

5, Liên kết với đối tượng toàn cục

5.1, Sử dụng đối tượng toàn cục

- Trong trình duyệt:Sử dụng `window`. Mọi biến, hàm, và đối tượng toàn cục đều được đặt trên đối tượng `window`.
- Trong Node.js:Sử dụng `global`. Các hàm, biến, module có thể được truy cập từ mọi module mà không cần import hay khai báo.
- Sử dụng `globalThis`:Đây là cách mới và được khuyến khích sử dụng để truy cập đối tượng toàn cục, vì nó tương thích với hầu hết các môi trường chạy JavaScript.

Lưu ý về `this`

- Trong phạm vi toàn cục, `this` tham chiếu đến `window` (trình duyệt) hoặc `global` (Node.js).
- Tuy nhiên, trong chế độ nghiêm ngặt (`strict mode`), `this` sẽ là `undefined` trong các hàm toàn cục, thay vì tham chiếu đến đối tượng toàn cục.

  5.2, Khai báo biến toàn cục

```jsx
;`var globalVar = 'Tôi là biến toàn cục';
console.log(window.globalVar); // 'Tôi là biến toàn cục'``let globalLet = 'Tôi không phải biến toàn cục';
console.log(window.globalLet); // undefined`
```

Bạn có thể khai báo biến toàn cục bằng cách định nghĩa biến bên ngoài bất kỳ hàm hoặc khối mã nào. JavaScript sẽ tự động coi các biến được khai báo mà không có từ khóa `var`, `let`, hay `const` là biến toàn cục

```jsx
;`// Trong trình duyệt
console.log(window.location.href); // Tham chiếu đến đối tượng toàn cục window``// Trong Node.js
console.log(global.process.version); // Tham chiếu đến đối tượng toàn cục global``// Sử dụng globalThis
console.log(globalThis.navigator.userAgent); // Hoạt động trên nhiều môi trường`
```

### II, Các kiểu dữ liệu

Với dynamic trong JS tự xác định kiểu dữ liệu cho biến đó dựa trên giá trị của nó gây ra tình trạng lỏng lẻo, không kiểm soát chặt được dữ liệu đầu vào

```jsx
// Dynamic typing (trong JavaScript)
let a = 42 // a là một số nguyên
const b = "Hello" // b là một chuỗi
var c = true // c là một boolean
```

Với static typing trong Java nó yêu cầu phải xác định được kiểu dữ liệu trước khi nhập giá trị của nó để gán vào biến

```jsx
// Static typing (trong java)
int a = 42; // a là một số nguyên
String b = 'Hello'; // b là một chuỗi
boolean c = true; // c là một boolean
```

1, Number - cả số nguyên và số thực

2, String - chuỗi kí tự

3, Boolean - true or false

4, Undefined - biến khai báo nhưng chưa được gán giá trị

5, Null - giá trị không tồn tại hoặc không hợp lệ

6, Symbol(ES6) - đại diện cho một giá trị không thể thay đổi

```jsx
const mySymbol = Symbol("key")
const obj = {
  [mySymbol]: "Giá trị của Symbol",
}
```

7, BigInt - kiểu số nguyên lớn vượt quá giới hạn của kiểu Number

8, Object - kiểu dữ liệu phức tạp biểu diễn dưới dạng key-value

```jsx
let person = {
  name: "Nguyễn Văn A",
  age: 30,
  isStudent: false,
}
```

9, Array - mảng

10, Function - là một kiểu dữ liệu trong JS

```jsx
function greet(name) {
  console.log("Xin chào, " + name + "!")
}
```

11, Map/Set

11.1, Map

Map là tập hợp của các cặp key-value có thể là bất cứ kiểu dữ liệu nào

```jsx
// Khởi tạo một map
const map1 = new Map();
const map2 = new Map([
  ['firstName', 'A'],
  ['lastName', 'B'],
  ['occupation', 'C'],
])
// Hoặc tạo một map từ một obj
const obj1 = {
  firstName: 'A',
  lastName: 'B',
  occupation: 'C',
}
const map3 = new Map(Object.entries(obj1))

// Biến một map thành obj hoặc arr
const obj = Object.fromEntries(map)
=> {firstName: "A", lastName: "B", occupation: "C"}

const arr = Array.from(map)
=> kết quả :
[ ['firstName', 'A'],
  ['lastName', 'B']
  ['occupation', 'C'] ]

// Thêm giá trị vào map
map.set('key1','value1');
map.set('key2','value2');

// Lấy giá trị trong map
map.get('key1') ==> 'value1'

// Kiểm tra key có tồn tại trong map không
map.has('key1') ==> true or false

// Xóa cặp giá trị key-value ra khỏi map
map.delete('key1')

// Xóa tất cả key-value
map.clear()

// Kiểm tra số lượng cặp giá trị trong map
map.size()

```

Keys trong Map là một giá trị duy nhất và có thể dùng được nhiều kiểu dữ liệu cho key nhưng không được trùng lặp vào một kiểu dữ liệu nào đó, nếu trong trường hợp có hai key cùng kiểu dữ liệu trùng lặp nhau thì value của key sau cùng sẽ ghi đè lên tất cả các key trước đó

```jsx
const map = new Map()

map.set('1', 'String one')
map.set(1, 'This will be overwritten')
map.set(1, 'Number one')
map.set(true, 'A Boolean')

0: {"1" => "String one"}
1: {1 => "Number one"}
2: {true => "A Boolean"}
```

11.2, Set

Set tương tự như Map nhưng nó sẽ giống array hơn trong khi Map giống obj

```jsx
// Giống ở bước khởi tạo
const set = new Set()

// Khác ở bước thêm dữ liệu vào set
set.add('arr1') thay vì map.set(key, value) như Map
```

### III, Vòng lặp

1, For loop

Vòng lặp for(khởi tạo biến đếm, kiểm tra điều kiện, tăng giảm biến đếm)

```jsx
for (var i = 0; i < 10; i++) {
  console.log(i)
}
```

Ví dụ: Với điều kiện khởi tạo chạy từ 0 đến 9 biến chạy tăng dần

In ra: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

2, While loop

Thực hiện vòng lặp khi điều kiện là đúng

```jsx
var i = 0
while (i < 10) {
  console.log(i)
  i++
}
```

Khi điều kiện i < 10 thỏa mãn thì sẽ in ra i , i tăng dần in ra: 0,1,2…., 9

3, Do - While loop

Chạy ít nhất một lần do nếu vẫn thỏa mãn while thì chạy tiếp do

```jsx
var i = 10
do {
  console.log(i)
  i++
} while (i > 10 && i < 12)
```

Ví dụ: in ra i = 10, sau đó thì i tăng lên thành 11 và vẫn thỏa mãn điều kiện của while nên được in ra thêm một lần nữa là 11

4, forEach()

forEach sẽ lặp từng phần tử trong arrayName theo thứ tự index trong mảng forEach sẽ không thực thi cho phần tử không có giá trị

```jsx
var arrayName = [arr1, arr2, ...]

arrayName.forEach(function(currentValue, index, array){
    function body
})

// currentValue: Giá trị đang được vòng lặp xử lý
// index: Chí số của giá trị (currentValue) trong mảng
// array: toàn bộ array đang gọi đến forEach
```

Ví dụ trực quan

```jsx
var arr=[10, 20, "hi", ,{}];

arr.forEach(function(item, index){
    console.log(' arr['+index+'] is '+ item);
});

// Output
 arr[0] is 10
 arr[1] is 20
 arr[2] is hi
 arr[4] is [object Object]
```

4, Map()

Cũng giống như forEach() nhưng Map() tạo ra một mảng mới chứ không phải thực thi một mảng có sẵn giống như forEach()

```jsx
var newArray = oldArray.map(function (currentValue, index, array) {
  //Return element for the newArray
})
```

5, for - in

For ... in mục đích chủ yếu được dùng để loop trong một object chứ không phải array . Số lượng vòng lặp sẽ tương ứng với số lượng thuộc tính của object

```jsx
var obj = { a: 1, b: 2, c: 3 }
for (var prop in obj) {
  console.log("obj." + prop + "=" + obj[prop])
}

obj.a = 1
obj.b = 2
obj.c = 3
```

6, for - of

Vòng lặp được ra mắt trong phiên bản ES6. Hàm này có thể sử dụng để duyệt phần lớn các đối tượng từ Array, String, Map, WeakMap, Set ,…

```jsx
var str = "paul"
for (var value of str) {
  console.log(value)
}

// Output
;("p")
;("a")
;("u")
;("l")
```

Ví dụ khác

```jsx
let itobj = new Map([
  ["x", 0],
  ["y", 1],
  ["z", 2],
])

for (let kv of itobj) {
  console.log(kv)
}
// ['x', 0]
// ['y', 1]
// ['z', 2]

for (let [key, value] of itobj) {
  console.log(value)
}

//0
//1
//2
```

### IV, Function

Function is a block command and you can reuse it for many task specific. Function help create structure program, separate different code and reuse it :::::)))))

1, Phân loại hàm

```jsx
// Function không có tham số
function khongthamso() {
  console.log("Function không có tham số")
}

// Function có tham số
function cothamso(a, b) {
  return a + b
}

// Function có tham số mặc định
function thamsoMacDinh(a = 1, b = 2) {
  return a * b
}

// Function khong trả về giá trị
function khongTraVe() {
  console.log("Function này không trả về giá trị")
}
```

2, Lưu ý

Các biến bên trong function không thể bị truy cập từ bên ngoài nhưng function có thể truy cập được các biến bên ngoài và trong cùng phạm vi được định nghĩa
