---
title: "Promise là gì? Cách dùng Promise trong JavaScript và React"
description: "Promise trong JavaScript là gì? Tìm hiểu 3 trạng thái, then, catch, finally, Promise.all, allSettled, race, any, lỗi thường gặp và cách dùng trong React."
canonical: "https://200lab.io/blog/promise-la-gi"
published: "2024-11-27T11:29:53Z"
updated: "2026-11-02T01:51:59Z"
authors: ["Tran Thuy Vy"]
tags: ["Frontend"]
reading_minutes: 18
access: "public"
---

Khi mới bắt đầu học JavaScript và React, mình đã từng bối rối với khái niệm Promise. Nó giống như một thứ gì đó mơ hồ và khó nắm bắt. Nhưng sau một thời gian tìm hiểu và thực hành, mình nhận ra rằng Promise thực sự là một công cụ mạnh mẽ giúp chúng ta xử lý các tác vụ bất đồng bộ một cách hiệu quả.

Trong tiếng Anh, "promise" là danh từ hoặc động từ chỉ một lời cam kết, sự bảo đảm sẽ thực hiện việc gì đó. Nếu bạn đang tra nghĩa từ vựng thông thường thì đó chính là câu trả lời ngắn gọn. Còn trong bài viết này, mình sẽ cùng bạn tìm hiểu về `Promise` trong lập trình JavaScript, một khái niệm xử lý bất đồng bộ mà dân làm web gặp hằng ngày.

Cụ thể, mình sẽ chia sẻ với các bạn:

- Promise là gì, 3 trạng thái của Promise và cách dùng `.then()`, `.catch()`, `.finally()`.
- Các hàm `Promise.all`, `Promise.allSettled`, `Promise.race`, `Promise.any` và thứ tự chạy của Promise trong Event Loop.
- Những lỗi thường gặp khi dùng Promise.
- Hướng dẫn áp dụng Promise trong dự án React, kể cả `use()` của React 19.

Hy vọng sau khi đọc xong, các bạn sẽ có cái nhìn rõ ràng hơn về Promise và tự tin áp dụng nó vào dự án của mình.

## 1. Bất đồng bộ trong JavaScript là gì?

Trước khi đi vào chi tiết về Promise, bạn cần hiểu về bất đồng bộ trong JavaScript. JavaScript là ngôn ngữ đơn luồng (single-threaded), nghĩa là nó chỉ thực thi một tác vụ tại một thời điểm. Tuy nhiên, trong thực tế, chúng ta thường phải xử lý nhiều tác vụ cùng lúc như call API, đọc/ghi file, hoặc xử lý sự kiện người dùng.

Nếu như bạn thực hiện các tác vụ trên một cách đồng bộ, ứng dụng sẽ bị "đóng băng" cho đến khi các tác vụ hoàn thành. Điều đó sẽ tạo ra trải nghiệm người dùng không hề tốt. Để giải quyết vấn đề này, JavaScript sử dụng cơ chế bất đồng bộ: trong lúc chờ các tác vụ này hoàn tất, luồng chính vẫn tiếp tục xử lý việc khác.

Nếu bạn mong muốn hiểu sâu hơn về cách mà JavaScript xử lý các tác vụ bất đồng bộ thì cá nhân mình khuyên bạn nên tìm hiểu về [Event Loop](</blog/event-loop-la-gi>).

## 2. Promise là gì? 3 trạng thái của Promise trong JavaScript

Trong JavaScript, `Promise` là một object đại diện cho kết quả thành công hoặc thất bại của một tác vụ bất đồng bộ sẽ hoàn tất trong tương lai. Promise có từ bản **ES2015**, còn gọi là ES6. Bạn có thể xem nó như một "chỗ giữ chỗ" cho một giá trị chưa có ngay lúc gọi.

Hãy tưởng tượng bạn đi đặt món ở quán ăn và nhận về một tờ phiếu hẹn có số thứ tự. Trong lúc bếp chuẩn bị, bạn vẫn rảnh tay lướt điện thoại hay trò chuyện cùng bạn bè. Cuối cùng, khi quầy gọi số, bạn sẽ nhận được món ăn đã đặt hoặc được nhân viên báo quán vừa hết nguyên liệu.

Một `Promise` luôn nằm ở một trong **3 trạng thái** sau:

- **pending**: trạng thái đang chờ, tác vụ bất đồng bộ chưa chạy xong.
- **fulfilled**: tác vụ hoàn thành suôn sẻ và trả về một giá trị kết quả.
- **rejected**: tác vụ thất bại và đi kèm lý do gây lỗi.

Khi đã chuyển sang **fulfilled** hoặc **rejected**, `Promise` được gọi là đã settled và giữ nguyên trạng thái đó mãi mãi, việc gọi `resolve` hay `reject` thêm lần nữa sẽ không có tác dụng. Bạn có thể xem luồng chuyển đổi này trong hình minh hoạ bên dưới.

![](https://assets.200lab.io/images/2024/12/05/promise-la-gi-example-a39e678ad640283127fb.webp)

## 3. Tại sao cần sử dụng Promise?

Trước khi có `Promise`, lập trình viên JavaScript thường truyền các hàm callback để xử lý tác vụ bất đồng bộ. Khi có nhiều bước phụ thuộc nhau, việc lồng nhiều callback vào nhau tạo ra cấu trúc "pyramid of doom" rất rối mắt, thường gọi là callback hell.

```js
getUser(userId, (user) => {
  getOrders(user.id, (orders) => {
    getOrderDetail(orders[0].id, (detail) => {
      console.log(detail);
    });
  });
});
```

`Promise` giải quyết vấn đề này bằng cách nối chuỗi `.then()` theo chiều dọc dễ đọc và gom toàn bộ việc xử lý lỗi về một hàm `.catch()` duy nhất. Ngoài ra, nó cung cấp các công cụ như `Promise.all` để kết hợp nhiều tác vụ chạy cùng lúc, đồng thời là nền tảng trực tiếp cho cú pháp `async`/`await` sau này.

## 4. Hướng dẫn sử dụng Promise trong JavaScript

### 4.1 Tạo một Promise

Để tạo một Promise, bạn sẽ sử dụng `new Promise`, truyền vào một hàm executor với hai tham số là `resolve` và `reject`. Bạn gọi `resolve` khi tác vụ thành công và `reject` khi tác vụ thất bại.

```js
const myPromise = new Promise((resolve, reject) => {
  // Làm tác vụ bất đồng bộ ở đây
  // Thành công: gọi resolve(giaTri)
  // Thất bại: gọi reject(new Error('Lý do lỗi'))
});
```

Ví dụ cụ thể hơn:

```js
const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    const success = true;
    if (success) {
      resolve('Success!');
    } else {
      reject(new Error('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 lỗi "Failed!". Nên truyền một object `Error` vào `reject` để có thêm thông tin stack khi debug.

### 4.2 Xử lý kết quả với .then(), .catch() và .finally()

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

- `.then(onFulfilled)`: được gọi khi Promise được hoàn thành.
- `.catch(onRejected)`: được gọi khi Promise bị từ chối.
- `.finally(onFinally)`: luôn được gọi khi Promise đã xong, dù thành công hay thất bại, hợp để tắt trạng thái loading.

```js
promise
  .then((result) => {
    console.log(result); // "Success!"
  })
  .catch((error) => {
    console.error(error.message); // "Failed!"
  })
  .finally(() => {
    console.log('Đã xong, tắt loading');
  });
```

### 4.3 Chaining Promises

Bạn có thể nối chuỗi các Promise bằng cách trả về (`return`) một Promise trong `.then()`. Bước sau sẽ chờ Promise đó xong rồi mới chạy.

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

### 4.4 Chạy nhiều Promise: Promise.all, allSettled, race và any

Khi cần xử lý nhiều tác vụ bất đồng bộ cùng lúc, bạn không cần chờ từng cái chạy nối đuôi nhau. Thay vào đó, JavaScript cung cấp **4 phương thức** tĩnh để gom nhóm chúng tuỳ theo bài toán thực tế.

```js
const promise1 = fetchData1();
const promise2 = fetchData2();

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

Bảng dưới đây tóm tắt sự khác biệt giữa các phương thức kết hợp này:

| Phương thức | Khi nào xong | Khi nào lỗi |
| --- | --- | --- |
| `Promise.all` | Khi tất cả `Promise` đều **fulfilled**. | Ngay khi có **1 phần tử** bị **rejected**. |
| `Promise.allSettled` | Khi tất cả đã settled, trả về mảng `{ status, value \| reason }`. | Không bao giờ reject vì lỗi của từng phần tử. |
| `Promise.race` | Ngay khi có **1 phần tử** đầu tiên settled, bất kể thành công hay lỗi. | Khi phần tử settled đầu tiên bị **rejected**. |
| `Promise.any` | Ngay khi có **1 phần tử** đầu tiên **fulfilled**. | Khi tất cả đều lỗi, trả về `AggregateError`. |

Nhờ đặc tính lấy kết quả của tác vụ xong sớm nhất, `Promise.race` rất hay được ứng dụng để tạo bộ đếm timeout cho các request mạng như ví dụ dưới đây.

```js
function timeout(ms) {
  return new Promise((_, reject) => {
    setTimeout(() => reject(new Error(`Quá ${ms}ms`)), ms);
  });
}

Promise.race([fetch('https://jsonplaceholder.typicode.com/users'), timeout(3000)])
  .then((response) => console.log('Status:', response.status))
  .catch((error) => console.error(error.message));
```

Khi dùng các hàm kết hợp này, bạn hãy luôn gắn thêm `.catch()` ở cuối để xử lý các trường hợp bị reject bất ngờ.

### 4.5 Promise.resolve, Promise.reject, Promise.withResolvers và Promise.try

Bên cạnh việc khởi tạo bằng từ khoá `new Promise`, bạn còn có **4 phương thức** tĩnh tiện lợi khác để tạo và quản lý `Promise`:

- `Promise.resolve(value)`: tạo ngay một `Promise` đã ở trạng thái **fulfilled** với giá trị truyền vào.
- `Promise.reject(reason)`: tạo nhanh một `Promise` đã ở trạng thái **rejected** kèm nguyên nhân lỗi.
- `Promise.withResolvers()`: trả về một object gồm `{ promise, resolve, reject }`, cho phép bạn gọi `resolve` hoặc `reject` từ bên ngoài hàm executor. Tính năng này đã được hỗ trợ rộng rãi trên các trình duyệt từ **tháng 3/2024**.
- `Promise.try(fn)`: nhận vào hàm `fn` đồng bộ hoặc bất đồng bộ và luôn gói kết quả thành `Promise`, tự động biến cả lỗi `throw` đồng bộ thành rejection. Phương thức này đạt chuẩn Baseline từ **tháng 1/2025** trên **Chrome 128**, **Firefox 134** và **Safari 18.2**.

```js
const { promise, resolve } = Promise.withResolvers();

const button = document.querySelector('#start');
button.addEventListener('click', () => resolve('Đã bấm nút'), { once: true });

promise.then((message) => console.log(message));
```

```js
function parseConfig(text) {
  return JSON.parse(text); // có thể throw lỗi đồng bộ
}

Promise.try(() => parseConfig('{ sai cú pháp'))
  .then((config) => console.log(config))
  .catch((error) => console.error('Lỗi:', error.message));
```

## 5. Thứ tự chạy của Promise: microtask và Event Loop

Để hiểu rõ thứ tự thực thi của `Promise`, bạn hãy thử đoán xem đoạn code dưới đây sẽ in các số ra màn hình theo thứ tự nào?

```js
console.log('1');

setTimeout(() => console.log('2'), 0);

Promise.resolve().then(() => console.log('3'));

console.log('4');
```

Kết quả in ra lần lượt là **1, 4, 3, 2**. Các dòng lệnh đồng bộ luôn chạy trước nên **1** và **4** xuất hiện đầu tiên.

Các callback bên trong `.then()`, `.catch()` hay `.finally()` được đưa vào hàng đợi microtask, trong khi `setTimeout` thuộc hàng đợi macrotask. Theo cơ chế của [Event Loop](</blog/event-loop-la-gi>), toàn bộ microtask sẽ được ưu tiên chạy ngay sau khi code đồng bộ hiện tại kết thúc và chạy trước các macrotask, vì vậy số **3** được in ra trước số **2**.

## 6. Lỗi thường gặp khi dùng Promise

### Quên return trong .then()

Khi nối chuỗi nhiều bước, nếu bạn quên từ khoá `return` bên trong hàm `.then()`, bước tiếp theo sẽ nhận giá trị `undefined` và chạy ngay mà không chờ tác vụ trước đó hoàn tất.

```js
// Sai: không return nên bước sau nhận undefined
getUser()
  .then((user) => {
    getOrders(user.id);
  })
  .then((orders) => {
    console.log(orders); // undefined
  });

// Đúng: return Promise để chuỗi chờ kết quả
getUser()
  .then((user) => getOrders(user.id))
  .then((orders) => {
    console.log(orders);
  });
```

### Quên .catch() khiến lỗi bị nuốt

Một `Promise` bị reject mà không có `.catch()` xử lý sẽ phát ra sự kiện `unhandledrejection` trên trình duyệt, hoặc làm dừng luôn process trên Node.js theo mặc định từ bản **Node.js v15**.

```js
// Bắt lỗi ở cuối chuỗi
loadData()
  .then(render)
  .catch((error) => showError(error));

// Trên trình duyệt, có thể theo dõi các rejection bị bỏ sót
window.addEventListener('unhandledrejection', (event) => {
  console.error('Promise bị reject mà không có catch:', event.reason);
});
```

### await từng phần tử trong vòng lặp

Đặt `await` trực tiếp trong vòng lặp sẽ bắt các tác vụ phải chờ nối đuôi nhau rất mất thời gian. Nếu các tác vụ độc lập với nhau, bạn nên gom chúng lại và chạy cùng lúc bằng `Promise.all`; chỉ khi nào bước sau thực sự cần kết quả của bước trước thì mới giữ cách chạy tuần tự.

```js
// Chạy tuần tự: request sau chờ request trước xong
const users = [];
for (const id of ids) {
  users.push(await fetchUser(id));
}

// Chạy cùng lúc khi các request độc lập với nhau
const usersAtOnce = await Promise.all(ids.map((id) => fetchUser(id)));
```

### Nghĩ rằng fetch lỗi 404 sẽ nhảy vào .catch()

Hàm `fetch` chỉ thực sự reject khi gặp lỗi mạng hoặc khi request bị huỷ chủ động. Với các mã lỗi HTTP như **404** hay **500**, `Promise` từ `fetch` vẫn tính là **fulfilled**, nên bạn cần tự kiểm tra thuộc tính `response.ok` để bắt lỗi.

```js
fetch('https://jsonplaceholder.typicode.com/users/9999')
  .then((response) => {
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }
    return response.json();
  })
  .then((user) => console.log(user))
  .catch((error) => console.error('Lỗi:', error.message)); // "Lỗi: HTTP 404"
```

### Bọc Promise có sẵn trong new Promise

Khi một hàm thư viện hay `fetch` đã trả về sẵn một `Promise`, việc bọc nó thêm một lớp `new Promise` nữa là dư thừa và dễ làm sót lỗi.

```js
// Không cần thiết: fetch đã trả về Promise
function getUsersWrapped() {
  return new Promise((resolve, reject) => {
    fetch('/api/users')
      .then((response) => response.json())
      .then(resolve)
      .catch(reject);
  });
}

// Viết lại: trả thẳng Promise của fetch
function getUsers() {
  return fetch('/api/users').then((response) => response.json());
}
```

## 7. Hướng dẫn sử dụng Promise trong React

Khi xây dựng ứng dụng React, bạn sẽ thường xuyên làm việc với `Promise` để gọi API lấy dữ liệu hoặc gửi biểu mẫu lên server. Việc quản lý đúng trạng thái chờ, xử lý lỗi và dọn dẹp tác vụ khi chuyển trang sẽ giúp giao diện mượt mà và tránh cập nhật state cho component đã bị gỡ.

### 7.1 Sử dụng fetch API với Promise

`fetch` là một API có sẵn trong JavaScript để lấy dữ liệu qua mạng, và nó trả về một Promise.

```js
fetch('https://jsonplaceholder.typicode.com/users')
  .then((response) => {
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }
    return response.json();
  })
  .then((data) => {
    console.log(data);
  })
  .catch((error) => {
    console.error('Lỗi:', error);
  });
```

Trong ví dụ này, chúng ta gọi đến API tại: `https://jsonplaceholder.typicode.com/users` để lấy danh sách người dùng. Lưu ý `fetch` không tự reject khi server trả về lỗi HTTP, nên mình kiểm tra `response.ok` trước khi đọc JSON.

### 7.2 Sử dụng Promise, useEffect trong component

```jsx
import { useState, useEffect } from 'react';

function UserList() {
  const [users, setUsers] = useState(null);
  const [error, setError] = useState(null);

  useEffect(() => {
    const controller = new AbortController();

    fetch('https://jsonplaceholder.typicode.com/users', { signal: controller.signal })
      .then((response) => {
        if (!response.ok) {
          throw new Error(`HTTP ${response.status}`);
        }
        return response.json();
      })
      .then((data) => setUsers(data))
      .catch((err) => {
        if (err.name !== 'AbortError') {
          setError(err.message);
        }
      });

    return () => controller.abort();
  }, []);

  if (error) return <div>Lỗi: {error}</div>;
  if (!users) return <div>Loading...</div>;

  return (
    <ul>
      {users.map((user) => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

export default UserList;
```

Trong đoạn code trên, có **3 điểm** quan trọng bạn cần lưu ý:

- Mảng dependencies rỗng `[]` ở cuối giúp `useEffect` chỉ kích hoạt việc gọi API **1 lần** khi component vừa mount lên giao diện.
- Chúng ta chủ động kiểm tra `response.ok` để ném lỗi kịp thời khi server trả về mã lỗi như **404** hoặc **500**, vì `fetch` không tự reject các trường hợp này.
- `AbortController` được dùng để huỷ request mạng ngay khi component unmount, đồng thời nhánh `.catch()` sẽ bỏ qua lỗi `AbortError` để tránh cập nhật state trên một component đã bị gỡ bỏ.

### 7.3 React 19: đọc Promise bằng use() và Suspense

Từ phiên bản **React 19**, bạn có thể truyền trực tiếp một `Promise` vào API `use(promise)` để đọc dữ liệu ngay trong component. Khi `Promise` đang ở trạng thái **pending**, component gọi `use` sẽ tự động suspend, lúc này thẻ `<Suspense fallback>` bọc bên ngoài sẽ hiển thị giao diện chờ. Nếu `Promise` bị **rejected**, Error Boundary gần nhất sẽ bắt và hiển thị giao diện báo lỗi.

Khác với các React Hook thông thường, hàm `use` linh hoạt hơn khi có thể được gọi bên trong câu lệnh `if` hoặc các vòng lặp.

```jsx
import { Suspense, use } from 'react';

function UserList({ usersPromise }) {
  const users = use(usersPromise);

  return (
    <ul>
      {users.map((user) => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

// Tạo Promise một lần bên ngoài component để không bị tạo lại mỗi lần render
const usersPromise = fetch('https://jsonplaceholder.typicode.com/users').then((res) => res.json());

export default function App() {
  return (
    <Suspense fallback={<div>Loading...</div>}>
      <UserList usersPromise={usersPromise} />
    </Suspense>
  );
}
```

Bạn cần lưu ý là `Promise` truyền vào `use()` phải được cache, chẳng hạn tạo từ Server Component rồi truyền qua props hoặc dùng thư viện có cache, không tạo mới `Promise` ngay trong hàm render để tránh việc fallback bị kích hoạt lặp lại liên tục.

## 8. So sánh Promise và Async/Await

Mặc dù bài viết này tập trung vào Promise, nhưng mình muốn chia sẻ một chút về Async/Await để các bạn có cái nhìn tổng quan hơn.

Với Promise:

- Sử dụng các phương thức `.then()`, `.catch()` và `.finally()` nối tiếp nhau để xử lý kết quả.
- Khi có chuỗi tác vụ dài nhiều bước cần truyền dữ liệu qua lại, code dùng chuỗi `.then()` sẽ bắt đầu khó đọc hơn.
- Nếu lỡ tay lồng `.then()` bên trong một `.then()` khác thay vì `return` ra ngoài, code sẽ lại bị thụt lề nhiều cấp rất khó theo dõi, đôi khi được gọi vui là "promise hell".

```js
function fetchData() {
    return fetch('https://jsonplaceholder.typicode.com/users')
        .then((response) => response.json())
        .then((data) => {
            console.log('Result:', data);
        })
        .catch((error) => {
            console.error('Err:', error);
        });
}

fetchData();
```

Với Async/await:

- Giúp code trông giống như mã đồng bộ, dễ đọc và hiểu hơn.
- Sử dụng try...catch để xử lý lỗi.
- Tránh được việc lồng ghép quá nhiều .then().

```js
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();
```

Như bạn có thể thấy, với Async/Await, code trông giống code đồng bộ và dễ đọc hơn. Tuy nhiên, việc sử dụng Async/Await cũng yêu cầu bạn hiểu rõ về Promise, vì vốn dĩ nó chỉ là một cú pháp mới dựa trên Promise.

- Dùng các hàm như `Promise.all`, `Promise.race` khi cần chạy nhiều tác vụ bất đồng bộ cùng lúc, kể cả khi đang viết async/await. Ví dụ, thay vì chờ từng phần tử như thế này:

```js
for (const item of items) {
    await processItem(item);
}
```

bạn có thể cho các tác vụ độc lập chạy cùng lúc:

```js
await Promise.all(items.map((item) => processItem(item)));
```

- Sử dụng Async/Await khi bạn muốn code trông giống như đồng bộ, dễ đọc và cần thực hiện các tác vụ bất đồng bộ tuần tự.

## 9. Câu hỏi thường gặp về Promise

### Promise khác callback thế nào?

Với callback truyền thống, bạn phải truyền hàm xử lý vào bên trong hàm gọi, rất dễ dẫn đến cấu trúc lồng nhau nhiều tầng khi có nhiều bước liên tiếp. `Promise` trả về một object đại diện cho kết quả tương lai, cho phép bạn viết code phẳng theo chiều dọc bằng `.then()` và gom toàn bộ lỗi về một chỗ với `.catch()`.

### Promise có chạy song song không?

Bản thân JavaScript vẫn chạy đơn luồng và `Promise` không hề tạo thêm luồng xử lý mới. Tuy nhiên, các tác vụ như chờ mạng hay bộ đếm timer được trình duyệt hoặc Node.js đảm nhận ở bên dưới, nên nhiều `Promise` có thể cùng ở trạng thái chờ một lúc và dùng `Promise.all` để chồng thời gian chờ lên nhau thay vì đợi nối đuôi.

### Hàm async có luôn trả về Promise không?

Đúng vậy, mọi hàm được khai báo với từ khoá `async` đều luôn trả về một `Promise`, ngay cả khi bạn chỉ `return` một giá trị thông thường bên trong. Thực chất, từ khoá `await` chỉ là lớp cú pháp được xây dựng dựa trên nền tảng của `Promise` giúp code dễ nhìn hơn, bạn có thể đọc chi tiết tại bài viết về [Async/await](</blog/async-await-la-gi>).

## 10. Kết luận

Qua bài viết này, mình đã cùng bạn đi qua toàn bộ kiến thức cốt lõi về `Promise` trong JavaScript: từ **3 trạng thái** hoạt động, cách nối chuỗi `.then()`, `.catch()`, `.finally()`, các hàm kết hợp như `Promise.all` cho đến cơ chế hàng đợi microtask. Việc nắm rõ những lỗi phổ biến và cách kết hợp với `useEffect` hay API `use()` trong **React 19** sẽ giúp bạn kiểm soát luồng dữ liệu bất đồng bộ vững vàng hơn.

Để nhớ lâu hơn, bạn hãy thử tự mở trình soạn thảo code và viết vài ví dụ nhỏ gọi API bằng `fetch`, kết hợp thử `Promise.all` và `Promise.race` cho dự án React của mình nhé.

Các bài viết liên quan:

- [Async/await là gì? Hướng dẫn sử dụng Async/await trong dự án React](</blog/async-await-la-gi>)
- [Một số Phương pháp cải thiện Performance trong dự án React](</blog/mot-so-phuong-phap-cai-thien-performance-trong-du-an-react>)
- [React Toastify là gì? Hướng dẫn sử dụng Toast Notification với React Toastify](</blog/react-toastify-la-gi>)
- [Lazy Loading: Kỹ thuật Tối ưu Hiệu suất Website](</blog/lazy-loading-la-gi>)
- [Event Loop là gì?](</blog/event-loop-la-gi>)

## Đọc thêm

- [Game System Design GonnaCrash được làm như thế nào](https://200lab.io/blog/game-system-design-gonnacrash-duoc-lam-nhu-the-nao.md): Kéo thả một hệ thống rồi nhìn nó trụ hay sập: cách mình dựng GonnaCrash, từ server làm trọng tài, con bot giải đề đến skin whiteboard.
- [Cách để website đạt Agent Ready - Chỉ có llms.txt hay render Markdown là chưa đủ](https://200lab.io/blog/cach-de-website-dat-agent-ready.md): llms.txt và bản Markdown mới là phần dễ thấy. Website Agent Ready còn cần twin đúng quyền, negotiation an toàn, cache không nhầm và UI cho Agent dùng browser.
- [Hành vi giúp Phân biệt các Senior Engineer với những người còn lại](https://200lab.io/blog/hanh-vi-giup-phan-biet-cac-senior-engineer-voi-nhung-nguoi-con-lai.md): Việc trở thành một senior engineer thực sự không chỉ nằm ở chức danh bạn được giao, mà là kết quả của tư duy, cách tiếp cận công việc mà bạn rèn luyện mỗi ngày
- [Shadcn UI vs Component Libraries truyền thống: Lựa chọn nào phù hợp với bạn?](https://200lab.io/blog/shadcn-ui-la-gi.md): Shadcn UI không phải là một thư viện component thông thường, mà là một bộ sưu tập các component React có thể sao chép và tùy chỉnh trực tiếp vào dự án của bạn
- [Hướng dẫn Prompt Engineering dành cho Developer](https://200lab.io/blog/huong-dan-prompt-engineering-danh-cho-developer.md): Bài viết liệt kê các kỹ thuật quan trọng giúp anh em developer khai thác tối đa sức mạnh của AI kèm theo ví dụ cụ thể
- [Mọi bài viết chủ đề Frontend](https://200lab.io/blog/tags/frontend.md)

Toàn bộ nội dung: https://200lab.io/llms.txt
