5 Common JavaScript Mistakes Beginners Make (And How to Fix Them)

sivasankarimuthu — Thu, 10 Sep 2026 12:12:48 +0000

5 Common JavaScript Mistakes

JavaScript is one of the easiest languages to start with, but it also has a few tricky parts that trip up beginners. Here are 5 common mistakes and how to avoid them.

1. Using `==` Instead of `===`:

Many beginners use ==to compare values, but this can cause unexpected bugs because == converts types before comparing, while === checks both value and type.

Example:

console.log(0 == "0"); // true (bad — different types treated as equal)
console.log(0 === "0"); // false (correct — strict comparison)

2.Confusing var, let, and const:

Beginners often use var everywhere out of habit, without realizing it behaves differently from let and const. var is function-scoped and can be redeclared, which often leads to bugs in loops and conditionals.

Example:

var x = 10;
var x = 20; // no error, silently overwritten

let y = 10;
let y = 20; // Error: cannot redeclare

3. Misusing async/await and Promises:

A common mistake is forgetting to use await, which causes your code to run before the data actually arrives.

Example:

Wrong method:
function getData() {
const data = fetch("/api/data"); // missing await
console.log(data); // logs a Promise, not the actual data
}

Correct method:
async function getData() {
const data = await fetch("/api/data");
const result = await data.json();
console.log(result);
}

4. Not Understanding Hoisting:

Beginners are often confused when a variable seems to exist before it's even declared. This happens because of hoisting — JavaScript moves variable and function declarations to the top of their scope before running the code.

Example:

console.log(a); // undefined (not an error!)
var a = 5;

console.log(b); // Error: Cannot access 'b' before initialization
let b = 5;

console.log(a); // undefined (not an error!)
var a = 5;

console.log(b); // Error: Cannot access 'b' before initialization
let b = 5;

5. Accidentally Mutating Arrays and Objects:

Beginners often modify arrays or objects directly, not realizing that in JavaScript, objects and arrays are copied by reference, not by value. This means changing a "copy" can accidentally change the original.

Example:

const original = [1, 2, 3];
const copy = original; // NOT a real copy — same reference
copy.push(4);

console.log(original); // [1, 2, 3, 4] — original got changed too!

To make a real copy, use the spread operator or array/object methods:

const properCopy = [...original]; // real copy
properCopy.push(5);

console.log(original); // [1, 2, 3, 4] — unaffected
console.log(properCopy); // [1, 2, 3, 4, 5]

Conclusion:

These 5 mistakes are extremely common when learning JavaScript, but once you understand why they happen, they're easy to avoid. Practicing with small examples like these will make your code more reliable and bug-free.

What is an API? (Explained Simply)

sivasankarimuthu — Tue, 08 Sep 2026 08:16:41 +0000

What is an API?

If you've ever used a weather app, ordered food online, or logged in with your Google account, you've already used an API — without even knowing it. Let's break down what an API actually is, in plain and simple words.

API = A Messenger Between Two Apps

API stands for Application Programming Interface. Think of it as a waiter in a restaurant.

You (the customer) don't go into the kitchen yourself.
You tell the waiter what you want.
The waiter takes your order to the kitchen, gets the food, and brings it back to you.

In technology, the API is that "waiter" — it takes a request from one app, sends it to another system, and brings back the response.

A Real Example

Let's say you're using a weather app on your phone:

You open the app and search "Chennai weather."
The app sends a request to a weather API (like a request to the "kitchen").
The API fetches the latest weather data from a server.
The API sends that data back to your app.
You see the temperature and forecast on your screen.

You never see this happening — but it happens in seconds, every time you check the weather.

Why APIs Matter

APIs let different apps and services "talk" to each other without needing to know how the other one works internally. This is why:

Websites can show Google Maps without building their own map system
Apps can let you "Login with Google" without storing your Google password
Online stores can accept payments through Razorpay/PayPal without building their own payment system
A Simple Code Example

Here's what calling a real API looks like in JavaScript:

js
fetch("https://api.weather.com/chennai")
.then(response => response.json())
.then(data => console.log(data.temperature));

This code sends a request to a weather API and prints the temperature it gets back — just like the waiter bringing your food.

Conclusion

APIs are everywhere in the apps we use daily, working silently in the background. Once you understand that an API is simply a messenger connecting two systems, a lot of modern technology starts to make more sense.

DEV Community: sivasankarimuthu

5 Common JavaScript Mistakes Beginners Make (And How to Fix Them)