TypeScript Fundamentals: Types, Functions, Objects

Day 84 of #100DaysOfLinkedIn — Utility Types in TypeScript Today I learned about Utility Types, which help transform existing types without rewriting them. These built-in helpers make TypeScript cleaner, DRY, and more maintainable, especially in large codebases. What I learned today: • What utility types are and why they exist • Using Partial to make properties optional • Using Pick to select specific properties • Using Omit to exclude properties • Other useful utilities like Readonly and Required • Real-world use cases in APIs and forms Utility types save time and reduce bugs by reusing and reshaping types. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #100DaysOfCode #CodingJourney

Day 78 of #100DaysOfLinkedIn — Function Overloads in TypeScript Today I learned how function overloads work in TypeScript and why they’re important for writing type-safe and flexible APIs. Function overloads allow us to define multiple function signatures for the same function, while keeping a single implementation. What I learned today: • What function overloads are and why they’re used • Writing multiple call signatures for one function • How TypeScript selects the correct overload • Difference between overload signatures & implementation • Making functions safer without using any This is very useful when building utility functions, libraries, and reusable APIs. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #100DaysOfCode #CodingJourney

Day 81 of #100DaysOfLinkedIn — Enums & Literal Types in TypeScript Today I learned about Enums and Literal Types in TypeScript, which help restrict values and make code more predictable and type-safe. These features are extremely useful when working with fixed sets of values like roles, statuses, directions, or modes. What I learned today: • How enum works in TypeScript • Difference between numeric and string enums • How literal types restrict exact values • Using union literals instead of enums • When to prefer enums vs literal types This topic helped me write safer code with fewer bugs by preventing invalid values. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #100DaysOfCode #CodingJourney

Day 76 of #100DaysOfLinkedIn — Functions, Return Types & void in TypeScript Today I focused on functions in TypeScript and how type safety makes them more reliable than plain JavaScript. Functions are the backbone of any application, and TypeScript helps ensure they behave exactly as expected. What I learned today: • Typing function parameters • Defining explicit return types • Understanding void return type • Preventing incorrect return values • Writing safer and predictable functions This makes code self-documented, easier to debug, and more scalable in large projects. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #100DaysOfCode #CodingJourney

✨ Why every developer should take TypeScript seriously! I used to think TypeScript was just “JavaScript with extra syntax”. Turns out — it’s more like JavaScript with fewer regrets. Type safety, better readability, fewer runtime surprises, and much cleaner collaboration in real projects. Especially once codebases grow, TS just makes sense. I’ve started documenting my TypeScript learnings with small examples and notes here 👇 🔗 https://lnkd.in/eSd6YYqA Slowly building strong fundamentals — one module at a time. 🙂 #TypeScript #JavaScript #WebDevelopment #LearningInPublic #SoftwareEngineering

Day 80 of #100DaysOfLinkedIn — Type Aliases vs Interfaces in TypeScript Today I learned the difference between Type Aliases and Interfaces, two core TypeScript features that look similar but are used differently in real-world projects. Understanding when to use type and when to use interface is important for writing clean, scalable TypeScript code. What I learned today: • Both type and interface define object shapes • interface is extendable and great for object contracts • type is more flexible (unions, intersections, primitives) • Interfaces support declaration merging • Best practices for choosing between them This topic cleared a lot of confusion and helped me write more intentional TypeScript code. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #100DaysOfCode #CodingJourney

Day 73 of #100DaysOfLinkedIn — Primitive Types & Special Types in TypeScript Today I explored primitive types and some special types that make TypeScript powerful and safe when used correctly. Understanding these types helps avoid unexpected bugs and improves code reliability. What I learned today: • Primitive types: string, number, boolean, null, undefined • Why any should be avoided in real projects • How unknown is safer than any • When never is used in functions • Difference between null and undefined These concepts are essential for writing type-safe and scalable TypeScript code. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #CodingJourney

Day 72 of #100DaysOfLinkedIn — Variables, Type Annotations & Type Inference in TypeScript Today I learned how TypeScript handles variables and how it understands types using annotations and inference. This topic is the foundation of everything in TypeScript — if this is clear, the rest becomes much easier. What I learned today: • How to declare variables with explicit types • Difference between type annotation and type inference • When to let TypeScript infer types automatically • Why avoiding any is important • How TypeScript prevents invalid reassignments Understanding this helps write clean, safe, and predictable code. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #CodingJourney

Day 83 of #100DaysOfLinkedIn — Generics in TypeScript (Functions & Interfaces) Today I learned about Generics, one of the most powerful features of TypeScript. Generics allow us to write reusable, flexible, and type-safe code without losing type information. What I learned today: • What generics are and why they’re used • Creating generic functions • Using generics with interfaces • How generics preserve type safety • Real-world use cases of generics This topic is heavily used in libraries, frameworks, APIs, and React code, so mastering it is a big step forward. #TypeScript #JavaScript #WebDevelopment #FrontendDevelopment #MERNStack #100DaysOfLinkedIn #100DaysOfCode #CodingJourney

📌 Something I learned recently TypeScript isn’t about writing more code. It’s about writing code with more confidence. I used to think adding types was just extra work that slowed me down. But over time, I realized it actually does the opposite. ✨ It catches mistakes early ✨ It makes refactoring less intimidating ✨ And it helps future-me (and teammates) understand decisions faster The biggest lesson? You don’t have to go all-in from day one. Even adding types gradually changes how you think about your code and that mindset shift is where the real value is. #TypeScript #JavaScript #DeveloperLife #SoftwareDevelopment