TypeScript — JavaScript with Syntax for Types

What it is

TypeScript is a superset of JavaScript created by Anders Hejlsberg at Microsoft that adds static types, interfaces, generics, and modern ES features. It compiles down to plain JavaScript and runs anywhere JavaScript runs.

TypeScript is best for web developers, backend engineers, and teams working on medium-to-large JavaScript projects where type safety prevents bugs and improves refactoring confidence.

How it saves time or tokens

TypeScript catches type errors at compile time instead of runtime. Refactoring a function signature automatically flags every caller that needs updating. IDE autocompletion powered by type information speeds up development. Teams report fewer production bugs and faster onboarding because types serve as documentation.

How to use

1. Install TypeScript:

npm i -D typescript
npx tsc --init

1. Write typed code:

interface User {
  id: number;
  email: string;
  role: 'admin' | 'user';
}

function greet(user: User): string {
  return `Hello, ${user.email} (${user.role})`;
}

1. Compile and run:

npx tsc           # Compile once
npx tsc --watch   # Watch mode

Example

// Generic API response type
interface ApiResponse<T> {
  data: T;
  error: string | null;
  status: number;
}

async function fetchUser(id: number): Promise<ApiResponse<User>> {
  const res = await fetch(`/api/users/${id}`);
  if (!res.ok) {
    return { data: null as any, error: res.statusText, status: res.status };
  }
  const data = await res.json();
  return { data, error: null, status: 200 };
}

// Type narrowing
const result = await fetchUser(1);
if (result.error) {
  console.error(result.error);
} else {
  console.log(result.data.email); // TypeScript knows data is User here
}

Related on TokRepo

• AI coding tools — development productivity tools
• Testing tools — type-safe testing frameworks

Common pitfalls

• Using any type everywhere, which defeats the purpose of TypeScript
• Not enabling strict mode in tsconfig.json, missing many type safety benefits
• Over-engineering types with complex generics when simpler types would suffice