How would I go about making an HTTP request within a React component in the most clean, efficient way possible?
There are two main ways to make an HTTP request within a React component: using the Fetch API or using a third-party library like Axios.

The Fetch API is a built-in JavaScript API that provides a simple way to make HTTP requests. To make an HTTP request using the Fetch API, you can use the `fetch()` method. The `fetch()` method takes a URL as its argument and returns a promise. The promise resolves with the response data when the request is successful, or rejects with an error if the request fails.

Here is an example of how to make a GET request using the Fetch API:

```javascript
const url = 'https://api.example.com/users';

const response = await fetch(url);

if (response.ok) {
  // The request was successful.
  const data = await response.json();
} else {
  // The request failed.
  console.error(response.statusText);
}
```

Axios is a third-party library that provides a more comprehensive API for making HTTP requests. Axios supports all the common HTTP methods, such as GET, POST, PUT, and DELETE. It also supports request headers, cookies, and other features.

To make an HTTP request using Axios, you can use the `axios.request()` method. The `axios.request()` method takes an object as its argument, which specifies the request options. The following is an example of how to make a GET request using Axios:

```javascript
axios.get('https://api.example.com/users');
```

Which method you choose to use depends on your specific needs. If you want to use a simple, built-in API, then the Fetch API is a good option. If you need more features or control over the request, then Axios is a better choice.
What's a concrete example of when I would need to use Axios vs Fetch? I need to call our backend server, and need to supply an Authorization bearer header.
To call your backend server and supply an Authorization bearer header, I would recommend using Axios. Axios has a built-in method for adding headers to requests, making it easy to add the Authorization header.

Here is an example of how to make a GET request to your backend server using Axios and the Authorization bearer header:

```javascript
import axios from 'axios';

const token = 'YOUR_BEARER_TOKEN';

const headers = {
  Authorization: `Bearer ${token}`,
};

axios.get('https://YOUR_BACKEND_SERVER_URL/api/users', { headers });
```

If you were to use the Fetch API to make the same request, you would need to manually add the Authorization header to the request. Here is an example:

```javascript
const url = 'https://YOUR_BACKEND_SERVER_URL/api/users';

const headers = new Headers();
headers.append('Authorization', `Bearer ${token}`);

const request = new Request(url, {
  headers,
});

fetch(request);
```

As you can see, the Axios example is more concise and easier to read.

Here is a concrete example of when you would need to use Axios vs Fetch:

* **Use Axios:** When you need to add headers to requests, or when you need to use other advanced features of HTTP requests, such as request timeouts and interceptors.
* **Use Fetch:** When you need a simple and lightweight API for making HTTP requests.

In general, Axios is a good choice for most applications. It is easy to use and provides a comprehensive set of features for making HTTP requests.