https://github.com/dfrho/async-python-and-js
Exploring Python and JavaScript Comparisons for Async Functions Making HTTP Calls
https://github.com/dfrho/async-python-and-js
async https javascript networking python
Last synced: about 1 year ago
JSON representation
Exploring Python and JavaScript Comparisons for Async Functions Making HTTP Calls
- Host: GitHub
- URL: https://github.com/dfrho/async-python-and-js
- Owner: dfrho
- Created: 2024-08-02T21:42:49.000Z (over 1 year ago)
- Default Branch: main
- Last Pushed: 2024-08-02T22:19:59.000Z (over 1 year ago)
- Last Synced: 2025-01-23T01:13:29.856Z (about 1 year ago)
- Topics: async, https, javascript, networking, python
- Homepage:
- Size: 2.93 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Asynchronous Functions and HTTPS Calls: JavaScript vs. Python
This document compares asynchronous functions and HTTPS calls in JavaScript and Python, focusing on syntax and implementation for both task types.
## 1. Asynchronous Functions
### JavaScript
JavaScript uses the `async/await` syntax for handling asynchronous operations, built on top of Promises.
```javascript
// Asynchronous function using async/await
async function fetchData() {
try {
const response = await fetch('https://api.example.com/data');
if (!response.ok) {
throw new Error('Network response was not ok');
}
const data = await response.json();
console.log(data);
} catch (error) {
console.error('Fetch error:', error);
}
}
// Call the async function
fetchData();
#### Key Points:
- **`async` Keyword**: Declares an asynchronous function.
- **`await` Keyword**: Pauses execution until the promise resolves.
- **Error Handling**: Implemented using `try/catch` blocks.
### Python
Python employs the `asyncio` library along with the `async`/`await` syntax to manage asynchronous operations.
```python
import asyncio
# Asynchronous function
async def fetch_data():
print('Fetching data...')
await asyncio.sleep(2) # Simulate an asynchronous operation (e.g., network call)
print('Data fetched')
# Run the asynchronous function
asyncio.run(fetch_data())
```
#### Key Points:
- **`async def`**: Defines an asynchronous function.
- **`await`**: Pauses execution until the awaited task completes.
- **`asyncio.run()`**: Executes the asynchronous function in an event loop.
## 2. HTTP Calls
### JavaScript
JavaScript uses the `fetch` API for making HTTP calls, which return promises for handling asynchronous requests.
#### GET Request
```javascript
// GET request using fetch
fetch('https://api.example.com/data')
.then(response => {
if (!response.ok) {
throw new Error('Network response was not ok');
}
return response.json();
})
.then(data => {
console.log(data);
})
.catch(error => {
console.error('Fetch error:', error);
});
```
#### POST Request
```javascript
// POST request using fetch
fetch('https://api.example.com/data', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({ key: 'value' })
})
.then(response => {
if (!response.ok) {
throw new Error('Network response was not ok');
}
return response.json();
})
.then(data => {
console.log(data);
})
.catch(error => {
console.error('Fetch error:', error);
});
```
### Python
Python supports both synchronous and asynchronous HTTP calls using different libraries.
#### Asynchronous HTTP Calls with `aiohttp`
##### GET Request
```python
import aiohttp
import asyncio
# Asynchronous function to make an HTTP GET request
async def fetch_data():
async with aiohttp.ClientSession() as session:
async with session.get('https://api.example.com/data') as response:
if response.status != 200:
raise Exception('Network response was not ok')
data = await response.json()
print(data)
# Run the asynchronous function
asyncio.run(fetch_data())
```
##### POST Request
```python
import aiohttp
import asyncio
# Asynchronous function to make an HTTP POST request
async def post_data():
async with aiohttp.ClientSession() as session:
async with session.post('https://api.example.com/data', json={'key': 'value'}) as response:
if response.status != 200:
raise Exception('Network response was not ok')
data = await response.json()
print(data)
# Run the asynchronous function
asyncio.run(post_data())
```
#### Synchronous HTTP Calls with `requests`
##### GET Request
```python
import requests
# Synchronous GET request
response = requests.get('https://api.example.com/data')
if response.status_code == 200:
data = response.json()
print(data)
else:
print('Network response was not ok')
```
##### POST Request
```python
import requests
# Synchronous POST request
response = requests.post('https://api.example.com/data', json={'key': 'value'})
if response.status_code == 200:
data = response.json()
print(data)
else:
print('Network response was not ok')
```
## Summary
- **JavaScript**:
- **Asynchronous Functions**: Utilize the `async/await` syntax and promises.
- **HTTP Calls**: Use the `fetch` API for both GET and POST requests.
- **Python**:
- **Asynchronous Functions**: Employ `asyncio` with `async`/`await` syntax.
- **HTTP Calls**:
- **Asynchronous**: Use `aiohttp` for non-blocking operations.
- **Synchronous**: Use `requests` for straightforward HTTP requests.
Both languages provide powerful tools for asynchronous programming and HTTP interactions, each with unique syntax and implementation details.
I wondered about the efficiency, still thinking Python is more concise. The percentage difference in the number of lines between JavaScript and Python for these tasks is approximately -4.44%, indicating that the Python examples have slightly more lines overall, although a negligible difference.
This shows that both languages have similar levels of verbosity for the tasks demonstrated, with Python being slightly more concise in some cases and JavaScript in others.
```