Introduction to TypeScript and Its Benefits • TypeScript is a superset of JavaScript, adding static typing capabilities for better code quality. • It catches errors early during development, improving reliability and reducing bugs in applications. • Types enhance code readability and maintainability, making projects easier to understand and manage. • Use TypeScript for any modern application to gain strong typing and improved developer experience.

Key points: - TypeScript is JavaScript with types. - Static typing finds errors before runtime. - Improves code clarity and organization. - Boosts developer productivity and confidence. - Essential for large and complex projects.

Example: Imagine JavaScript: let name = 'Alice'; name = 123; // No error!. TypeScript: let name: string = 'Alice'; name = 123; // Error: Type 'number' is not assignable to type 'string'.

Basic Data Types (string, number, boolean, null, undefined) • These are fundamental types representing text, numerical values, truthiness, and absence of value. • Understanding them is crucial for writing predictable and error-free JavaScript code. • Assign values directly or declare variables with their specific type for clarity. • Use these types for simple data like names, ages, statuses, and optional parameters.

Key points: - string: for text. - number: for numerical values. - boolean: for true/false states. - null: intentional absence of any object value. - undefined: variable has not been assigned a value.

Example: typescript let userName: string = "Alice"; let userAge: number = 30; let isActive: boolean = true; let noValue: null = null; let notSet: undefined;

Type Inference and Explicit Type Annotations • Type inference lets TypeScript guess a variable's type based on its initial value. • Explicit annotations manually declare a variable's type, making intentions very clear. • TypeScript automatically infers string for let message = 'Hello';. • Use inference for simple cases and annotations for complex types or clarity.

Key points: - Type inference is automatic type guessing. - Explicit annotations provide direct type declarations. - Inference is concise for simple assignments. - Annotations improve readability for complex types. - Both are valid, choose for clarity and intent.

Example: typescript // Type Inference let inferredName = "Bob"; // TypeScript infers string

// Explicit Type Annotation let explicitAge: number = 25;

Arrays and Tuples • Arrays store ordered lists of items of the same type; tuples store fixed-size lists with specific types. • They provide structured ways to manage collections of data efficiently. • Arrays are declared with type[] or Array<type>; tuples use [type1, type2, ...]. • Use arrays for homogeneous lists (e.g., all numbers) and tuples for mixed, ordered data (e.g., user ID and name).

Key points: - Arrays hold elements of a single type. - Tuples hold elements of predefined types in order. - Arrays: type[] or Array<type>. - Tuples: [type1, type2]. - Choose based on data homogeneity and structure.

Example: typescript // Array of strings let names: string[] = ["Alice", "Bob"];

// Tuple: user ID (number) and name (string) let user: [number, string] = [1, "Alice"];

Working with 'any' and 'unknown' • 'any' disables type checking, treating a value as having any type; 'unknown' requires type checks before use. • They offer flexibility but come with risks; use them cautiously to maintain type safety. • 'any' allows any operation, while 'unknown' forces explicit type assertions or checks. • Use 'any' sparingly for migrating JavaScript or when truly dynamic typing is unavoidable; use 'unknown' for safer dynamic values.

Key points: - 'any': bypasses all type checking. - 'unknown': requires explicit type checking. - 'any' sacrifices type safety for flexibility. - 'unknown' promotes safer handling of dynamic data. - Use 'any' only when absolutely necessary; prefer 'unknown' for safer dynamic types.

Example: typescript let dynamicValue: any = "Hello"; dynamicValue = 123; // No error with 'any'

let unknownValue: unknown = "World"; // console.log(unknownValue.length); // Error: Object is of type 'unknown'. if (typeof unknownValue === "string") { console.log(unknownValue.toUpperCase()); // Safe type guard }

Quick quiz: 1. Which of the following best describes a primary benefit of using TypeScript over plain JavaScript for modern applications? 2. Consider the following TypeScript code: let message = 'Hello';. What is the inferred type of the message variable? 3. What is the main difference between an Array and a Tuple in TypeScript? 4. You have a function that might receive data of any type and you want to handle it safely, performing type checks before use. Which type annotation would be most appropriate for the input parameter? 5. What is a common pitfall when using the any type in TypeScript?