DEV Community: Adhi sankar

Methods in Java

Adhi sankar — Sat, 26 Sep 2026 08:32:49 +0000

A method in Java is a block of code that performs a specific task. Methods help us reuse code, reduce repetition, and make programs easier to understand.

Basic Syntax

returnType methodName(parameters) {
    // code
}

Example

class Main {

    static void greet() {
        System.out.println("Hello Java!");
    }

    public static void main(String[] args) {
        greet();
    }
}

Output:

Hello Java!

Method with Parameters

A method can accept values called parameters.

static int add(int a, int b) {
    return a + b;
}

We can call it like this:

int result = add(10, 20);
System.out.println(result);

Output:

Here, a and b are parameters, while 10 and 20 are arguments.

Types of Methods

Methods can be commonly classified as:

No parameter and no return value
Parameter but no return value
No parameter but return value
Parameter and return value

Method Overloading

Java also supports method overloading, where multiple methods have the same name but different parameters.

static int add(int a, int b) {
    return a + b;
}

static int add(int a, int b, int c) {
    return a + b + c;
}

Why Use Methods?

Code reusability
Less code duplication
Better readability
Easier debugging
Breaks a large program into smaller tasks

Conclusion

Methods are one of the most important concepts in Java. By using methods, we can write clean, reusable, and organized code. Understanding parameters, return values, and method overloading is especially important for Java programming and interviews.

JDK in Java

Adhi sankar — Tue, 22 Sep 2026 11:54:01 +0000

Introduction

JDK stands for Java Development Kit. It is a software package used to develop, compile, debug, and run Java applications.

If you want to create a Java program, you need tools that can convert your Java source code into something the computer can execute. The JDK provides these tools.

For example, when we write:

class Main {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

the JDK provides the tools required to compile and run this program.

What is JDK?

JDK (Java Development Kit) is a collection of software tools required for Java application development.

It contains:

JRE (Java Runtime Environment)
JVM (Java Virtual Machine)
Java compiler
Debugging tools
Other development utilities

In simple words:

JDK = Tools needed to develop Java applications

Main Components of JDK

1. JDK

JDK is the complete development kit.

It is mainly used by Java developers to write and develop applications.

JDK
 ├── JRE
 │    └── JVM
 └── Development Tools

2. JRE

JRE stands for Java Runtime Environment.

It provides the environment required to run Java applications.

JRE
 └── JVM

JRE contains the JVM and Java libraries required for running Java programs.

3. JVM

JVM stands for Java Virtual Machine.

It is responsible for executing Java bytecode.

For example:

Java Code
    ↓
Compiler
    ↓
Bytecode (.class)
    ↓
JVM
    ↓
Program Output

The JVM helps Java achieve its famous feature:

Write Once, Run Anywhere

A Java program can run on different operating systems as long as a compatible JVM is available.

Java Compiler

One of the most important tools in the JDK is the Java compiler.

The Java compiler is called:

javac

Suppose we have a file:

Main.java

We can compile it using:

javac Main.java

This creates:

Main.class

The .class file contains Java bytecode.

We can then run it using:

java Main

JDK Compilation Process

The basic process is:

Main.java
    ↓
   javac
    ↓
Main.class
    ↓
   JVM
    ↓
Output

For example:

Step 1: Write Java code

class Main {
    public static void main(String[] args) {
        System.out.println("Hello Java");
    }
}

Save the file as:

Main.java

Step 2: Compile

javac Main.java

Step 3: Run

java Main

Output:

Hello Java

Important JDK Commands

javac

Used to compile Java source code.

javac Main.java

java

Used to run a Java application.

java Main

javadoc

Used to generate documentation from Java source code.

javadoc Main.java

jar

Used to create and manage Java archive files.

jar

jdb

Used for debugging Java applications.

JDK vs JRE vs JVM

JDK	JRE	JVM
Used for development	Used for running Java programs	Executes bytecode
Contains JRE	Contains JVM	Part of JRE
Contains development tools	Contains runtime libraries	Converts bytecode into machine-level instructions
Used mainly by developers	Used to run applications	Executes Java programs

The relationship can be remembered as:

JDK
 ↓
JRE
 ↓
JVM

Why Do We Need JDK?

JDK is needed when we want to develop Java applications.

For example, if you want to create:

Web applications
Desktop applications
Backend applications
Android-related Java projects
Enterprise applications
Java-based tools

you need a Java development environment.

The JDK provides the compiler and other tools required for development.

How to Check JDK Installation

After installing the JDK, open Command Prompt or Terminal and type:

java -version

You can also check the compiler:

javac -version

Example:

java version "21..."
javac 21...

The exact version depends on the JDK installed on your computer.

JDK Versions

Java has many versions, such as:

Java 8
Java 11
Java 17
Java 21
Java 25

Some Java versions are LTS (Long-Term Support) releases.

For learning Java, it is useful to understand that the JDK version determines which Java language features and tools are available.

Advantages of JDK

1. Complete Development Environment

JDK provides the tools needed to develop Java applications.

2. Platform Independent

Java bytecode can run on different platforms using a compatible JVM.

3. Development Tools

It provides tools such as:

javac
java
javadoc
jar
jdb

4. Supports Large Applications

Java and the JDK are widely used for developing large-scale applications.

5. Debugging and Documentation

JDK provides tools that help developers debug programs and create documentation.

Simple Real-Life Example

Think of JDK like a complete workshop for a mechanic.

JDK → Complete workshop
Compiler → Tool that prepares the program
JRE → Environment where the program can operate
JVM → Machine that executes the program

Therefore, if you want to build Java applications, you need the JDK.

Conclusion

JDK is an important part of Java development. It provides the compiler, runtime environment, JVM, libraries, and various development tools required to create Java applications.

The most important concept to remember is:

JDK → Development
JRE → Running
JVM → Execution

Understanding useState in React: A Beginner's Guide

Adhi sankar — Mon, 07 Sep 2026 10:55:21 +0000

When building React applications, we often need to store information that can change over time. For example, a counter can increase or decrease, an input field can contain text, or a button can show and hide content.

React provides a Hook called useState to handle this kind of changing data.

In this blog, let's understand useState with simple examples.

What is useState?

useState is a React Hook that allows a functional component to store and update data.

The basic syntax is:

const [value, setValue] = useState(initialValue);

Here:

value → current state value
setValue → function used to update the state
initialValue → starting value

For example:

const [count, setCount] = useState(0);

Initially, count is 0.

Creating a Simple Counter

Let's create a counter that increases when we click a button.

import { useState } from "react";

function App() {
  const [count, setCount] = useState(0);

  function increase() {
    setCount(count + 1);
  }

  return (
    <div>
      <h1>Count: {count}</h1>

      <button onClick={increase}>
        Increase
      </button>
    </div>
  );
}

export default App;

When the button is clicked:

setCount(count + 1);

React updates the state and renders the component again.

The result will be:

Count: 0
   ↓
Count: 1
   ↓
Count: 2
   ↓
Count: 3

Increase and Decrease

We can use the same state to create both Increase and Decrease buttons.

import { useState } from "react";

function App() {
  const [count, setCount] = useState(0);

  function increase() {
    setCount(count + 1);
  }

  function decrease() {
    setCount(count - 1);
  }

  function reset() {
    setCount(0);
  }

  return (
    <div>
      <h1>Count: {count}</h1>

      <button onClick={increase}>Increase</button>
      <button onClick={decrease}>Decrease</button>
      <button onClick={reset}>Reset</button>
    </div>
  );
}

export default App;

Now we have three operations:

setCount(count + 1); // Increase
setCount(count - 1); // Decrease
setCount(0);         // Reset

Why Can't We Use a Normal Variable?

A common beginner mistake is:

let count = 0;

function increase() {
  count++;
}

This doesn't work properly for React UI updates.

React doesn't automatically re-render the component when a normal variable changes.

Instead, we use:

const [count, setCount] = useState(0);

and update it using:

setCount(count + 1);

When the state changes, React knows that the component needs to render again.

useState with Input

useState is also commonly used with input fields.

import { useState } from "react";

function App() {
  const [name, setName] = useState("");

  return (
    <div>
      <input
        onChange={(e) => setName(e.target.value)}
      />

      <h2>Hello {name}</h2>
    </div>
  );
}

export default App;

If the user types:

Adhi

The UI displays:

Hello Adhi

Here:

setName(e.target.value);

updates the state with whatever the user types.

Important Rule

Don't directly modify state.

❌ Avoid:

count++;

❌ Avoid:

count = count + 1;

✅ Use:

setCount(count + 1);

The setter function tells React that the state has changed.

Multiple State Variables

A component can have more than one state.

const [name, setName] = useState("");
const [age, setAge] = useState(0);

For example:

function App() {
  const [name, setName] = useState("");
  const [age, setAge] = useState(0);

  return (
    <div>
      <input onChange={(e) => setName(e.target.value)} />

      <button onClick={() => setAge(age + 1)}>
        Increase Age
      </button>

      <h2>Name: {name}</h2>
      <h2>Age: {age}</h2>
    </div>
  );
}

Each state variable can be updated independently.

Functional State Updates

When the new state depends on the previous state, you can also write:

setCount(prevCount => prevCount + 1);

This is especially useful when multiple state updates happen close together.

For example:

function increase() {
  setCount(prevCount => prevCount + 1);
}

Common useState Examples

useState can be used for many things:

Counters
Form inputs
Login forms
Show/Hide elements
Dark mode
Todo lists
Shopping cart quantities
Selected items
Tabs
Modal windows

Conclusion

useState is one of the most important React Hooks for beginners.

The main idea is simple:

useState → Store data
setState → Update data
React → Re-render the UI

The basic syntax to remember is:

const [value, setValue] = useState(initialValue);

Once you understand useState, you'll have a strong foundation for learning other React concepts such as useEffect, props, forms, and component communication.

Prime Number Program Using Function in Python

Adhi sankar — Wed, 26 Aug 2026 16:08:36 +0000

A prime number is a number greater than 1 that has only two factors: 1 and itself.

Examples of prime numbers are 2, 3, 5, 7, 11, 13, 17, and 19.

In Python, we can use a function to check whether a number is prime.

Python Program

def is_prime(n):
    if n < 2:
        return False

    for i in range(2, n):
        if n % i == 0:
            return False

    return True


number = int(input("Enter a number: "))

if is_prime(number):
    print(number, "is a prime number")
else:
    print(number, "is not a prime number")

How It Works

1. Create a function

def is_prime(n):

The function is_prime() receives a number n.

2. Check numbers less than 2

if n < 2:
    return False

Numbers like 0 and 1 are not prime numbers.

3. Check for factors

for i in range(2, n):

The loop checks numbers from 2 up to n-1.

4. Use the modulo operator

if n % i == 0:
    return False

If n is exactly divisible by any number other than 1 and itself, it is not prime.

5. Return True

return True

If no factor is found, the number is prime.

Example Output

Enter a number: 17
17 is a prime number

Another example:

Enter a number: 20
20 is not a prime number

Conclusion

Using a function makes the prime number program simple, reusable, and easy to understand. The same is_prime() function can also be used when checking many numbers in a program.

How to Check a Palindrome in Python

Adhi sankar — Sun, 23 Aug 2026 08:20:52 +0000

A palindrome is a word, number, or sentence that reads the same forward and backward.

For example:

madam → madam
level → level
121 → 121
racecar → racecar

In this blog, we will learn how to check whether a word is a palindrome using Python.

Python Program

word = input("Enter a word: ")

reverse = word[::-1]

if word == reverse:
    print("It is a palindrome")
else:
    print("It is not a palindrome")

How Does the Program Work?

1. Get input from the user

word = input("Enter a word: ")

This asks the user to enter a word.

For example:

Enter a word: madam

2. Reverse the word

reverse = word[::-1]

[::-1] is used to reverse a string.

For example:

madam → madam
hello → olleh

3. Compare the original and reversed words

if word == reverse:

The program checks whether the original word and reversed word are the same.

If they are the same, it is a palindrome.

4. Print the result

print("It is a palindrome")

If the word is a palindrome, the program prints:

It is a palindrome

Otherwise:

It is not a palindrome

Example

Input

Enter a word: level

Output

It is a palindrome

Another example:

Input

Enter a word: python

Output

It is not a palindrome

Conclusion

Checking a palindrome is a simple and useful Python exercise. It helps beginners understand:

Strings
User input
String slicing
if-else conditions
Comparing values

How to Find Prime Numbers Using Python

Adhi sankar — Sun, 23 Aug 2026 08:18:34 +0000

Prime numbers are an important concept in programming and mathematics. In this blog, we will learn how to check whether a number is prime using a simple Python program.

What is a Prime Number?

A prime number is a number that has only two factors:

1
The number itself

For example:

2, 3, 5, 7, 11, 13, 17, 19

are prime numbers.

But 4 is not prime because it can be divided by 1, 2, and 4.

Python Program

def prime(n):
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

for n in range(10, 21):
    if prime(n):
        print(n)

How Does the Program Work?

1. Create a function

def prime(n):

This creates a function called prime() that takes a number n.

2. Check numbers from 2

for i in range(2, n):

The loop checks numbers starting from 2 up to n - 1.

3. Check divisibility

if n % i == 0:

The % operator gives the remainder.

If the remainder is 0, the number can be divided exactly by i.

So, the number is not prime.

4. Return False

return False

If a divisor is found, the function returns False.

5. Return True

return True

If no divisor is found, the number is prime, so the function returns True.

6. Check numbers from 10 to 20

for n in range(10, 21):

This checks every number from 10 to 20.

7. Print prime numbers

if prime(n):
    print(n)

If the number is prime, it will be printed.

Output

Conclusion

Finding prime numbers is a good beginner programming exercise. It helps us understand:

Functions
for loops
if conditions
The % operator
return statements

Finding Bugs in Software Testing: A Beginner's Guide

Adhi sankar — Wed, 19 Aug 2026 06:53:21 +0000

What Is a Bug in Software Testing?

When we use an application, we expect everything to work correctly. But sometimes, the application behaves differently from what we expect.

This problem is called a bug.

What is a Bug?

A bug is an error or defect in software that causes the application to produce an incorrect or unexpected result.

Simple Example

Imagine a login page:

Username: adhi
Password: 12345

You enter the correct username and password, but the application says "Invalid Password".

This is a bug because the application is not working as expected.

How Do Testers Find Bugs?

Software testers check an application by trying different scenarios.

For example:

Enter valid username and password.
Enter an incorrect password.
Leave the username empty.
Leave the password empty.
Enter special characters.
Try very long input.

If the application behaves incorrectly in any of these cases, the tester can report it as a bug.

Basic Bug Life Cycle

A bug usually goes through these stages:

New → Assigned → Open → Fixed → Retest → Closed

Sometimes, a bug can also be Reopened if the problem still exists after the developer fixes it.

Why Are Bugs Important?

Finding bugs early helps to:

Improve software quality
Provide a better user experience
Reduce development costs
Prevent serious problems after release

Conclusion

Bugs are a normal part of software development. The job of a tester is to find these problems, report them clearly, and make sure they are fixed.

How to Find Even Numbers in Python

Adhi sankar — Tue, 18 Aug 2026 00:40:15 +0000

If you're learning Python, finding even numbers is a simple and useful beginner exercise.

An even number is a number that can be divided by 2 without any remainder.

For example:

2, 4, 6, 8, 10

Using the `%` Operator

In Python, we can use the modulus (%) operator to check whether a number is even.

num = 10

if num % 2 == 0:
    print("Even number")
else:
    print("Odd number")

How does it work?

num % 2 gives the remainder after dividing the number by 2.

Remainder 0 → Even number
Remainder 1 → Odd number

For example:

10 % 2 = 0
7 % 2 = 1

Finding Even Numbers from a List

We can also find even numbers from a list using a for loop.

numbers = [1, 2, 3, 4, 5, 6, 7, 8]

for num in numbers:
    if num % 2 == 0:
        print(num)

Output

Conclusion

Finding even numbers is a simple Python problem, but it helps beginners understand important concepts like:

% operator
if-else
for loops
Lists

These basic concepts are useful for solving many programming problems.

Software Testing for Beginners: A Simple Guide to Getting Started

Adhi sankar — Tue, 18 Aug 2026 00:38:08 +0000

What Is Software Testing? 🧪

Software testing is the process of checking software to make sure it works correctly and does what it is supposed to do.

For example, when we use a login page, we can test:

Correct username and password
Wrong password
Empty username
Empty password
Forgot password option

The goal is to find bugs and problems before the software is used by customers.

Why Is Testing Important?

Testing helps developers and companies:

Find bugs
Improve software quality
Provide a better user experience
Prevent problems after release

Even a small bug can sometimes cause a big problem, so testing is an important part of software development.

Manual Testing

In manual testing, a tester checks the application manually without using automation scripts.

For example, a tester can open a website, enter different inputs, click buttons, and check whether the expected result appears.

Automation Testing

In automation testing, we use tools and programming to test software automatically.

Some popular tools are:

Selenium
Playwright
Cypress

Automation is useful when the same tests need to be performed many times.

Conclusion

Software testing is an important part of creating reliable software.

If you are a beginner, you can start with manual testing, then learn SQL, API testing, and automation testing.

PostgreSQL: A Beginner's Guide to Getting Started

Adhi sankar — Mon, 10 Aug 2026 09:55:07 +0000

If you're learning backend development, one database you should definitely know is PostgreSQL.

PostgreSQL is a powerful open-source relational database management system (RDBMS) that uses SQL to store, manage, and retrieve data.

What is PostgreSQL?

PostgreSQL is a relational database where data is stored in tables made up of rows and columns.

For example, an employee table might contain:

id	name	age
1	Adhi	21
2	Ravi	24
3	Kumar	22

Each row represents an employee, while each column represents a particular piece of information.

DBMS vs RDBMS

DBMS stands for Database Management System.

RDBMS stands for Relational Database Management System.

An RDBMS stores data in related tables and allows us to establish relationships between them.

PostgreSQL is an RDBMS.

Creating a Database

We can create a database using:

CREATE DATABASE company;

After creating it, we can connect to the database and create tables.

Creating a Table

CREATE TABLE employee (
    id INT,
    name VARCHAR(50),
    age INT
);

Here:

id stores the employee ID
name stores the employee name
age stores the employee's age

Inserting Data

To insert a row:

INSERT INTO employee
VALUES (1, 'Adhi', 21);

We can insert another employee:

INSERT INTO employee
VALUES (2, 'Ravi', 24);

Reading Data

To retrieve all employees:

SELECT * FROM employee;

To retrieve only the names:

SELECT name FROM employee;

Filtering Data

The WHERE clause is used to filter records.

SELECT * FROM employee
WHERE age = 21;

We can also use conditions such as:

SELECT * FROM employee
WHERE age > 21;

Updating Data

To change existing data:

UPDATE employee
SET name = 'Rahul'
WHERE id = 2;

Always be careful with UPDATE. Using it without a WHERE condition can change every row.

Deleting Data

To delete a particular employee:

DELETE FROM employee
WHERE id = 2;

To delete all rows while keeping the table:

DELETE FROM employee;

To delete the entire table:

DROP TABLE employee;

Altering a Table

We can add a new column using:

ALTER TABLE employee
ADD COLUMN salary INT;

We can remove a column using:

ALTER TABLE employee
DROP COLUMN salary;

We can rename a table:

ALTER TABLE employee
RENAME TO employees;

And rename a column:

ALTER TABLE employee
RENAME COLUMN name TO full_name;

Sorting Data

ORDER BY is used to sort results.

Ascending order:

SELECT * FROM employee
ORDER BY age ASC;

Descending order:

SELECT * FROM employee
ORDER BY age DESC;

Aggregate Functions

PostgreSQL provides useful functions for calculations.

Count

SELECT COUNT(*) FROM employee;

Average

SELECT AVG(age) FROM employee;

Maximum

SELECT MAX(age) FROM employee;

Minimum

SELECT MIN(age) FROM employee;

Sum

SELECT SUM(salary) FROM employee;

Important PostgreSQL Topics to Learn

After learning these basics, you should move on to:

Primary Keys
Foreign Keys
Constraints
Joins
GROUP BY
HAVING
Subqueries
CTEs
Indexes
Transactions
Views
PostgreSQL data types
JSON/JSONB
Query optimization

Conclusion

PostgreSQL is an important skill for backend and full-stack developers.

The best way to learn it isn't by memorizing commands. Create a small database, insert data, query it, update it, delete it, and practice different SQL problems.

Understanding Python `range()` with Real-Life Examples

Adhi sankar — Wed, 05 Aug 2026 11:27:55 +0000

When learning Python, one of the first concepts you'll encounter is the range() function. It is commonly used with loops to repeat tasks a specific number of times.

Instead of using random numbers, let's understand range() through simple real-life examples.

What is `range()`?

The range() function generates a sequence of numbers.

Syntax

range(start, stop, step)

start → The number where the sequence begins.
stop → The sequence ends before this number.
step → The amount by which the numbers increase or decrease.

Example 1: Assigning Roll Numbers

Imagine five students enter a classroom one after another.

First student → Roll Number 1
Second student → Roll Number 2
Third student → Roll Number 3
Fourth student → Roll Number 4
Fifth student → Roll Number 5

Code

for i in range(1, 6):
    print(i)

Output

Explanation

range(1, 6)

starts from 1 and stops before 6, so Python prints:

1 → 2 → 3 → 4 → 5

Example 2: Even Queue Positions

A coach asks students to stand only in even-numbered positions.

The first five even positions are:

2, 4, 6, 8, 10

Code

for a in range(2, 12, 2):
    print(a)

Output

Explanation

range(2, 12, 2)

Starts at 2
Stops before 12
Increases by 2 every time

Sequence:

2 → 4 → 6 → 8 → 10

Example 3: Lift Stops Every Third Floor

A newly constructed building has a lift that stops only at every third floor for safety reasons.

Starting from the ground floor, display the first five stops.

Code

for b in range(0, 15, 3):
    print(b)

Output

Explanation

range(0, 15, 3)

Starts from floor 0
Stops before 15
Moves 3 floors each time

Sequence:

0 → 3 → 6 → 9 → 12

Example 4: Rocket Countdown

A rocket launches with a countdown using only even numbers.

Code

for c in range(10, -1, -2):
    print(c)

Output

Explanation

range(10, -1, -2)

Starts at 10
Counts backward
Decreases by 2
Stops after printing 0

Sequence:

10 → 8 → 6 → 4 → 2 → 0

Understanding the Three Parameters

Parameter	Meaning	Example
Start	Where counting begins	`1`
Stop	Stops before this value	`6`
Step	Increment or decrement	`2` or `-2`

Example:

range(1, 6)

Produces:

1 2 3 4 5

Example:

range(10, -1, -2)

Produces:

10 8 6 4 2 0

Why Use `range()`?

The range() function makes loops simple and efficient.

It helps when you need to:

Assign serial numbers
Print even or odd numbers
Generate countdowns
Skip numbers with custom intervals
Repeat tasks multiple times

Final Thoughts

The range() function is one of the most useful tools in Python programming. Once you understand its three parameters—start, stop, and step—you can solve many looping problems with ease.

Using real-life examples like roll numbers, queue positions, lift stops, and rocket countdowns makes learning range() much more intuitive.

APIs in JavaScript: A Beginner's Guide

Adhi sankar — Tue, 04 Aug 2026 12:09:28 +0000

What is an API?

API stands for Application Programming Interface.

An API allows two applications to communicate with each other.

For example:

A weather app requests weather information.
A shopping website requests product details.
A movie app requests movie information.
A social media app requests user profiles.

Instead of storing all the data inside your application, you simply request it from an API.

How Does an API Work?

The communication process looks like this:

User
   │
   ▼
JavaScript Application
   │
   ▼
API Request
   │
   ▼
Server
   │
   ▼
JSON Response
   │
   ▼
Display Data on Web Page

What is Fetch API?

The Fetch API is a built-in JavaScript feature used to send HTTP requests and receive responses from a server.

Basic syntax:

fetch(url)
    .then(response => response.json())
    .then(data => {
        console.log(data);
    })
    .catch(error => {
        console.log(error);
    });

Understanding the Code

Step 1: Send a Request

fetch("https://fakestoreapi.com/products")

This sends a GET request to the API.

Step 2: Convert the Response into JSON

.then(response => response.json())

The server sends data in JSON format.

response.json() converts it into a JavaScript object.

Step 3: Use the Data

.then(data => {
    console.log(data);
})

Now you can display the data on your webpage.

Step 4: Handle Errors

.catch(error => {
    console.log(error);
})

If something goes wrong, the error is displayed in the console.

Complete Example

HTML

<button onclick="loadProducts()">
    Load Products
</button>

<div id="products"></div>

JavaScript

function loadProducts() {

    fetch("https://fakestoreapi.com/products")

    .then(response => response.json())

    .then(data => {

        let output = "";

        data.forEach(product => {

            output += `
                <div>
                    <h3>${product.title}</h3>
                    <img src="${product.image}" width="120">
                    <p>$${product.price}</p>
                </div>
            `;

        });

        document.getElementById("products").innerHTML = output;

    })

    .catch(error => {

        console.log(error);

    });

}

When you click the button, JavaScript fetches product data from the API and displays each product's title, image, and price.

Common HTTP Methods

Method	Purpose
GET	Retrieve data
POST	Create new data
PUT	Update existing data
DELETE	Remove data

The Fetch API supports all these methods.

Example of a POST request:

fetch("https://example.com/users", {
    method: "POST",
    headers: {
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        name: "John",
        age: 22
    })
});

Checking the Response Status

fetch("https://fakestoreapi.com/products")

.then(response => {

    if (!response.ok) {
        throw new Error("Request Failed");
    }

    return response.json();

})

.then(data => console.log(data))

.catch(error => console.log(error));

Checking response.ok helps ensure the request was successful before processing the data.

Advantages of Fetch API

Built into modern browsers
Easy to learn and use
Supports Promises
Works with JSON data
Supports asynchronous programming
Cleaner than older AJAX methods

Best Practices

Always use .catch() to handle errors.
Check response.ok before reading the response.
Keep API keys secure.
Avoid making unnecessary API requests.
Use meaningful variable names.
Display user-friendly error messages.

Real-World Uses of APIs in JavaScript

Weather applications
E-commerce websites
Movie search apps
News websites
Currency converters
Chat applications
Travel booking systems

Conclusion

The Fetch API makes it easy for JavaScript applications to communicate with servers and retrieve data. By understanding how to send requests, process JSON responses, and handle errors, you can build interactive and dynamic web applications.

If you're just starting with JavaScript, practice using free public APIs like Fake Store API or JSONPlaceholder. It's one of the best ways to improve your frontend development skills.