DEV Community: Akash Singh

A Cleaner Way to Access the Last Element of an Array in JavaScript

Akash Singh — Sun, 26 Jul 2026 15:47:14 +0000

Most JavaScript developers access the last element of an array like this:

const arr = [10, 20, 30, 40];

console.log(arr[arr.length - 1]); // 40

It works perfectly and is still a common approach.

However, modern JavaScript provides a cleaner alternative:

const arr = [10, 20, 30, 40];

console.log(arr.at(-1)); // 40

Why use `.at()`?

✅ Cleaner and easier to read.
✅ Supports negative indexing.
✅ No need to calculate length - 1.
✅ Great for accessing elements from the end of an array.

More examples

const arr = [10, 20, 30, 40];

console.log(arr.at(-1)); // 40
console.log(arr.at(-2)); // 30
console.log(arr.at(-3)); // 20

Instead of calculating indexes manually, you can directly access elements from the end of an array.

Final Thoughts

Both approaches are correct.

arr[arr.length - 1] is the classic and widely used approach.
arr.at(-1) is a modern, more expressive alternative that improves readability.

Small JavaScript features like this can make your code cleaner over time.

💬 **Do you use .at() in your projects, or do you still prefer arr[arr.length - 1]? Let me know in the comments!

Can You Predict the Output? 🤔 A JavaScript Equality Puzzle That Tricks Developers

Akash Singh — Tue, 21 Jul 2026 09:18:43 +0000

JavaScript's loose equality (==) can produce some surprising results because of type coercion. Here's a classic interview question that confuses even experienced developers.

If you think you know JavaScript, try answering this without running the code.

console.log([] == ![]);
🤔 What will be the output?
A. true
B. false
C. undefined
D. TypeError

Take a moment to guess before reading further.

✅ Answer

The output is:

true

Surprised?

Let's break it down step by step.

Step 1: Evaluate ![]

In JavaScript, every object (including an empty array) is truthy.

Boolean([]); // true

Therefore,

![] // false

Now the expression becomes:

[] == false
Step 2: Loose Equality (==)

The == operator performs type coercion.

Since one side is a boolean, JavaScript converts it to a number.

false // becomes 0

Now the comparison is:

[] == 0
Step 3: Convert the Array

When an array is compared with a primitive, JavaScript converts the array into a primitive value.

[].toString(); // ""

So the comparison becomes:

"" == 0
Step 4: Convert the String to a Number

An empty string converts to the number 0.

Number(""); // 0

Now JavaScript compares:

0 == 0

Which evaluates to:

true
🔄 Conversion Chain
[] == ![]

↓

![] → false

↓

[] == false

↓

false → 0

↓

[] == 0

↓

[] → ""

↓

"" → 0

↓

0 == 0

↓

true ✅
💡 Why Does This Happen?

The == operator follows JavaScript's Abstract Equality Comparison rules.

Instead of comparing values directly, JavaScript automatically converts operands into compatible types before making the comparison.

That's why many developers recommend using:

===

The strict equality operator (===) compares both value and type, avoiding unexpected type coercion.

⚡ Key Takeaways
[] is an object, and all objects are truthy.
![] evaluates to false.
false is converted to 0.
[] becomes an empty string ("").
"" converts to 0.
Finally, JavaScript compares 0 == 0, which is true.
🧩 Your Turn

Without running the code, what do you think this prints?

console.log([] + []);

Drop your answer in the comments before testing it.

If you enjoyed this puzzle, follow me for more JavaScript interview questions, tricky outputs, and deep dives into how JavaScript actually works.

Happy Coding! 🚀

How I Merged Two MongoDB Collections Using $unionWith

Akash Singh — Sat, 13 Jun 2026 06:04:16 +0000

How I Merged Two MongoDB Collections Using `$unionWith`

While working on a doctor listing feature, I encountered an issue where some doctors were missing from the All Doctors page.

After investigating the issue, I found that data was being fetched from two separate collections, and pagination was being applied independently. This resulted in inconsistent results and unnecessary complexity.

The Problem

I had two collections:

ReferralUser
user_managements

Fetching data separately caused:

Multiple API calls
Missing records
Inconsistent pagination
Additional frontend logic

The Solution

MongoDB's $unionWith aggregation stage allowed me to combine both collections into a single pipeline.


js
`db.ReferralUser.aggregate([
  {
    $unionWith: {
      coll: "user_managements"
    }
  }
]);`
---

Benefits
Reduced multiple API calls into one
Improved pagination consistency
Simplified frontend logic
Easier to maintain
Key Takeaways

When working with similar data across multiple collections, $unionWith can help simplify the API and provide more consistent results.

Thanks for reading! 🚀

DEV Community: Akash Singh

A Cleaner Way to Access the Last Element of an Array in JavaScript

Why use .at()?

More examples

Final Thoughts

Can You Predict the Output? 🤔 A JavaScript Equality Puzzle That Tricks Developers

How I Merged Two MongoDB Collections Using $unionWith

How I Merged Two MongoDB Collections Using $unionWith

The Problem

The Solution

Why use `.at()`?

How I Merged Two MongoDB Collections Using `$unionWith`