AJAX stands forAsynchronous JavaScript and XML. It’s a technique used in web development to create dynamic and interactive web pages without needing to reload the entire page. With AJAX, you can request data from a server and update parts of a webpage asynchronously, meaning the user can continue interacting with the page while the request is being processed in the background.
AnAPI(Application Programming Interface) is a set of rules and definitions that allows different software applications to communicate with each other. In the context of web development, APIs are often used to interact with web servers, retrieve data, and send data. APIs can be public (available for anyone to use) or private (restricted to specific users or applications).
When you use AJAX and APIs together, you enable your web application to fetch, send, and update data dynamically. This combination allows you to build rich, responsive, and interactive web applications that provide a smooth user experience without constant page reloads.
AJAX is not a single technology but a combination of multiple technologies that work together:
To demonstrate the basics of AJAX, let’s create a simple HTML page and use JavaScript to send an AJAX request to a server.
AJAX Example AJAX Request Example
2.Create a JavaScript File (app.js):
document.getElementById('loadData').addEventListener('click', function() { const xhr = new XMLHttpRequest(); xhr.open('GET', 'https://jsonplaceholder.typicode.com/posts', true); xhr.onload = function() { if (xhr.status === 200) { document.getElementById('dataContainer').innerHTML = xhr.responseText; } else { console.error('Failed to load data'); } }; xhr.send(); });
3.Test the AJAX Request:
AnAPI(Application Programming Interface) is a set of rules and protocols that allows different software applications to communicate with each other. APIs define the methods and data formats that applications can use to interact with each other, making it easier to build software by providing reusable components and services.
APIs typically useJSON(JavaScript Object Notation) orXML(eXtensible Markup Language) to format data. JSON is more lightweight and easier to read, making it the preferred choice for most modern APIs.
{ "id": 1, "title": "Example Post", "body": "This is an example of a post.", "userId": 1 }
1 Example Post This is an example of a post.1
To make your first AJAX request, you need a basic HTML and JavaScript environment. Follow these steps:
First AJAX Request Fetch Data with AJAX
Create a JavaScript File (ajax.js):
document.getElementById('fetchDataBtn').addEventListener('click', function() { const xhr = new XMLHttpRequest(); xhr.open('GET', 'https://jsonplaceholder.typicode.com/posts/1', true); xhr.onload = function() { if (xhr.status === 200) { const data = JSON.parse(xhr.responseText); document.getElementById('dataDisplay').innerHTML = ` ${data.title}
${data.body}
`; } else { console.error('Error fetching data'); } }; xhr.onerror = function() { console.error('Request failed'); }; xhr.send(); });
3.Test the AJAX Request:
The XMLHttpRequest object is used to interact with servers. It allows you to make HTTP requests to retrieve or send data without reloading the page.
When the server responds to an AJAX request, the response is available in the xhr.responseText property. You can use JavaScript to process this data and update the webpage dynamically.
To debug AJAX requests, use browser developer tools:
TheFetch APIis a modern alternative to XMLHttpRequest for making HTTP requests. It provides a more powerful and flexible feature set and returns Promises, making it easier to handle asynchronous operations.
fetch('https://jsonplaceholder.typicode.com/posts/1')
.then(response => response.json())
.then(data => {
document.getElementById('dataDisplay').innerHTML =
<h2>${data.title}</h2>
<p>${data.body}</p>
;
})
.catch(error => console.error('Error fetching data:', error));
fetch('https://jsonplaceholder.typicode.com/posts', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
title: 'New Post',
body: 'This is a new post.',
userId: 1
})
})
.then(response => response.json())
.then(data => console.log('Post created:', data))
.catch(error => console.error('Error creating post:', error));
The Fetch API provides a json() method to parse the response body as JSON. This method returns a Promise that resolves with the parsed JSON data.
Use .catch() to handle errors in Fetch requests. This method catches any errors that occur during the fetch operation or while processing the response.
REST(Representational State Transfer) is an architectural style for designing networked applications. RESTful APIs follow specific conventions for managing resources over the web.
fetch('https://jsonplaceholder.typicode.com/posts')
.then(response => response.json())
.then(posts => {
posts.forEach(post => {
console.log(post.title);
});
})
.catch(error => console.error('Error fetching posts:', error));
CRUDstands for Create, Read, Update, Delete — four fundamental operations for managing data.
CRUD Operations with AJAX
CRUD stands for Create, Read, Update, Delete—four fundamental operations for managing data.
Create: Use POST to add new data.
Read: Use GET to retrieve data.
Update: Use PUT or PATCH to modify existing data.
Delete: Use DELETE to remove data.
Example of CRUD Operations with Fetch:
CORS(Cross-Origin Resource Sharing) is a security feature that restricts web pages from making requests to a different domain than the one that served the web page. To work with APIs across different domains, the server must enable CORS.
Promisessimplify the management of asynchronous operations in JavaScript. They provide a more readable way to handle AJAX requests compared to callbacks.
fetch('/api/posts')
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
Async/Awaitis syntactic sugar built on top of Promises, making asynchronous code easier to read and write.
async function fetchPosts() {
try {
const response = await fetch('/api/posts');
const data = await response.json();
console.log(data);
} catch (error) {
console.error('Error:', error);
}
} fetchPosts();
To handle multiple AJAX requests in sequence, use Promises or Async/Await to chain requests.
fetch('/api/user')
.then(response => response.json())
.then(user => fetch(/api/posts?userId=${user.id}))
.then(response => response.json())
.then(posts => console.log(posts))
.catch(error => console.error('Error:', error));
To build a real-world application, you need a backend API and a frontend interface. For this example, we’ll use a simple API to fetch weather data.
const apiKey = 'YOUR_API_KEY';
const city = 'London';
fetch(https://api.openweathermap.org/data/2.5/weather?q=${city}&appid=${apiKey})
.then(response => response.json())
.then(data => {
document.getElementById('weatherDisplay').innerHTML =
<h2>Weather in ${data.name}</h2>
<p>Temperature: ${(data.main.temp - 273.15).toFixed(2)}°C</p>
<p>Condition: ${data.weather[0].description}</p>
;
})
.catch(error => console.error('Error fetching weather data:', error));
Use JavaScript to create dynamic elements that update based on user input or server responses.
document.getElementById('searchButton').addEventListener('click', function() {
const city = document.getElementById('cityInput').value;
fetchWeatherData(city);
}); function fetchWeatherData(city) {
fetch(https://api.openweathermap.org/data/2.5/weather?q=${city}&appid=${apiKey})
.then(response => response.json())
.then(data => {
document.getElementById('weatherDisplay').innerHTML =
<h2>Weather in ${data.name}</h2>
<p>Temperature: ${(data.main.temp - 273.15).toFixed(2)}°C</p>
<p>Condition: ${data.weather[0].description}</p>
;
})
.catch(error => console.error('Error fetching weather data:', error));
}
Use HTML and CSS to format the data received from APIs. JavaScript allows you to manipulate the DOM and display the data dynamically.
DebouncingandThrottlingare techniques used to limit the rate at which a function is executed. This is especially useful when working with APIs to avoid unnecessary requests.
function debounce(func, delay) {
let timeout;
return function(...args) {
clearTimeout(timeout);
timeout = setTimeout(() => func.apply(this, args), delay);
};
} const fetchWeatherDebounced = debounce(fetchWeatherData, 300);
document.getElementById('cityInput').addEventListener('input', function() {
fetchWeatherDebounced(this.value);
});
Use JavaScript to manage the state of your AJAX requests and provide feedback to users, such as loading indicators or error messages.
function fetchWeatherData(city) {
const loader = document.getElementById('loader');
loader.style.display = 'block'; // Show loader fetch(`https://api.openweathermap.org/data/2.5/weather?q=${city}&appid=${apiKey}`) .then(response => response.json()) .then(data => { loader.style.display = 'none'; // Hide loader // Display weather data... }) .catch(error => { loader.style.display = 'none'; // Hide loader console.error('Error fetching weather data:', error); });
Copier après la connexion
}
To improve performance, cache API responses using JavaScript or a service worker. This reduces the number of requests sent to the server and speeds up the application.
const cache = new Map();function fetchWeatherData(city) {
if (cache.has(city)) {
displayWeatherData(cache.get(city)); // Use cached data
} else {
fetch(https://api.openweathermap.org/data/2.5/weather?q=${city}&appid=${apiKey})
.then(response => response.json())
.then(data => {
cache.set(city, data); // Cache the response
displayWeatherData(data);
})
.catch(error => console.error('Error fetching weather data:', error));
}
}
Use browser developer tools to inspect network requests, view responses, and debug JavaScript code:
Provide users with clear error messages and fallback options when AJAX requests fail.
fetch('https://api.example.com/data')
.then(response => response.json())
.then(data => {
// Display data...
})
.catch(error => {
console.error('Error fetching data:', error);
document.getElementById('errorMessage').innerText = 'Failed to load data. Please try again later.';
});
In this tutorial, you’ve learned how to use AJAX and APIs to build dynamic web applications. You explored the basics of AJAX, the Fetch API, interacting with RESTful APIs, and advanced techniques like error handling, optimization, and security.
As you continue learning, explore more advanced topics like:
By Peymaan Abedinpour | پیمان عابدین پور
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Comment apprendre le langage go à partir de 0 bases
Quels sont les logiciels de programmation du microcontrôleur ?
Comment acheter et vendre du Bitcoin en Chine
Comment transmettre une valeur au composant vue
Quelles sont les méthodes pour télécharger des vidéos depuis Douyin ?
Quelles sont les performances de php8 ?
Quelles sont les solutions de stockage Big Data ?
Pilote de carte son pour ordinateur portable HP
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
