• tsconfig.json is the configuration file used by the TypeScript compiler.
• It defines compiler options, file inclusions, output directory, and more.
• Using tsconfig.json standardizes builds and improves project scalability.

• Install @types/node along with TypeScript in your Node.js project.
• Then set up your tsconfig.json to include Node-specific configurations.
• This enables full IntelliSense and type checking for Node modules and APIs.

• TypeScript can automatically infer types based on variable assignment.
• For example, let score = 100; is inferred as a number without explicit annotation.
• It reduces boilerplate while still providing type safety.

• TypeScript is a superset of JavaScript that adds optional static typing, interfaces, and advanced tooling.
• It helps developers catch errors early during development rather than at runtime.
• Using TypeScript improves code maintainability, readability, and scalability in large frontend applications.

TypeScript supports default parameter values just like JavaScript.

Example: function greet(name: string = "Guest") sets "Guest" as the default.

This helps simplify function calls when parameters are optional.

• Decorators are functions prefixed with @ and can be applied to classes, methods, or properties.
• They allow meta-programming and are often used in frameworks like Angular.
• Enable experimentalDecorators in your tsconfig.json to use them.

• The never type represents values that should never occur.
• It’s used for functions that throw errors or contain infinite loops.
• It ensures that unreachable code is properly marked during type checking.

• TypeScript supports public, private, and protected access modifiers in classes.
• These control how and where class members can be accessed.
• For example, private methods are only accessible within the class itself.

• Type aliases allow you to create a custom name for any type using the type keyword.
• For example, type ID = string | number; creates a reusable type.
• They help simplify complex types and improve code readability.

• Tuple types allow you to define arrays with fixed sizes and types for each index.
• For example, let user: [string, number] = ["Alice", 25]; defines a tuple.
• They are useful when dealing with data of mixed types in a fixed structure.

• Install vue-class-component, vue-property-decorator, and @vue/cli-plugin-typescript.
• Rename components to .ts or .vue with TypeScript blocks.
• Vue with TypeScript gives better tooling, autocompletion, and type safety.

• With --strictNullChecks enabled, TypeScript treats null and undefined as separate types.
• You must explicitly allow them using union types like string | null.
• This helps prevent runtime errors from accessing properties on null values.

• Use a ? symbol in your TypeScript interfaces to mark properties as optional.
• Example: interface Car { brand: string; model?: string; } means model is optional.
• This gives flexibility while still enforcing type checks for required fields.

• Install typescript, @types/react, and @types/react-dom using npm.
• Then rename your files to .tsx to support JSX with TypeScript.
• This setup enables strong typing for props, state, and component functions.

• You can declare variables using let, const, or var, with optional type annotations.
• For example, let name: string = "John"; ensures the variable can only be a string.Type annotations help prevent bugs by enforcing the expected type.

• Use union types like string | null to declare variables that can be null.
• You can also use optional chaining (?.) and nullish coalescing (??) to handle them.
• This avoids errors from accessing properties on null or undefined objects.

• Enums let you define a set of named constants, improving code readability and reducing magic strings.
• You can use enum Color { Red, Green, Blue } to represent color states.
• They are useful in frontend development for managing application states or types.

• The keyof operator returns a union of the keys of a given type.
• For example, keyof Person returns "name" | "age" for a Person type.
• It’s often used with generics and mapped types for flexible utility functions.

• Install ts-loader and add it to your Webpack config under module.rules.
• Also, ensure your tsconfig.json is properly configured for module output.
• This allows you to bundle and compile TypeScript code seamlessly.

• Mapped types transform properties of an existing type into a new type.
• Example: type Readonly<T> = { readonly [P in keyof T]: T[P]; } makes all fields readonly.
• They are useful for building utility types and advanced abstractions.

• Use the tsc command in the terminal to compile .ts files into .js files.
• You can also use a configuration file (tsconfig.json) for larger projects.
• The TypeScript compiler supports incremental builds for better performance.

• You can install TypeScript globally using npm install -g typescript.
  • For local development, use npm install --save-dev typescript inside your project directory.
  • This ensures your project always uses the correct version of the TypeScript compiler.

• Generics allow you to write reusable functions, classes, or interfaces that work with multiple types.
• They provide type safety while retaining flexibility.
• For example, function identity<T>(arg: T): T returns a value of the same type that it receives.

• JavaScript is dynamically typed, while TypeScript introduces static typing and advanced features like interfaces and enums.
• TypeScript code must be compiled into JavaScript before running in browsers.
• The added features make code more predictable and reduce runtime errors.

• Interfaces define contracts in your code by specifying the structure of an object.
• They ensure objects meet specific requirements like having required properties or methods.
• TypeScript interfaces improve code clarity and enable powerful tooling like autocompletion.