Explain the `async` and `defer` attributes for scripts in HTML5.
Jul 13, 2025 am 03:06 AMThe difference between async and defer is the execution timing of the script. async allows scripts to be downloaded in parallel and executed immediately after downloading, without guaranteeing the execution order; defer executes scripts in order after HTML parsing is completed. Both avoid blocking HTML parsing. Using async is suitable for standalone scripts such as analyzing code; defer is suitable for scenarios where you need to access the DOM or rely on other scripts.
When you're adding JavaScript to an HTML page, using the async
or defer
attributes can make a real difference in how your page loads and performs. These two attributes control how the browser handles script loading and execution, especially during the parsing of the HTML document.

Here's what they do in short:
-
async
makes the script load in parallel with HTML parsing and executes it as soon as it's downloaded — without waiting for the HTML parsing to finish. -
defer
also loads the script while HTML is being parsed, but it waits until the entire HTML document is parsed before running the script.
Let's go into more detail about when and why you'd use each one.

What happens without async
or defer
By default, when the browser encounters a <script></script>
tag (without any attribute), it stops parsing the HTML. It downloads and runs the script immediately. Only after the script finishes executing does the browser continue building the DOM.
This behavior can cause delays in rendering the page, especially if the script is large or take time to download. That's why async
and defer
were introduced — to avoid blocking the parser.

How async
works
The async
attribute tells the browser that the script doesn't depend on the rest of the page content or other scripts. So the browser can:
- Download the script in the background while it continues parsing HTML
- Run the script as soon as it finishes downloading
- Stop HTML parsing just long enough to execute the script
Because of this behavior, async
is best used for scripts that are completely independent — like analytics trackers or simple widgets that don't interact with the page content.
Example:
<script src="analytics.js" async></script>
Important notes:
- The order of execution isn't guaranteed for multiple
async
scripts - They run as soon as they're ready, not in the order they appear in the HTML
How defer
works
With defer
, the script also downloads in the background during HTML parsing. But instead of running right away, it waits until the entire HTML document has been parsed.
This means:
- HTML parsing continues uninterrupted
- Scripts are executed in the order they appear in the document
- Execution happens after the DOM is fully built but before the
DOMContentLoaded
event
This is ideal for scripts that need to access or manipulate the DOM, or rely on other deferred scripts.
Example:
<script src="main.js" defer></script>
Key points:
-
defer
preserves execution order - It ensures the DOM is ready when the script runs
- No need to manually wait for
DOMContentLoaded
inside the script
When to use which
Choosing between async
and defer
depends on what the script does and whether it relies on anything else.
Use async
if:
- The script doesn't depend on the DOM or other scripts
- You want it to run as soon as possible after download
- It's something like a tracking code or third-party widget
Use defer
if:
- The script needs to access or modify the DOM
- It relies on other scripts (especially those earlier in the page)
- You want to ensure execution happens in a specific order
If a script is small and critical, sometimes it's even better to inline it in a <script></script>
block rather than load it externally — but that's another topic.
A quick comparison summary
Feature | Regular Script | async
|
defer
|
---|---|---|---|
Blocks HTML parsing? | Yes | No | No |
Executes in order? | N/A | No | Yes |
Waits for HTML? | — | No | Yes |
Waits for other scripts? | — | No | Yes (in order) |
So, basically, pick async
when the script can run anytime, and defer
when it needs to wait for the page. Both help improve performance by avoiding render-blocking JavaScript — and that makes for a better user experience.
That's it. Not too complicated once you get the hang of it.
The above is the detailed content of Explain the `async` and `defer` attributes for scripts in HTML5.. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

When using HTML5SSE, the methods to deal with reconnection and errors include: 1. Understand the default reconnection mechanism. EventSource retrys 3 seconds after the connection is interrupted by default. You can customize the interval through the retry field; 2. Listen to the error event to deal with connection failure or parsing errors, distinguish error types and execute corresponding logic, such as network problems relying on automatic reconnection, server errors manually delay reconnection, and authentication failure refresh token; 3. Actively control the reconnection logic, such as manually closing and rebuilding the connection, setting the maximum number of retry times, combining navigator.onLine to judge network status to optimize the retry strategy. These measures can improve application stability and user experience.

HTML5, CSS and JavaScript should be efficiently combined with semantic tags, reasonable loading order and decoupling design. 1. Use HTML5 semantic tags, such as improving structural clarity and maintainability, which is conducive to SEO and barrier-free access; 2. CSS should be placed in, use external files and split by module to avoid inline styles and delayed loading problems; 3. JavaScript is recommended to be introduced in front, and use defer or async to load asynchronously to avoid blocking rendering; 4. Reduce strong dependence between the three, drive behavior through data-* attributes and class name control status, and improve collaboration efficiency through unified naming specifications. These methods can effectively optimize page performance and collaborate with teams.

Server-SentEvents (SSE) is a lightweight solution provided by HTML5 to push real-time updates to the browser. It realizes one-way communication through long HTTP connections, which is suitable for stock market, notifications and other scenarios. Create EventSource instance and listen for messages when using: consteventSource=newEventSource('/stream'); eventSource.onmessage=function(event){console.log('Received message:',event.data);}; The server needs to set Content-Type to text/event

Doctype is a statement that tells the browser which HTML standard to use to parse the page. Modern web pages only need to be written at the beginning of the HTML file. Its function is to ensure that the browser renders the page in standard mode rather than weird mode, and must be located on the first line, with no spaces or comments in front of it; there is only one correct way to write it, and it is not recommended to use old versions or other variants; other such as charset, viewport, etc. should be placed in part.

Using HTML5 semantic tags and Microdata can improve SEO because it helps search engines better understand page structure and content meaning. 1. Use HTML5 semantic tags such as,,,, and to clarify the function of page blocks, which helps search engines establish a more accurate page model; 2. Add Microdata structured data to mark specific content, such as article author, release date, product price, etc., so that search engines can identify information types and use them for display of rich media summary; 3. Pay attention to the correct use of tags to avoid confusion, avoid duplicate tags, test the effectiveness of structured data, regularly update to adapt to changes in schema.org, and combine with other SEO means to optimize for long-term.

To build standardized and clear HTML5 documents, the following best practices must be followed: 1. Use standard document type declarations; 2. Build a basic skeleton including three tags and pay attention to the character set, title and script location; 3. Use semantic tags such as , , to improve accessibility and SEO; 4. Reasonably nest the title levels to ensure that the structure is clear and there is only one per page. These steps help improve code quality, collaboration efficiency and user experience.

It is a block-level element, suitable for layout; it is an inline element, suitable for wrapping text content. 1. Exclusively occupy a line, width, height and margins can be set, which are often used in structural layout; 2. No line breaks, the size is determined by the content, and is suitable for local text styles or dynamic operations; 3. When choosing, it should be judged based on whether the content needs independent space; 4. It cannot be nested and is not suitable for layout; 5. Priority is given to the use of semantic labels to improve structural clarity and accessibility.

When using HTML5Geolocation API to obtain user location, you must first obtain user authorization, and request and explain the purpose at the right time; the basic method is navigator.geolocation.getCurrentPosition(), which contains successful callbacks, wrong callbacks and configuration parameters; common reasons for failure include permission denied, browser not supported, network problems, etc., alternative solutions and clear prompts should be provided. The specific suggestions are as follows: 1. Request permissions when the user operation is triggered, such as clicking the button; 2. Use enableHighAccuracy, timeout, maximumAge and other parameters to optimize the positioning effect; 3. Error handling should distinguish between different errors
