Forem: Shivam Yadav

URL Parameters vs Query Strings in Express.js Explained from Scratch

Shivam Yadav — Fri, 01 May 2026 10:18:38 +0000

hey reader hii

today we are i mean to say u and me are going to talk about URL Parameters vs Query Strings in Express.js

yaaa yaaa its boring but let me make it intresting for u

first lets start from starting

everyone know about Tim Berners-Lee creator of URL , HTML and HTTP

he created this thing mostly to share document easily to any one

but we are going to focus on URL

why did he create URL ?

so the problem was how will we identify the document in this www or internet world

so he end up making a unique string (yes a basic developer thinking)

let decode how the first URL looks like

http://info.cern.ch/hypertext/WWW/TheProject.html

yes yes this is how it look like it is messy but everything is messy at first gradually it will get clean that what history sayy

okay okay let come back to the main topic

so in this URL

http://
this act as a protocol
tell system to use this protocol to communicate with this system
info.cern.ch
this is host
/hypertext/WWW/TheProject.html
this is path

so if u see this carefully u can see that this kinda a looking like a file system path

why ? because developer are familiar with this strcuture

so he did not made something new he just reused a familiar structure

but till now this URL is not having the params and query

Where query strings came from ?

with development the static website get converted into a dynamic website

DB gets involve, search systems came in

dynamic content was needed, people want condition baised data

That’s where query strings appeared

so there are many parameter in an url like path , query , hash (#) ,etc

we are going to focus on path which is params and another is query

so lets start with params

so this how it look in url

/users/123/posts/456

This is not random. It follows a hierarchical structure

/resource/identifier

Where did this structure come from?

this was designed directly from file system (Unix)

/home/shivam/file.txt

so basically it means

Go inside:

users
user 123
posts
post 456

General structure pattern

Basic form:

/collection/:id

Nested form:

/collection/:id/subcollection/:subId

How Express understands this

When you write:

app.get('/users/:id', (req, res) => {
  console.log(req.params);
});

Internally Express converts it to:

/users/([^/]+)

it means match after any things comes after users/
and till the next /

BTW one more thing express does not see the :id it see what is comming next after the users/ and till the next /

so :id is only showing as a wrapper code to identify it in a code so the developer can use the value in his code

how to use in express

so if first thing u have to do is to pass the name of the params so that in your code u can use it for accessing it

it look like this

/user/:id

so if u want to access it u can use

let id = req.params.id

Request:

/users/123

Extracted:

req.params = { id: "123" }

Multiple params structure

app.get('/users/:userId/posts/:postId', ...)

Request:

/users/123/posts/456

Output:

{
  userId: "123",
  postId: "456"
}

how lets talk about query

so the first AIM of query is to show data to user depending on condition

A query string is the part of a URL that comes after ? and is made of key=value pairs

this is how it looks like

/search?q=express&sort=latest&page=2

? starts the query string
& separates parameters
= assigns value to a key

{
  q: "express",
  sort: "latest",
  page: "2"
}

Original purpose

“Provide additional data to the resource without changing its identity.”

That’s why

/users/123 means the user which is identity

/users?age=20 means filtered list which is instruction

if u look closely u can the query parameter is inspired by SQL COMMAND

example

SELECT * FROM users WHERE age = 20

Query string became the web version of that

/users?age=20

4. Full structure

General format

?key=value&key2=value&key3=value

Important rules

1. every one need starting point so as query so it becames ?

/users?age=20

2. there can be multiple query parameter so we use &

/users?age=20&active=true

3. keys should be unique

/users?age=20&age=30

Allowed but it can create ambiguity

one of the most important point

Everything is text

?age=20

comes as

"20"

not number

How query parsing works internally

Step by step

Split after ?

age=20&active=true

Split by &

["age=20", "active=true"]

Split by =

age becomes 20
active becomes true

Create object

{
  age: "20",
  active: "true"
}

In Express.js

so in params u first have to declare the params but not in this

it will directly given into the req.query so access it from there

app.get('/users', (req, res) => {
  console.log(req.query);
});

Request

/users?age=20&active=true

Output

{
  age: "20",
  active: "true"
}

Important detail

Express uses parsers like

querystring which is basic
qs which is advanced

Advanced query formats

Arrays

/products?category=electronics&category=books

/products?category[]=electronics&category[]=books

Parsed

{
  category: ["electronics", "books"]
}

Nested objects

/user?filter[name]=shivam&filter[age]=20

Parsed

{
  filter: {
    name: "shivam",
    age: "20"
  }
}

Boolean or numbers

?active=true

Still string

"true"

You must convert

const active = req.query.active === 'true';

Real-world use cases

Search

/search?q=nodejs

Filtering

/products?price=low&brand=apple

Pagination

/posts?page=2&limit=10

Sorting

/posts?sort=latest

Feature toggles

/dashboard?darkMode=true

14. Internal philosophy

Query params follow this principle

“Same resource, different representation”

Example

/products?sort=price
/products?sort=rating

Same resource but different view depending on how you request it

15. Final mental model

Burn this

Query means how you want the data

Example

/users/123?include=posts&limit=5

/users/123 means what resource you are targeting

?include=posts&limit=5 means how you want that data to be returned

Final closure

so if u look at everything from starting to now

you will realize that nothing in URL design is random

everything is built on simple thinking

first identify the resource clearly using path

then modify or filter the data using query

params give you the exact thing you want

query helps you control how that thing should behave

this separation is the reason why APIs today are clean predictable and scalable

if u mix them randomly then your API will work but it will not be understandable and not maintainable

and that is the difference between just making something work and actually designing it properly

so next time when you design an API do not just write routes

think what is the resource and how it should be accessed

that is where real backend engineering starts

What Arranged Marriage Taught Me About JavaScript Promises

Shivam Yadav — Sun, 01 Mar 2026 08:42:21 +0000

Promises, Rishtas, Aur Thoda Sa Intezaar

Har Indian ghar mein ek phase aata hai.

Shaam ka time.
Mummy chai bana rahi hoti hain.
TV pe daily soap chal raha hota hai.

Aur beech mein casually ek line aati hai

“Beta… Sharma ji ka phone aaya tha.”

Bas.

Background music change.

Aapko samajh aa jaata hai.

Shaadi season officially shuru ho chuka hai.

Riya bhi ussi phase mein thi.

Job stable.
Salary theek.
Life sorted.

Par ghar walon ke hisaab se—

“Ab settle ho jao.”

Aur yahin se shuru hoti hai Promises ki kahani.

Promise Kya Hota Hai?

Promise matlab

“Abhi answer nahi milega.
Par milega.
Ya toh haan mein milega.
Ya seedha mana.”

Beech mein koi confusion nahi.

Jaise rishta.

Ya pakka.
Ya cancel.

JavaScript ne is waiting ko naam diya Promise.

Promise.all() “Sabki Haan Zaroori Hai”

Riya ka pehla rishta aaya.

Ladka achha tha.
Salary impressive thi.
Family decent thi.

Par Indian shaadi emotional nahi hoti.

System hota hai.

Checklist hoti hai.

Riya ko ladka pasand?
Mummy ko family pasand?
Papa ko job pasand?
Kundli match?

Sab green tick chahiye.

Ek bhi red cross?

Game over.

Yeh hai Promise.all().

Sab promises successful honge tabhi result milega.

Code

const riya = Promise.resolve("Riya agreed");
const parents = Promise.resolve("Parents agreed");
const horoscope = Promise.resolve("Horoscope matched");

Promise.all([riya, parents, horoscope])
  .then(() => console.log("Shaadi Pakki "))
  .catch(() => console.log("Rishta Toot Gaya "));

Agar ek bhi reject ho jaye…

Sab khatam.

Promise.allSettled() — “Mujhe Sach Batao”

Do teen rishton ke baad Riya badal gayi.

Ab woh toot’ti nahi thi.

Bas bolti thi

“Thik hai. Batao feedback kya hai.”

Ek ne mana kiya.
Ek ne horoscope issue bola.
Ek ne haan bola.

Pehle rejection insult lagta tha.

Ab woh sirf data tha.

Yeh hai Promise.allSettled().

Yeh kehta hai—

Main sabka result launga.
Jo pass hua woh bhi.
Jo fail hua woh bhi.

Code

const boy1 = Promise.resolve("Good Family");
const boy2 = Promise.reject("Horoscope Issue");
const boy3 = Promise.resolve("Nice Nature");

Promise.allSettled([boy1, boy2, boy3])
  .then(result => console.log(result));

Output:

[
 { status: 'fulfilled', value: 'Good Family' },
 { status: 'rejected', reason: 'Horoscope Issue' },
 { status: 'fulfilled', value: 'Nice Nature' }
]

Maturity is when rejection becomes information.

Promise.race() “Jo Pehle Haan Karega”

Ab ghar wale impatient ho gaye.

Dadi ne declare kar diya—

“Jo pehle haan karega, wahi final.”

Do families baat kar rahi thi.

Delhi wale soch rahe the.
Mumbai wale ready ho gaye.

Decision ho gaya.

Yeh hai Promise.race().

Jo pehle settle hua
Wahi result.

Code

const delhi = new Promise(resolve =>
  setTimeout(() => resolve("Delhi Ready"), 2000)
);

const mumbai = new Promise(resolve =>
  setTimeout(() => resolve("Mumbai Ready"), 1000)
);

Promise.race([delhi, mumbai])
  .then(result => console.log(result));

Speed bhi ek decision hoti hai.

Promise.any() “Bas Ek Haan Kaafi Hai”

Phir ek phase aaya.

Jab Riya ne decide kiya

“Mujhe perfect nahi chahiye.”

“Bas ek insaan chahiye jo mujhe choose kare.”

Paanch ne mana kar diya.

Ek ne haan bola.

Aur us ek haan ne
sab purane mana ko irrelevant bana diya.

Yeh hai Promise.any().

Code

const p1 = Promise.reject("Rejected 1");
const p2 = Promise.reject("Rejected 2");
const p3 = Promise.resolve("He Said Yes ❤️");

Promise.any([p1, p2, p3])
  .then(result => console.log(result))
  .catch(() => console.log("Sabne Mana Kar Diya"));

One success is enough.

Promise.resolve() “Instant Haan”

Kabhi kabhi cheezein simple hoti hain.

Milte hi vibe match.

No drama.

Seedha

“Let’s do this.”

Yeh hota hai Promise.resolve().

Code Example

Promise.resolve("Rishta Pakka ")
  .then(result => console.log(result));

Output:

Rishta Pakka

Immediate success. No waiting.

Promise.reject() “Seedha Mana”

Kabhi kabhi message aata hai

“Sorry. Not interested.”

Bas.

Koi explanation nahi.

Yeh hota hai Promise.reject().

Code Example

Promise.reject("Rishta Cancelled ")
  .catch(error => console.log(error));

Output:

Rishta Cancelled

Immediate rejection.

The 1% Realization

Zindagi synchronous nahi hoti.

Har cheez time leti hai.

Rishtas.
Career.
Dreams.
Replies.
Results.

Aur har jagah wahi patterns milte hain—

Sabka approval → Promise.all()
Full report → Promise.allSettled()
Jo pehle aaye → Promise.race()
Bas ek chance → Promise.any()

Programming sirf syntax nahi hai.

It’s life converted into logic.

Aur jab tum Promises samajh jaate ho…

Tum wait karna seekh jaate ho.

Kyuki intezaar bhi system ka part hai.

Aur jo intezaar samajh gaya…

Woh asynchronous se kabhi nahi darega.