DEV Community: mashayeakh islam

🚀 Type Alias in TypeScript: Why I Use Them Every Day (And How They Compare to Interfaces)

mashayeakh islam — Thu, 20 Nov 2025 06:20:06 +0000

If you’ve already dipped your toes into TypeScript, you’ve probably met that one feature everyone talks about but no one fully explains at the start.

🧩 What Is a Type Alias?

A type alias is basically giving a nickname to a type.
Instead of rewriting the same structure again and again, you wrap it inside a type and reuse it.

A basic explanation?

Think of it like giving your WiFi a name.
The internet was always there, but naming it “DragonSlayer-5G” makes life easier.

Here’s a simple example from my playground:

// type alias
type USER = {
  name: string;
  contactNo: string;
  address: {
    division: string;
    city: string;
  };
  gender: "male" | "female";
};

const user1: USER = {
  name: "Mashayeakh",
  contactNo: "01777",
  address: {
    division: "Dhaka",
    city: "Dhaka"
  },
  gender: "male"
};

console.log(user1);

😄 Why I Like Type Aliases

When I'm structuring data models, a type alias feels natural. It’s straightforward and doesn’t pretend to be anything else. It just bundles types together and says, “Bro, use me wherever you want.”

You can even reuse it across multiple variables:

const user2: USER = {
  name: "Emma",
  contactNo: "017988",
  address: {
    division: "UK",
    city: "UK"
  },
  gender: "female"
};

console.log(user2);

This alone saves you from rewriting properties all day.

🍕 Type Alias for Functions (Tasty Feature)

Types aren’t only for objects. You can name a function’s signature as well.

type AddFunc = (num1: number, num2: number) => number;

const add: AddFunc = (num1, num2) => {
  return num1 + num2;
};

console.log(add(2, 5));

_ This makes your functions consistent and self-documented.
It also prevents “creative” arguments like strings, booleans, or emotions entering your math functions._

⚔️ Intersection Types (Combining Multiple Types)

Sometimes you want to combine different structures.
Type alias handles that with the & operator.

Like merging two Marvel characters but without copyright issues.

type User = {
  name: string;
  age: number;
};

type Role = {
  role: "admin" | "user";
};

type UserWithRole = User & Role;

const user1: UserWithRole = {
  name: "MR.X",
  age: 100,
  role: "admin"
};

console.log(user1);

Here, UserWithRolebecomes a new super-type that contains everything.

🆚 Type vs Interface — The Battle That Never Ends

If you Google “type vs interface TypeScript”, you’ll find 500 different answers.
Some swear by interface. Others defend typelike it's their first-born child.

Let me explain it cleanly.

✔ Interfaces are designed specifically for object shapes
✔ Types are more flexible — they work with primitives, unions, tuples, functions, and objects too

Both can describe objects, but types can do much more.

Let’s compare both with the same example.

🧱 Using Interface

interface IUser {
  name: string;
  age: number;
}

interface IUserWithRole extends IUser {
  role: "admin" | "user";
}

const user3: IUserWithRole = {
  name: "MIP",
  age: 123,
  role: "user"
};

console.log(user3);

Interfaces shine when you need extension and structured modeling.
They support declaration merging, are extendable, and feel very OOP-friendly.

🔗 Using Type Alias

type User = {
  name: string;
  age: number;
};

type Role = {
  role: "admin" | "user";
};

type UserWithRole = User & Role;

Types don’t use extends, but the & operator does the same job.
The difference is more about preference and convenience.

🥊 So When Should You Use What?

Use type when:

You need unions (string | number)
You need intersections
You define primitives (type ID = string | number)
You define function signatures
You want one flexible tool for everything

Use interface when:

You are modeling objects heavily
You want declaration merging
You prefer OOP-style extensions
You want a consistent structure across your app

Both work. Both are valid.
TypeScript doesn't judge you. Your team might, though.

😄 A Tiny Joke Before You Go

TypeScript developers be like:

“I don’t have trust issues. I just don’t trust any.”

🎯 Final Thoughts

If you’re learning TypeScript, mastering typeand interfaceearly will make your life easier.
These features help you write safer code and help your future teammates avoid headaches.

This post is part of my TypeScript learning journey, and I hope it helps someone who’s just getting started.

If you're a beginner, keep exploring. If you're experienced, feel free to roast my examples in the comments.

Happy coding!

Written by Masayeakh full stack dev sharing his TypeScript journey.

🚀 4 TypeScript Concepts That Made Me Write Cleaner Code

mashayeakh islam — Tue, 28 Oct 2025 08:18:32 +0000

Hey everyone 👋,
I’m Masayeakh, a full stack dev from Bangladesh currently learning TypeScript to level up my JavaScript skills.

After diving deeper into TypeScript this week, I learned a few features that completely changed how I think about code — Union Types, Tuples, Enums, and Interfaces.
Let’s go through them one by one 👇

🔗 1. Union Types — When You Don’t Know What’s Coming

Sometimes you don’t know if a value will be a string or a number.
That’s where Union Types shine.

let score: number | string = 33;
score = "55";

TypeScript now lets score accept both numbers and strings — without losing type safety.

Here’s a more practical example 👇

type User = { name: string; email: string; id: number; };
type Admin = { adminName: string; email: string; id: number; };

let person: User | Admin = { name: "Masayeakh", email: "m@gmail.com", id: 101 };
person = { adminName: "Masayeakh", email: "m@admin.com", id: 101 };

🧠 Lesson:

Union types make your code flexible when multiple data types or structures are possible — like APIs, roles, or IDs.

🧱 2. Tuples — Arrays That Follow Strict Rules

Tuples define fixed length and data type order.

let user: [string, number] = ["Jhon", 22];

If you try to swap types or add another element, TypeScript will yell at you 😅

But you can even make them readonly:

type UserInfo = readonly [string, number];
const user1: UserInfo = ["Masayeakh", 25];

🧠 Lesson:

Use tuples when you need ordered, predictable data — like
[username, id],
[lat, long], etc.

🪑 3. Enums — Human-Readable Constant Values

Instead of using magic numbers or strings everywhere, enums make your code more readable.

enum SeatChoice {
  AISLE,
  MIDDLE,
  WINDOW,
}

Now you can write:

let mySeat: SeatChoice = SeatChoice.MIDDLE;

You can even customize them 👇

enum SeatChoice2 {
  AISLE = 10,
  MIDDLE = 20,
  WINDOW = 30,
}

🧠 Lesson:

Enums make constants easier to manage, especially for configurations or fixed categories.

💡 4. Interfaces — The Blueprint for Objects

Interfaces tell TypeScript what structure an object should follow.

interface User {
  name: string;
  age: number;
  isActive: boolean;
}

Now, any object claiming to be a Usermust match this shape.

You can even define functions inside:

interface MathOp {
  val1: number;
  val2: number;
  operation(): number;
}

let result: MathOp = {
  val1: 23,
  val2: 32,
  operation() {
    return this.val1 + this.val2;
  },
};

🧠 Lesson:

Interfaces make code scalable — especially when working on large applications or teams.

🎯 Final Thoughts
Each week I learn something that makes me respect TypeScript more.
This language doesn’t just help avoid bugs — it forces me to think clearly about structure, safety, and intent.

Next up, I’ll explore Generics and Type Inference — the real brain stretchers 🧠💪

If you’re also learning TypeScript, let’s connect and share progress!
Drop your profile or comment below 💬

Written by Masayeakh — full stack dev sharing his TypeScript journey.

[Boost]

mashayeakh islam — Mon, 27 Oct 2025 12:25:41 +0000

5 Things I Learned in My First Week of TypeScript

mashayeakh islam ・ Oct 27

#programming #typescript #fullstack #learninginpublic

5 Things I Learned in My First Week of TypeScript

mashayeakh islam — Mon, 27 Oct 2025 05:14:20 +0000

Hey everyone! I’m Masayeakh, a Full stack Dev from Bangladesh who’s learning TypeScript to level up my skills.

Last week, I started my TypeScript journey — and wow, it’s been an exciting ride so far! From type safety to cleaner code, I can already see why so many developers love it.

In this post, I’ll share 5 simple but powerful lessons I learned in my first week of TypeScript. If you’re starting out like me, this might help you avoid confusion and learn faster 🚀

💡 1. TypeScript Catches Errors Before You Run the Code

In JavaScript, many bugs show up only when you run your code.
But in TypeScript, errors appear while you’re writing.

let age: number = "25"; // ❌ Type error: Type 'string' is not assignable to type 'number'

> It’s like having a super strict but helpful teacher who doesn’t let you make silly mistakes.

💬 2. Defining Function Types Keeps Your Code Clean

You can define what type of data a function expects and what it returns.

function add(a: number, b: number): number {
  return a + b;
}

> If you accidentally return a string or forget a parameter, TypeScript immediately warns you.
It makes functions predictable — which is great for big projects.

🧱 3. Objects and Type Aliases Make Life Easier
Instead of writing object types again and again, you can use type aliases.

type User = {
  name: string;
  age: number;
  email?: string; // optional property; email will be added if used otherwise blank;
};

const user1: User = { name: "Masayeakh", age: 25 };

> This makes code look cleaner, especially when building apps with many components.

🔒 4. Readonly Properties Prevent Unwanted Changes
If you don’t want something to be modified, just make it readonly.

type Config = {
  readonly apiUrl: string;
};

const config: Config = { apiUrl: "https://api.example.com" };
config.apiUrl = "https://newurl.com"; // ❌ Error

> This is small but super useful in team projects where mistakes happen.

🔗 5. Union Types Are a Game-Changer
Union types let a variable hold more than one type.

function getId(id: number | string) {
  return id;
}

getId(123);
getId("abc");

> They’re great when your data can come in multiple forms (like user IDs or API responses).

🎯 Final Thoughts

My first week with TypeScript taught me one thing — type safety = peace of mind.
It doesn’t just catch bugs early; it helps me write more confident, organized code.

Next, I’ll dive into interfaces, generics, and TypeScript with React — can’t wait to share that journey too!

If you’re learning TypeScript as well, let’s connect and grow together 💬

🧠 About Me
I’m a Full Stack Developer learning AI-driven TypeScript, Next.js, and modern web technologies.**
I love building projects, sharing what I learn, and connecting with global devs.
Let’s grow together — both in code and life 🌍💻