TypeScript - chunhualiao/public-docs GitHub Wiki

TypeScript is a programming language developed by Microsoft that extends JavaScript by adding static types. It’s a superset of JavaScript, meaning all valid JavaScript code is also valid TypeScript code, but TypeScript introduces optional type annotations and other features to enhance code quality and maintainability, especially in large-scale applications.

1. Static Typing:

   • Developers can define types for variables, function parameters, and return values (e.g., number, string, boolean, or custom types).
   • Types are checked at compile time, catching errors like type mismatches before the code runs.
   • Example:

     let age: number = 30;
     let name: string = "Alice";
     // Error: Type 'string' is not assignable to type 'number'
     // age = "thirty";

2. Interfaces and Type Aliases:

   • TypeScript allows defining custom types using interface or type to describe object shapes, function signatures, or complex data structures.
   • Example:

     interface User {
       id: number;
       name: string;
     }
     let user: User = { id: 1, name: "Bob" };

3. Advanced Type Features:

   • Supports features like union types (string | number), intersection types, generics, and type inference.
   • Example with generics:

     function identity<T>(value: T): T {
       return value;
     }
     let num = identity<number>(42); // Type-safe generic function

4. Tooling and IDE Support:

   • TypeScript provides rich tooling, including autocompletion, type checking, and refactoring support in editors like VS Code.
   • It helps catch errors early through compile-time checks.

5. Compiles to JavaScript:

   • TypeScript code is transpiled to plain JavaScript using the TypeScript compiler (tsc), making it compatible with any JavaScript environment (browsers, Node.js, etc.).
   • Developers can target specific ECMAScript versions (e.g., ES5, ES6) during compilation.

6. Enums and Other Features:

   • TypeScript adds features like enum for defining sets of named constants and access modifiers (public, private, protected) for classes.
   • Example:

     enum Color {
       Red,
       Green,
       Blue
     }
     let c: Color = Color.Green;

• Error Detection: Catches type-related errors during development, reducing runtime bugs.
• Scalability: Improves maintainability in large codebases by providing clear type contracts.
• Refactoring: Makes code refactoring safer and easier with type-aware tooling.
• Interoperability: Works seamlessly with existing JavaScript libraries, with type definitions available via DefinitelyTyped or @types packages.

• Learning Curve: Developers new to static typing may need time to adapt.
• Build Step: Requires compilation to JavaScript, adding a step to the development workflow.
• Not Runtime-Enforced: Types are erased during compilation, so TypeScript’s type safety doesn’t apply at runtime.

• Widely used in web development, especially with frameworks like React, Angular, and Vue.js.
• Popular in large-scale projects (e.g., enterprise applications, Node.js backends) where type safety improves code reliability.
• Examples: VS Code, Slack, and parts of Microsoft’s own products are built with TypeScript.

Here’s a simple TypeScript function with type annotations:

function greet(person: { name: string; age: number }): string {
  return `Hello, ${person.name}! You are ${person.age} years old.`;
}
console.log(greet({ name: "Alice", age: 25 }));
// Error: Property 'age' is missing
// console.log(greet({ name: "Bob" }));

• Install TypeScript: npm install -g typescript
• Compile a .ts file: tsc file.ts (outputs file.js)
• Run the JavaScript output with Node.js or in a browser.
• TypeScript can be used in projects via tsconfig.json for configuration.

If you want to dive deeper into TypeScript’s features, set up a project, or explore how it integrates with SARIF for static analysis (e.g., type checking results), let me know!