Complete Guide to Synchronous and Asynchronous in JavaScript

What Is Synchronous in JavaScript?

In Synchronous JavaScript, code executes sequentially, running one task at a time. Each operation must complete before the next begins, ensuring predictable flow and easier debugging.

Synchronous execution can block the main thread during long-running tasks, potentially causing UI freezes or delays in applications that require responsiveness.

Examples for Synchronous in JavaScript

Now, let’s look at a simple example to see it in action:

Code Example:

console.log("Step 1"); // executes first
console.log("Step 2"); // executes after Step 1
console.log("Step 3"); // executes after Step 2

In synchronous execution, each task runs one after another. The main thread completes the current function before moving to the next, blocking further execution until the current task finishes, even if it involves waiting for an external resource.

Synchronous Node.js Methods Example

When learning about synchronous and asynchronous in JavaScript, it’s important to see how blocking operations work. In Node.js, synchronous methods stop further execution until the task completes, making them easier to understand but less efficient for I/O-heavy tasks.

Code Implementation:

let fs = require("fs")
console.log("Starting read operation synchronously")
let data = fs.readFileSync("./somefile.txt", { encoding: "utf8" })
console.log("File Content:", data)
console.log("Finished read operation synchronously")

Code Walkthrough:

• require("fs"): Loads the fs module, executes, returns its contents, and pops off the stack.
• console.log("Starting read operation synchronously"): Logs the starting message to the terminal.
• fs.readFileSync(...): Performs a blocking file read, waits until the file is fully read, then returns the content.
• console.log("File Content:", data): Logs the file content to the terminal.
• console.log("Finished read operation synchronously"): Logs the finished message to the terminal.

Synchronous Callback Example

When learning about synchronous and asynchronous in JavaScript, it’s important to understand that not all callbacks are asynchronous. Synchronous callbacks execute immediately and block the function until they finish, helping illustrate how execution flows in a single-threaded environment.

Code Implementation:

function solve(a, b, callback) {
  let result = a + b
  callback(result) //block other operations in function till callback finishes executing
  console.log("Solve operation finished, solution obtained")
}
function callback(result) {
  let finalResult = 2 * result
  console.log(finalResult)
}
solve(2, 3, callback)")

Code Walkthrough:

• solve(2, 3, callback): Calls the solve function with arguments 2, 3, and the callback function.
• let result = a + b: Adds a and b, stores the value in result.
• callback(result): Calls the callback function immediately with result and blocks further execution in solve until it finishes.
• let finalResult = 2 * result: Inside callback, multiplies result by 2 and stores it in finalResult.
• console.log(finalResult): Logs the calculated finalResult to the console.
• console.log("Solve operation finished, solution obtained"): After the callback finishes, it logs the completion message and finishes solve.

What Is Asynchronous in JavaScript?

In asynchronous JavaScript, code is scheduled to run later, often after the synchronous parts of your script have executed and the main thread is free.

Tasks don’t complete strictly in the order they appear; they are non-blocking and allow other operations to continue while waiting for results. Asynchronous programming is useful for tasks that can be slow, like I/O operations or network requests. You start a task, move on to the next, and handle the result later using callbacks, promises, or async/await.

Examples of Asynchronous in JavaScript

As you’ve learned, asynchronous JavaScript allows tasks to run later without blocking the main thread. This is often used for operations like I/O, network requests, or timers, letting other code execute while waiting for results.

Code Example:

console.log("Start")
setTimeout(() => {
  console.log("Async task done")
}, 2000)
console.log("End")

Here, console.log("End") runs before the setTimeout callback because setTimeout is non-blocking.

Note: The core ECMAScript language itself doesn’t provide asynchronous features. Functions like setTimeout, fetch, or fs.readFile come from the runtime environment, Web APIs in browsers and Libuv in Node.js. Without these, JavaScript executes all code synchronously, one line at a time.

The following examples will help you see how asynchronous behavior works:

Asynchronous Node.js Example

When learning about asynchronous in JavaScript, it’s important to understand how non-blocking operations work. In Node.js, asynchronous methods allow the main thread to continue executing other tasks while waiting for I/O operations to complete.

This demonstrates the efficiency of synchronous and asynchronous in JavaScript for handling I/O-heavy tasks without blocking the main thread.

Code Implementation:

let fs = require("fs")
console.log("Started reading file asynchronously")
fs.readFile("./somefile.txt", "utf8", (error, data) => {
  if (error) {
    console.log(error)
  } else {
    console.log("File Content:", data)
  }
})
console.log("Ended")

Code Walkthrough:

• require("fs"): Loads the fs module, executes, returns its contents, and pops off the stack.
• console.log("Started reading file asynchronously"): Logs the starting message to the terminal.
• fs.readFile(...): Performs a non-blocking file read, delegates the task to Libuv, and registers the callback. Execution continues without waiting.
• console.log("Ended"): Logs immediately after initiating the asynchronous read.
• Callback in fs.readFile(...): Once the file is read, the callback is placed in the event queue and executed by the event loop, logging the file content to the terminal.

Promise API Example

A JavaScript promise represents the future value of an asynchronous operation. It acts as a placeholder for a result that will be available later. A promise has three states: pending, fulfilled (success), and rejected (failure).

Promises are commonly used for asynchronous tasks that take time to complete, helping manage code in a non-blocking way.

Code Implementation:

let fs = require("fs")
function makePromise() {
  return new Promise((resolve, reject) => {
    fs.readFile("./promises.txt", "utf-8", (err, data) => {
      if (err) {
        reject(err)
      } else {
        resolve(data)
      }
    })
  })
}
function onSuccess(data) {
  console.log("Data successfully read:", data)
}
function onError(err) {
  console.log("Following error found:", err)
}
makePromise().then(onSuccess).catch(onError)

Code Walkthrough:

• makePromise(): Wraps fs.readFile in a promise to handle asynchronous file reading.
• fs.readFile(...): Non-blocking file read; calls resolve if successful or reject if there’s an error.
• .then(onSuccess): Executes when the promise is fulfilled, logging the file content.
• .catch(onError): Executes when the promise is rejected, logging the error.

Converting to async/await

The .then/.catch syntax used to handle the success (fulfilled) and failure (rejected) states of a promise can be converted into async/await with a try-catch for error handling. This approach is often preferred when you have multiple asynchronous operations, as it makes the code easier to read and maintain.

Using .then/.catch:

function mainReceiver() {
  makePromise().then(onSuccess).catch(onError)
}
mainReceiver()

Using async/await:

async function mainReceiver() {
  try {
    let data = await makePromise()
    console.log("data already logged")
  } catch (error) {
    console.log("Error already logged")
  }
}
mainReceiver()

Code Walkthrough:

• await makePromise(): Pauses execution within the async function until the promise resolves or rejects.
• try-catch: Handles both fulfilled (success) and rejected (error) states of the promise in a clean, readable way.
• console.log("data already logged"): Executes if the promise is fulfilled.
• console.log("Error already logged"): Executes if the promise is rejected.

Dealing with synchronous and asynchronous behavior in JavaScript can be tricky. Different browsers may handle async operations like timers, fetch calls, or DOM updates inconsistently, making it hard to predict behavior. Nested callbacks or mixed sync/async patterns can also create complex flows that are difficult to debug and maintain.

A practical solution is to use a cloud-based testing platform. It provides consistent environments across browsers and OSes, allowing you to reliably test both synchronous and asynchronous behavior, while offering real-time logging and monitoring to visualize the order and timing of actions.

One such platform is LambdaTest, which allows you to test synchronous and asynchronous JavaScript behavior across a wide range of browsers and operating systems without worrying about local setup or infrastructure.

Handling Synchronous and Asynchronous in JavaScript Across Browsers

With LambdaTest, you can simulate user interactions like clicks, typing, and navigation to observe how both immediate (synchronous) and delayed (asynchronous) actions execute in real time.

LambdaTest is a GenAI-native test execution platform that allows you to perform manual and JavaScript automation testing at scale across 3000+ browsers and OS combinations.

For example, automate a polynomial evaluator by injecting data synchronously for instant results, asynchronously for delayed updates, while LambdaTest ensures that your synchronous and asynchronous JavaScript executes correctly across all targeted browsers, enabling precise automation and effective debugging in JavaScript.

In your scenarios, sync or async behavior depends on browser response and automated actions, not Selenium’s async/await.

You’ll automate two scenarios:

• Automating a Polynomial Evaluator Webpage Synchronously: Executes tasks step-by-step on the webpage without waiting for other operations.
• Injecting Data Asynchronously into a Local Webpage: Sends data in the background, allowing other scripts to continue running concurrently.

Project Prerequisites:

• Verify Node.js installation: Ensure Node.js is installed; check version with node -v or install latest version.
• Create a project folder: Set up a new folder and open it in your preferred code editor for project setup.
• Initialize npm project: Run npm init -y to generate a package.json file in your project folder.
• Install dependencies: Add essential packages using npm install selenium-webdriver dotenv for Selenium automation and environment management.
• Install HTTP server: Add a dev dependency with npm install http-server --save-dev to serve local files.
• Add server script in package.json: Include "server": "http-server -p 8080" under scripts to run the HTTP server easily.
• Run the server: Execute npm run server to start the local HTTP server whenever needed.

Project Structure Setup:

• LambdaTest Credentials: Set your LambdaTest Username and Access Key as environment variables from Account Settings.
• Download LambdaTest Tunnel (LT): Download the OS-compatible LT binary from the LambdaTest tunnel downloads page.
• Run LambdaTest Tunnel: Start the tunnel using ./LT --user <your_username> --key <your_access_key>.
• Get Capabilities: Use Automation Capabilities Generator to configure OS, browser, and version for your LambdaTest tests.

Once you are done with your project setup, in the root of your project folder, add the following files:

• .env: Store your LambdaTest credentials securely.
• .gitignore: Prevent the .env file from being pushed to GitHub.
• syncauto.js: Contains synchronous automation scripts.
• asyncauto.js and asyncauto1.test.js: Contain asynchronous automation scripts.
• index.html and style.css: Local webpage used for testing with LambdaTest Tunnel.

Automating Synchronous JavaScript at Scale

This test validates synchronous data injection in a polynomial evaluator. Inputs are processed instantly, and results are verified in real time across browsers with LambdaTest.

Test Scenario:

• Automating Coefficient Entry and Polynomial Evaluation.: Executes tasks step-by-step on the webpage without waiting for other operations.
• Validating that the Result Appears Instantly on the Page: Sends data in the background, allowing other scripts to continue running concurrently.

Code Implementation:

require("dotenv").config()
const { Builder, By } = require("selenium-webdriver")
let assert = require("node:assert")


const USERNAME = process.env.LT_USERNAME
const ACCESS_KEY = process.env.LT_ACCESS_KEY
  browserName: "chrome",
  browserVersion: "latest",
  "LT:Options": {
    platformName: "Windows 10",
    build: "Sync Data Injection",
    name: "LambdaTest Synchronous Test",
    selenium_version: "4.0.0",
  },
}
async function syncAutomate() {
  const driver = await new Builder()
    .usingServer(GRID_URL)
    .withCapabilities(capabilities)
    .build()
  try {
    await driver.get("https://stevepurpose.github.io/polynomial-Evaluate/")
    let coEntry = await driver.findElement(By.id("toPush"))
    let sendEntry = await driver.findElement(By.id("but1"))
    let varEntry = await driver.findElement(By.id("toSub"))
    let displayInfo = await driver.findElement(By.id("to_read"))
    let takeSum = await driver.findElement(By.id("but3"))
    let showEntry = await driver.findElement(By.id("but2"))
    await coEntry.sendKeys(2); await sendEntry.click()
    await coEntry.sendKeys(0); await sendEntry.click()
    await coEntry.sendKeys(1); await sendEntry.click()
    await coEntry.sendKeys(0); await sendEntry.click()
    await coEntry.sendKeys(1); await sendEntry.click()
    await varEntry.sendKeys(2); await takeSum.click()
    let info = await displayInfo.getText()
    console.log(info)
    assert(info.includes("37"), "Expected result to contain 37")
    await showEntry.click()
    let info2 = await displayInfo.getText()
    console.log(info2)
  } finally {
    await driver.quit()
  }
}
syncAutomate()

Code Walkthrough:

• Import modules: dotenv, selenium-webdriver, and assert are imported.
• Load credentials: Reads LambdaTest username and access key from .env.
• Grid URL setup: Constructs the Selenium Grid URL with credentials.
• Define capabilities: Specifies Chrome browser, Windows 10, build name, and Selenium version.
• Build driver instance: Creates a Selenium session on the LambdaTest cloud.
• Navigate to webpage: Opens the polynomial evaluator site.
• Locate DOM elements: Finds input fields and buttons (toPush, but1, toSub, etc.).
• Enter polynomial values: Inputs coefficients and substitution value step by step.
• Click evaluate: Runs the calculation by clicking takeSum.
• Verify output: Fetches result text and asserts it contains 37.
• Show coefficients: Clicks showEntry and displays stored coefficients.
• Quit driver: Closes the Selenium browser session.

In your console, you will see:

Viewing Results on LambdaTest:

On the LambdaTest Automation Dashboard, your build will appear under Builds. The name matches the build field in LT:Options of your script ("Sync Data Injection" in this example).

Click on it to view the test output, and you can playback the recording on the bottom right of the resulting page.

Automating Asynchronous JavaScript at Scale

Asynchronous automation on LambdaTest involves testing behaviors that don’t happen immediately. they’re delayed, event-driven, or data-driven.

Test Scenario:

• Automating Both Sync and Async Injections: Executes tasks step-by-step on the webpage without waiting for other operations.
• Checking How Non-blocking Behavior Works in Real Execution Order: Sends data in the background, allowing other scripts to continue running concurrently.

Code Implementation:

Using LambdaTest Tunnel to give LambdaTest access to your local webpage.

require("dotenv").config()
const { Builder, By } = require("selenium-webdriver")

const USERNAME = process.env.LT_USERNAME
const ACCESS_KEY = process.env.LT_ACCESS_KEY

const capabilities = {
browserName: "Chrome",
browserVersion: "latest",
platformName: "Windows 10",
"LT:Options": {
build: "Async Data Injection",
name: "Non-blocking SendKeys Logging",
selenium_version: "4.0.0",
tunnel: true,
},
}

async function asyncAutomate() {
const driver = await new Builder()
.usingServer(GRID_URL)
.withCapabilities(capabilities)
.build()

try {
await driver.get("[http://localhost:8080/index.html](http://localhost:8080/index.html)")
const syncPara = await driver.findElement(By.id("sync"))
const asyncPara = await driver.findElement(By.id("async"))
// Async injection after delay
setTimeout(async () => {
  await asyncPara.sendKeys("Asynchronous injection after delay")
  const asyncText = await asyncPara.getText()
  console.log("Async Paragraph Text:", asyncText)
}, 5000)


// Synchronous injection runs immediately
await syncPara.sendKeys("Synchronous injection completed")
const syncText = await syncPara.getText()
console.log("Sync Paragraph Text:", syncText)
// Wait to capture async log
await driver.sleep(7000)


} finally {
await driver.quit()
}
}
asyncAutomate()

Code Walkthrough:

• Import modules: Use dotenv to load credentials and selenium-webdriver for automation.
• Authenticate with LambdaTest: Build the Grid URL using your username and access key.
• Set capabilities: Choose Chrome on Windows 10, enable tunnel: true, and name the build "Async Data Injection".
• Start WebDriver session: Spin up a browser session on LambdaTest Grid with these capabilities.
• Open your local page: Load http://localhost:8080/index.html.
• Locate elements: Grab the #sync and #async paragraph elements.
• Async injection: Use setTimeout to delay injecting text into the async paragraph by 5 seconds. This won’t block other actions.
• Sync injection: Immediately inject text into the sync paragraph.
• Verify order: The sync injection logs right away; the async injection logs only after the delay.
• Wait & clean up: Use driver.sleep(7000) so the async action completes before quitting.

Run the test by following the below commands:

• Start your HTTP Server:

npm run server

• Execute your Script:

node asyncauto.js

In your console, you will see:

Viewing Results on LambdaTest:

On the LambdaTest Automation Dashboard, your build will appear under Builds. The name matches the build field in LT:Options of your script ("Async Data Injection" in this example).

Click on it to view the test output, and you can playback the recording on the bottom right of the resulting page, like we did for the synchronous case above.

To get started, follow this support documentation on JavaScript with Selenium to run your first JavaScript test on LambdaTest.

What Are the Core Differences Between Synchronous and Asynchronous in JavaScript?

Synchronous and Asynchronous in JavaScript define how tasks are executed in the runtime. Synchronous code runs sequentially, blocking the main thread until each task completes, while asynchronous code allows tasks to run independently, enabling non-blocking execution and better performance for I/O-heavy operations.

How To Choose Between Synchronous and Asynchronous JavaScript?

Select synchronous JavaScript for straightforward, immediate tasks, and asynchronous for operations needing concurrency, external calls, or non-blocking execution.

• Complexity of the Task: Use asynchronous JavaScript for complex operations that need high performance and scalability. For simple, linear tasks, synchronous JavaScript is sufficient.
• Time Intensiveness: Long-running or time-consuming tasks can block the main thread. Asynchronous JavaScript prevents freezing, while synchronous JavaScript is suitable for quick operations.
• External Resources: For APIs, databases, or file system interactions, asynchronous methods like async/await are ideal. For tasks handled entirely by the JavaScript engine, synchronous execution works fine.

Common Mistakes in Synchronous and Asynchronous in JavaScript

When working with synchronous and asynchronous in JavaScript, certain mistakes often lead to bugs or unpredictable behavior.

Understanding these common pitfalls helps you write more reliable code.

Unpredictable Functions

Writing functions that behave synchronously under some conditions and asynchronously under others. For example, inconsistentRead calls the callback synchronously if the data exists in cache, but asynchronously if it doesn’t. This can confuse callers and cause unpredictable behavior.

Solution:

Make the function consistently asynchronous using process.nextTick().

let fs = require("fs")
const cache = new Map()

function consistentRead(filename, cb) {
  if (cache.has(filename)) {
    // Always call callback asynchronously
    process.nextTick(() => cb(null, cache.get(filename)))
  } else {
    fs.readFile(filename, "utf8", (err, data) => {
      if (err) return cb(err)
      cache.set(filename, data)
      cb(null, data)
    })
  }
}

Nested Callbacks

Callbacks nested within each other (“pyramid of doom”) make code unreadable and hard to debug.

Solution:

Use Promises for readability.

function pMaker1() { return new Promise((resolve, reject) => { /*...*/ }) }
function pMaker2() { return new Promise((resolve, reject) => { /*...*/ }) }
function pMaker3() { return new Promise((resolve, reject) => { /*...*/ }) }
pMaker1().then(onSuccess1).then(onSuccess2).then(onSuccess3).catch(onReject)

Unhandled Errors

Asynchronous operations fail (throw or reject) without a handler, causing unhandled errors.

Solution:

Handle errors in Promises using .then/.catch:

doSomething()
  .then(result => console.log(result))
  .catch(err => console.log(err))

Besides these, developers often encounter other common JavaScript errors that make debugging challenging.

Even with flawless front-end code, certain functionalities may fail, especially during cross-browser compatibility testing. Understanding these pitfalls helps prevent unexpected behavior and improve code reliability.

Best Practices for Writing Synchronous and Asynchronous in JavaScript

Certain considerations need to be made when we think of writing asynchronous code with JavaScript; you can see some of them below:

• Use Promises for Dependent asyncOoperations: When multiple asynchronous tasks rely on previous results, use promises instead of nested callbacks. This avoids deeply nested “callback hell” and keeps your synchronous and asynchronous JavaScript flow clear.
• Prefer async/await Over .then() Chaining: Using async/await simplifies the handling of asynchronous code, making it look more like synchronous code. It improves readability, reduces complexity, and helps with easier error handling using try-catch.
• Avoid Callbacks in Synchronous Functions: If you use a heavy callback in a function that is otherwise synchronous, it can block the main thread and degrade application performance. Keep synchronous and asynchronous logic separate.
• Keep Patterns Consistent: Mixing synchronous and asynchronous behavior within the same function can lead to unpredictable results and subtle bugs. Always ensure that a function behaves consistently, either fully synchronous or fully asynchronous.
• Leverage JavaScript Testing Frameworks: Using reliable JavaScript testing frameworksAnchor helps validate that your asynchronous code behaves as expected across different scenarios and browsers, ensuring robust and predictable outcomes.

Conclusion

Understanding synchronous and asynchronous JavaScript is crucial for building efficient applications. Start with callbacks, master promises, and then use async/await for the most readable and maintainable code.