Learning TypeScript Type System Day 4

Day 01 of Learning TypeScript 🚀 Today I covered some core fundamentals of TypeScript, and it already feels like I’m writing cleaner and safer code. Here’s what I learned today 👇 🔹 1. Installation & Setup Installed TypeScript globally Created my first .ts file Used tsc to compile & run the code 🔹 2. Type Inference TypeScript can automatically detect types: let age = 20; // inferred as number This reduces boilerplate and prevents type errors. 🔹 3. Primitive Data Types number string boolean null undefined bigint symbol 🔹 4. Special Types any → flexible but unsafe unknown → safer than any void → used in function void clearly expresses that a function does something but returns nothing. never → for unreachable code 🔹 4. Why avoid any I also learned that any removes all type-checking. Basically, it turns TypeScript back into JavaScript. ❌ Avoid using any unless absolutely required. ✔ Prefer unknown for safer typing. Small takeaway: TypeScript gives structure and catches mistakes before you run the code. Even these basics already feel much more reliable than plain JS. #typescript #javascript #learninginpublic #webdevelopment #frontend

Day 47 of the #100DaysOfCodeChallenge Today I started learning TypeScript. Since most modern large-scale applications are moving towards TypeScript, I decided it’s important to understand it properly instead of only relying on JavaScript. Today I explored the fundamentals: What TypeScript is and why it is used How static typing helps catch errors before runtime Basic types like string, number, boolean, arrays, and objects Understanding interfaces and type safety How TypeScript improves code readability and maintainability One thing I realized is that TypeScript doesn't replace JavaScript — it actually enhances JavaScript by adding type safety and better structure, which becomes very useful when working on large or collaborative projects. Right now I’m just getting comfortable with the basics, but I know mastering TypeScript will help me write more reliable and scalable code in the future. 💡 Quote of the day: "The best developers are not the ones who write the most code, but the ones who understand their code the most." Step by step improving the developer toolkit 🚀 #100DaysOfCode #TypeScript #JavaScript #WebDevelopment #LearningJourney

📘 Day 03 of Learning TypeScript — 🚀 Today was all about diving deeper into TypeScript and understanding how TS makes JavaScript safer, cleaner, and smarter. Some major concepts clicked today—especially around type narrowing and type assertions. 🔥 What I Learned Today ✅ 1. Type Narrowing I understood how TypeScript becomes smart based on conditions: 🏹 typeof 🏹 instanceof 🏹 truthiness checks 🏹 switch-case narrowing This helps TS auto-detect whether a value is a string, number, or a specific object type. ✅ 2. Custom Type Guards ✅ 3. Discriminated Union Types Learnt how to create multiple object variations like Masala, Ginger, Elaichi Chai and use the type field for precise narrowing. ✅ 4. Type Assertions (as) Practiced: ✔ Converting any → specific type ✔ Using assertion with JSON.parse() ✔ DOM element type assertion like as HTMLInputElement ✅ 5. Safe Error Handling if (error instanceof Error) to safely access error details. 🧠 Key Takeaway TypeScript isn’t just about types — It’s about making JavaScript predictable, reliable, and professional. Let’s keep going! 💪 #TypeScript #LearningJourney #100DaysOfCode #WebDevelopment #JavaScript #React #DeveloperJourney

🚀 Day 07 of Learning TypeScript — Type Guards & Static Keyword Today I explored two important concepts in TypeScript that make code more robust and structured. 🔹 1. Type Guards Type Guards help TypeScript narrow down types so we can safely work with variables. They make sure we use the right operations on the right type. ✨ Example: function checkValue(value: string | number) { if (typeof value === "string") { console.log(value.toUpperCase()); } else { console.log(value.toFixed(2)); } } 📌 TypeScript understands the type based on conditions like: typeof instanceof 🔹 2. static Keyword in TypeScript The static keyword is used to define properties or methods that belong to the class itself, not to its instances. 📌 No need to create an object to use static methods! ⭐ Key Takeaways ✔ Type Guards make code safer and prevent runtime errors ✔ static helps organize utility methods inside classes ✔ TypeScript keeps improving code clarity and structure Learning step-by-step and enjoying the process 🚀 More concepts coming soon! #typescript #javascript #webdevelopment #learninginpublic #frontend #developers #codingjourney

🚀 Day 09 of Learning TypeScript — Utility Types & Namespaces Continuing my TypeScript journey, today I went deeper into Utility Types and explored a new concept: Namespaces. 🔹 1. Utility Types (Deep Dive) TypeScript provides powerful built-in utility types that help transform existing types efficiently. // Make all properties optional type PartialUser = Partial<User>; 📌 These utilities reduce code duplication and improve scalability. 🔹 2. Namespaces — Organizing Code Namespaces help in organizing code into logical groups, especially in large applications. ✨ Example: namespace UserUtils { export function greet(name: string) { return `Hello, ${name}`; } } console.log(UserUtils.greet("Rohit")); 📌 Useful for structuring code and avoiding naming conflicts. ⭐ Key Takeaways ✔ Utility types simplify type transformations ✔ Helps write cleaner and maintainable code ✔ Namespaces organize code logically ✔ TypeScript is not just typing — it’s structuring code better Learning step-by-step and building consistency 🚀 👉 Do you prefer modules or namespaces in TypeScript? #typescript #javascript #webdevelopment #learninginpublic #frontend #developers #codingjourney

🚀 Day 08 of Learning TypeScript — Generics & keyof Today I explored two powerful features in TypeScript that make code more flexible and type-safe. 🔹 1. Generics — Write reusable & flexible code Generics allow us to write functions/components that work with multiple types without losing type safety. ✨ Example:- function identity<T>(value: T): T { return value; } const result = identity<string>("Hello TypeScript"); 📌 Instead of fixing a type, we make it dynamic using <T>. 🔹 2. keyof Operator — Work with object keys safely keyof helps us get all the keys of an object as a type. ✨ Example:- type User = { name: string; age: number; }; function getValue(obj: User, key: keyof User) { return obj[key]; } 📌 Now only valid keys (name, age) are allowed → no runtime errors. ⭐ Key Takeaways ✔ Generics make code reusable and scalable ✔ keyof ensures safe access to object properties ✔ Together, they help write strongly typed and flexible logic Learning TypeScript step-by-step and loving how it improves code quality 🚀 👉 What’s your favorite TypeScript feature so far? #typescript #javascript #webdevelopment #learninginpublic #frontend #codingjourney #developers

Started noticing one thing in modern MERN projects — TypeScript is everywhere 👀💙 At first, JavaScript feels easy… Then bugs start appearing from “somewhere” 😅 That’s where TypeScript steps in — better code clarity, fewer surprises, and cleaner projects ✨💻 Still learning it step by step… but honestly, it feels worth it 🚀 #MERNStack #TypeScript #WebDevelopment #Learning #StudentDeveloper

🚀 Just dropped my first video in the TypeScript series! If you're starting with TypeScript or planning to level up from JavaScript, this is the perfect place to begin 👇 🎥 Watch here: https://lnkd.in/gkzhB-9a 📅 Day 1 — Setup + Basic Types In this video, I’ve broken down: ✔ What TypeScript actually is ✔ How to set it up from scratch ✔ Understanding tsconfig.json ✔ Core basics: string, number, boolean ✔ null & undefined (no confusion!) ✔ How to write typed functions 💡 My goal with this series is simple: Make TypeScript easy, practical, and beginner-friendly — not overwhelming. If you're serious about becoming a better developer, consistency > intensity. Start small, but start today. 📂 PPT + resources included in description of the video. Would love your feedback 🙌 And if you're learning TypeScript too, let’s connect! #TypeScript #WebDevelopment #Programming #JavaScript #Developers #CodingJourney #LearningInPublic

🚀 Dive into the world of TypeScript Mapped Types! 🌟 TypeScript, the handy buddy for developers, got even cooler with Mapped Types. 🛠️ These map-magicians let you create new types from existing ones, making code transformations a breeze. Imagine creating a "ReadOnlyPerson" type from a "Person" type – now your data is untouchable like mom's cookies! 🍪 But wait, there's more! You can remix keys, dance with conditions, and even throw in some conditional types for a wild type transformation party. 🎉 From crafting unchangeable types to whipping up utility types for easy coding, Mapped Types are the secret sauce behind the scenes. So, why stick to the basics when you can level up your type game with TypeScript Mapped Types? Embrace the magic and let your code sparkle! ✨ #TypeScript #MappedTypes #CodeMagic #DeveloperLife

🚀 Today I Learned: Type Narrowing in TypeScript! TypeScript continues to surprise me with how powerful (and smart) it is! Today, I explored Type Narrowing — a feature that helps TypeScript understand what type a variable holds at runtime, even when multiple types are possible. 🔍 What is Type Narrowing? When a variable has more than one possible type (like string | number), TypeScript uses checks to narrow it down and provide accurate IntelliSense & error checking. 🔧 Ways TypeScript Performs Type Narrowing: typeof checks instanceof checks Equality checks Truthiness checks Custom type predicates 🎯 Why It Matters? Type narrowing makes your code: ✔️ Safer ✔️ More predictable ✔️ Developer-friendly ✔️ Less prone to runtime errors Learning TypeScript step-by-step feels amazing, and type narrowing has definitely leveled up how I write logic in TS! More TypeScript concepts on the way… 🔥 #TypeScript #LearningJourney #WebDevelopment #Frontend #JavaScript #100DaysOfCode #DeveloperJourney