1# TypeScript Cheatsheet
2 
3## Type Basics
4 
5```typescript
6// Primitives
7const name: string = 'John'
8const age: number = 30
9const isActive: boolean = true
10const nothing: null = null
11const notDefined: undefined = undefined
12 
13// Arrays
14const numbers: number[] = [1, 2, 3]
15const strings: Array<string> = ['a', 'b', 'c']
16 
17// Tuple
18const tuple: [string, number] = ['hello', 42]
19 
20// Object
21const user: { name: string; age: number } = { name: 'John', age: 30 }
22 
23// Union
24const value: string | number = 'hello'
25 
26// Literal
27const direction: 'up' | 'down' | 'left' | 'right' = 'up'
28 
29// Any vs Unknown
30const anyValue: any = 'anything'     // ❌ Avoid
31const unknownValue: unknown = 'safe' // ✅ Prefer, requires narrowing
32```
33 
34## Type Aliases & Interfaces
35 
36```typescript
37// Type Alias
38type Point = {
39  x: number
40  y: number
41}
42 
43// Interface (preferred for objects)
44interface User {
45  id: string
46  name: string
47  email?: string  // Optional
48  readonly createdAt: Date  // Readonly
49}
50 
51// Extending
52interface Admin extends User {
53  permissions: string[]
54}
55 
56// Intersection
57type AdminUser = User & { permissions: string[] }
58```
59 
60## Generics
61 
62```typescript
63// Generic function
64function identity<T>(value: T): T {
65  return value
66}
67 
68// Generic with constraint
69function getLength<T extends { length: number }>(item: T): number {
70  return item.length
71}
72 
73// Generic interface
74interface ApiResponse<T> {
75  data: T
76  status: number
77  message: string
78}
79 
80// Generic with default
81type Container<T = string> = {
82  value: T
83}
84 
85// Multiple generics
86function merge<T, U>(obj1: T, obj2: U): T & U {
87  return { ...obj1, ...obj2 }
88}
89```
90 
91## Utility Types
92 
93```typescript
94interface User {
95  id: string
96  name: string
97  email: string
98  age: number
99}
100 
101// Partial - all optional
102type PartialUser = Partial<User>
103 
104// Required - all required
105type RequiredUser = Required<User>
106 
107// Readonly - all readonly
108type ReadonlyUser = Readonly<User>
109 
110// Pick - select properties
111type UserName = Pick<User, 'id' | 'name'>
112 
113// Omit - exclude properties
114type UserWithoutEmail = Omit<User, 'email'>
115 
116// Record - key-value map
117type UserMap = Record<string, User>
118 
119// Extract - extract from union
120type StringOrNumber = string | number | boolean
121type OnlyStrings = Extract<StringOrNumber, string>
122 
123// Exclude - exclude from union
124type NotString = Exclude<StringOrNumber, string>
125 
126// NonNullable - remove null/undefined
127type MaybeString = string | null | undefined
128type DefinitelyString = NonNullable<MaybeString>
129 
130// ReturnType - get function return type
131function getUser() { return { name: 'John' } }
132type UserReturn = ReturnType<typeof getUser>
133 
134// Parameters - get function parameters
135type GetUserParams = Parameters<typeof getUser>
136 
137// Awaited - unwrap Promise
138type ResolvedUser = Awaited<Promise<User>>
139```
140 
141## Conditional Types
142 
143```typescript
144// Basic conditional
145type IsString<T> = T extends string ? true : false
146 
147// Infer keyword
148type UnwrapPromise<T> = T extends Promise<infer U> ? U : T
149 
150// Distributive conditional
151type ToArray<T> = T extends any ? T[] : never
152type Result = ToArray<string | number>  // string[] | number[]
153 
154// NonDistributive
155type ToArrayNonDist<T> = [T] extends [any] ? T[] : never
156```
157 
158## Template Literal Types
159 
160```typescript
161type Color = 'red' | 'green' | 'blue'
162type Size = 'small' | 'medium' | 'large'
163 
164// Combine
165type ColorSize = `${Color}-${Size}`
166// 'red-small' | 'red-medium' | 'red-large' | ...
167 
168// Event handlers
169type EventName = 'click' | 'focus' | 'blur'
170type EventHandler = `on${Capitalize<EventName>}`
171// 'onClick' | 'onFocus' | 'onBlur'
172```
173 
174## Mapped Types
175 
176```typescript
177// Basic mapped type
178type Optional<T> = {
179  [K in keyof T]?: T[K]
180}
181 
182// With key remapping
183type Getters<T> = {
184  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
185}
186 
187// Filter keys
188type OnlyStrings<T> = {
189  [K in keyof T as T[K] extends string ? K : never]: T[K]
190}
191```
192 
193## Type Guards
194 
195```typescript
196// typeof guard
197function process(value: string | number) {
198  if (typeof value === 'string') {
199    return value.toUpperCase()  // string
200  }
201  return value.toFixed(2)  // number
202}
203 
204// instanceof guard
205class Dog { bark() {} }
206class Cat { meow() {} }
207 
208function makeSound(animal: Dog | Cat) {
209  if (animal instanceof Dog) {
210    animal.bark()
211  } else {
212    animal.meow()
213  }
214}
215 
216// in guard
217interface Bird { fly(): void }
218interface Fish { swim(): void }
219 
220function move(animal: Bird | Fish) {
221  if ('fly' in animal) {
222    animal.fly()
223  } else {
224    animal.swim()
225  }
226}
227 
228// Custom type guard
229function isString(value: unknown): value is string {
230  return typeof value === 'string'
231}
232 
233// Assertion function
234function assertIsString(value: unknown): asserts value is string {
235  if (typeof value !== 'string') {
236    throw new Error('Not a string')
237  }
238}
239```
240 
241## Discriminated Unions
242 
243```typescript
244// With type discriminant
245type Success<T> = { type: 'success'; data: T }
246type Error = { type: 'error'; message: string }
247type Loading = { type: 'loading' }
248 
249type State<T> = Success<T> | Error | Loading
250 
251function handle<T>(state: State<T>) {
252  switch (state.type) {
253    case 'success':
254      return state.data  // T
255    case 'error':
256      return state.message  // string
257    case 'loading':
258      return null
259  }
260}
261 
262// Exhaustive check
263function assertNever(value: never): never {
264  throw new Error(`Unexpected value: ${value}`)
265}
266```
267 
268## Branded Types
269 
270```typescript
271// Create branded type
272type Brand<K, T> = K & { __brand: T }
273 
274type UserId = Brand<string, 'UserId'>
275type OrderId = Brand<string, 'OrderId'>
276 
277// Constructor functions
278function createUserId(id: string): UserId {
279  return id as UserId
280}
281 
282function createOrderId(id: string): OrderId {
283  return id as OrderId
284}
285 
286// Usage - prevents mixing
287function getOrder(orderId: OrderId, userId: UserId) {}
288 
289const userId = createUserId('user-123')
290const orderId = createOrderId('order-456')
291 
292getOrder(orderId, userId)  // ✅ OK
293// getOrder(userId, orderId)  // ❌ Error - types don't match
294```
295 
296## Module Declarations
297 
298```typescript
299// Declare module for untyped package
300declare module 'untyped-package' {
301  export function doSomething(): void
302  export const value: string
303}
304 
305// Augment existing module
306declare module 'express' {
307  interface Request {
308    user?: { id: string }
309  }
310}
311 
312// Declare global
313declare global {
314  interface Window {
315    myGlobal: string
316  }
317}
318```
319 
320## TSConfig Essentials
321 
322```json
323{
324  "compilerOptions": {
325    // Strictness
326    "strict": true,
327    "noUncheckedIndexedAccess": true,
328    "noImplicitOverride": true,
329    
330    // Modules
331    "module": "ESNext",
332    "moduleResolution": "bundler",
333    "esModuleInterop": true,
334    
335    // Output
336    "target": "ES2022",
337    "lib": ["ES2022", "DOM"],
338    
339    // Performance
340    "skipLibCheck": true,
341    "incremental": true,
342    
343    // Paths
344    "baseUrl": ".",
345    "paths": {
346      "@/*": ["./src/*"]
347    }
348  }
349}
350```
351 
352## Best Practices
353 
354```typescript
355// ✅ Prefer interface for objects
356interface User {
357  name: string
358}
359 
360// ✅ Use const assertions
361const routes = ['home', 'about'] as const
362 
363// ✅ Use satisfies for validation
364const config = {
365  api: 'https://api.example.com'
366} satisfies Record<string, string>
367 
368// ✅ Use unknown over any
369function parse(input: unknown) {
370  if (typeof input === 'string') {
371    return JSON.parse(input)
372  }
373}
374 
375// ✅ Explicit return types for public APIs
376export function getUser(id: string): User | null {
377  // ...
378}
379 
380// ❌ Avoid
381const data: any = fetchData()
382data.anything.goes.wrong  // No type safety
383```
384