25 从零到上手学习 React 框架 - 第三方 API 集成

25 从零到上手学习 React 框架 - 第三方 API 集成

在本节中,我们将学习如何在一个 React 应用中集成第三方 API。我们将分步骤进行,最终创建一个可以显示数据的简单应用。

1. 创建 React 应用

首先,确保你已经安装了 Node.jsnpm。接着使用以下命令创建一个新的 React 应用:

1
2
npx create-react-app my-api-app
cd my-api-app

2. 安装 Axios

我们将使用 Axios 这个库来进行 API 请求。使用以下命令安装 Axios:

1
npm install axios

3. 选择一个第三方 API

为了演示,我们将使用 JSONPlaceholder 这个假数据 API。这个 API 提供了一些模拟的数据,方便进行测试。

4. 创建数据获取组件

接下来,我们将创建一个新的组件,用于获取并显示数据。首先,在 src 文件夹内创建一个新文件 MyDataComponent.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// src/MyDataComponent.js

import React, { useEffect, useState } from 'react';
import axios from 'axios';

const MyDataComponent = () => {
const [data, setData] = useState([]);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);

useEffect(() => {
// 定义异步获取数据的函数
const fetchData = async () => {
try {
const response = await axios.get('https://jsonplaceholder.typicode.com/posts');
setData(response.data); // 使用获取到的数据更新状态
} catch (err) {
setError(err); // 捕获错误
} finally {
setLoading(false); // 数据请求结束,设置加载状态为 false
}
};

fetchData(); // 调用获取数据的函数
}, []); // 空数组意味着只在组件挂载时运行

if (loading) {
return <p>Loading...</p>;
}

if (error) {
return <p>Error occurred: {error.message}</p>;
}

return (
<div>
<h1>Posts</h1>
<ul>
{data.map(post => (
<li key={post.id}>
<h2>{post.title}</h2>
<p>{post.body}</p>
</li>
))}
</ul>
</div>
);
};

export default MyDataComponent;

组件详细解读

  • useEffect: 此钩子用于处理副作用,例如 API 请求。我们提供一个空依赖数组 [],表示仅在组件首次加载时执行。
  • axios.get(): 用于发送 GET 请求并获取数据。
  • 状态管理:使用 useState 来管理数据、加载状态和错误状态。
  • 条件渲染:根据不同状态返回不同的 JSX。

5. 在 App 组件中使用 MyDataComponent

接下来,将 MyDataComponent 导入并使用在 App.js 中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// src/App.js

import React from 'react';
import MyDataComponent from './MyDataComponent';

function App() {
return (
<div className="App">
<header className="App-header">
<h1>My API App</h1>
<MyDataComponent />
</header>
</div>
);
}

export default App;

6. 启动应用

现在,可以使用以下命令启动你的应用:

1
npm start

你的浏览器应该在 http://localhost:3000 打开,看到加载的 Posts 列表。

7. 总结

在本节中,我们学习了如何:

  • 创建 React 应用并安装 Axios。
  • 使用 Axios 与第三方 API 进行集成。
  • 管理组件的状态和副作用。
  • 实现简单的条件渲染。

使用第三方 API 扩展 React 应用的功能是非常强大且常见的实践。你可以尝试连接其他的 API,获取不同类型的数据并进行展示。

从零到上手 - 小节管理应用数据流

从零到上手 - 小节管理应用数据流

在这个小节中,我们将探讨如何在一个小节管理应用中实现数据流。理解数据流是学习 React 的核心之一,因为它帮助我们构建可维护和可扩展的应用。

1. 什么是数据流

在 React 中,数据流 通常指的是组件之间状态的传递和管理。React 应用的状态管理可以遵循以下几个原则:

  • 自上而下(Unidirectional Data Flow):数据总是从父组件流向子组件。
  • 状态提升(Lifting State Up):当多个组件需要共享状态时,状态应该提升到它们的共同父组件中。

2. 小节管理应用概述

我们的目标是创建一个简单的小节管理应用,允许用户添加、删除和查看小节。我们的数据流将在以下几个组件间传递:

  • App:主组件,管理状态。
  • SectionList:展示小节列表。
  • SectionForm:输入和提交新小节。

3. 组件结构

1
2
3
4
5
6
App

├── SectionList
│ └── Section (列表项)

└── SectionForm

4. 状态管理

App 组件中,我们将维护小节的状态。例如,我们可以使用 useState 钩子来管理小节的数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import React, { useState } from 'react';
import SectionList from './SectionList';
import SectionForm from './SectionForm';

const App = () => {
// 定义小节状态
const [sections, setSections] = useState([]);

// 添加小节的函数
const addSection = (newSection) => {
setSections([...sections, newSection]);
};

// 删除小节的函数
const deleteSection = (index) => {
const newSections = sections.filter((_, i) => i !== index);
setSections(newSections);
};

return (
<div>
<h1>小节管理应用</h1>
<SectionForm addSection={addSection} />
<SectionList sections={sections} deleteSection={deleteSection} />
</div>
);
};

export default App;

4.1 SectionForm 组件

SectionForm 组件用于接受用户输入并调用 addSection 函数将新的小节添加到状态中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import React, { useState } from 'react';

const SectionForm = ({ addSection }) => {
const [sectionName, setSectionName] = useState('');

const handleSubmit = (e) => {
e.preventDefault();
if (sectionName) {
addSection(sectionName);
setSectionName('');
}
};

return (
<form onSubmit={handleSubmit}>
<input
type="text"
value={sectionName}
onChange={(e) => setSectionName(e.target.value)}
placeholder="输入小节名称"
/>
<button type="submit">添加小节</button>
</form>
);
};

export default SectionForm;

4.2 SectionList 组件

SectionList 组件接收小节数组并渲染每一个小节。它还会提供一个删除小节的功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import React from 'react';

const SectionList = ({ sections, deleteSection }) => {
return (
<ul>
{sections.map((section, index) => (
<li key={index}>
{section} <button onClick={() => deleteSection(index)}>删除</button>
</li>
))}
</ul>
);
};

export default SectionList;

5. 数据流总结

在这个小节管理应用中,我们实现了数据自上而下的流动。App 组件中的状态被传递到子组件 SectionFormSectionList。这个模式确保了我们的数据来源是集中和可控的。

  • 当用户在 SectionForm 中添加新小节时,App 组件的状态会更新,SectionList 组件会自动重新渲染以展示最新的小节列表。
  • 删除小节的操作同样是通过 App 组件中的函数来处理的,确保了状态的一致性。

理解并应用这个数据流的概念对于构建更复杂的 React 应用至关重要。接下来,我们可以进一步探讨如何整合路由和上下文来管理全局状态。

处理异步操作与数据请求

处理异步操作与数据请求

在 React 应用中,异步操作数据请求是非常常见的需求,尤其是在与后端 API 交互时。我们通常使用 fetch API 或者更高级的库(如 Axios)来发送请求并处理响应。

1. 使用 fetch API 进行数据请求

fetch 是一个用于网络请求的浏览器 API,它返回一个 Promise,允许我们进行异步数据获取。以下是一个简单的示例,展示如何使用 fetch 请求数据。

示例:获取用户数据

我们下面的例子将会从一个假设的 API 获取用户数据,并将其存储在组件的状态中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import React, { useEffect, useState } from 'react';

const UserList = () => {
const [users, setUsers] = useState([]);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);

useEffect(() => {
const fetchUsers = async () => {
try {
const response = await fetch('https://jsonplaceholder.typicode.com/users');
if (!response.ok) { // 检查响应状态
throw new Error('网络请求失败');
}
const data = await response.json();
setUsers(data);
} catch (error) {
setError(error.message);
} finally {
setLoading(false);
}
};

fetchUsers();
}, []); // 依赖数组为空,类似于 componentDidMount

if (loading) {
return <div>加载中...</div>;
}

if (error) {
return <div>错误: {error}</div>;
}

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

export default UserList;

代码解析:

  1. **useState**:定义了三个状态变量:users(存储用户列表)、loading(表示加载状态)和 error(存储错误信息)。
  2. **useEffect**:当组件挂载时执行 fetchUsers 函数。
  3. fetchUsers 函数:异步函数中使用 fetch 发送 GET 请求,处理响应和错误。
  4. 条件渲染
    • 如果 loadingtrue,显示“加载中…”。
    • 如果有错误,显示错误信息。
    • 否则,将用户列表渲染到页面中。

2. 使用 Axios 进行数据请求

虽然 fetch 是十分强大的 API,但我们也可以使用 Axios,它提供了更加友好的 API 和更多功能,如请求和响应拦截器等。

示例:使用 Axios 获取用户数据

安装 Axios:

1
npm install axios

然后在组件中使用 Axios 进行数据请求:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import React, { useEffect, useState } from 'react';
import axios from 'axios';

const UserList = () => {
const [users, setUsers] = useState([]);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);

useEffect(() => {
const fetchUsers = async () => {
try {
const response = await axios.get('https://jsonplaceholder.typicode.com/users');
setUsers(response.data); // 直接获取数据
} catch (error) {
setError(error.message);
} finally {
setLoading(false);
}
};

fetchUsers();
}, []);

if (loading) {
return <div>加载中...</div>;
}

if (error) {
return <div>错误: {error}</div>;
}

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

export default UserList;

Axios vs Fetch

  • 简洁性:Axios API 更加简洁,特别是在处理响应时。
  • 自动转换 JSON:Axios 会自动将响应数据转换为 JSON。
  • 请求拦截和响应拦截:Axios 支持请求和响应拦截,可以添加 Token 或处理错误的逻辑。

3. 处理副作用和清理

在进行异步请求的同时,我们需要注意组件在卸载时的副作用处理。通常情况下,我们会使用一个变量来标识组件是否仍然挂载,以避免在未挂载的组件上进行状态更新。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
useEffect(() => {
let isMounted = true; // 标记组件是否挂载

const fetchUsers = async () => {
try {
const response = await fetch('https://jsonplaceholder.typicode.com/users');
if (!response.ok) throw new Error('网络请求失败');
const data = await response.json();

if (isMounted) {
setUsers(data);
}
} catch (error) {
if (isMounted) {
setError(error.message);
}
} finally {
if (isMounted) {
setLoading(false);
}
}
};

fetchUsers();

return () => { isMounted = false; }; // 清理函数,组件卸载时设置标记
}, []);

4. 总结

在 React 中处理异步操作与数据请求主要依靠 useEffect 钩子和状态管理。根据具体需求,你可以选择 fetch API 或 Axios 来实现数据请求,并根据请求状态渲染相应的 UI。务必注意清理副作用,以避免可能的内存泄漏和状态更新错误。

通过以上示例与介绍,希望你能熟练掌握在 React 应用中进行异步操作与数据请求的基本方法。