TypeScript

You can compile TypeScript, read a compiler error, and annotate primitive values with the everyday types.

1. 1Why static types existYou can explain which class of runtime bug a static type checker catches before the code runs.8m20xp
2. 2Compiling with tscYou can run the compiler on a file, read the emitted JavaScript, and describe what was erased.9m23xp
3. 3Reading a compiler errorYou can locate the offending expression from an error code, message, and position.8m20xp
4. 4string, number, booleanYou can annotate variables and parameters with the three primitive types using lowercase names.8m20xp
5. 5Inference and when to annotateYou can decide whether an annotation is redundant by checking what the compiler already inferred.9m23xp
6. 6Array and tuple typesYou can distinguish a homogeneous array type from a fixed-length tuple type and choose the right one.10m25xp
7. 7any versus unknownYou can replace an unsafe any with unknown and add the narrowing needed to use it.10m25xp
8. 8null, undefined and strictNullChecksYou can turn on strict null checking and resolve the errors it reveals on optional values.10m25xp
9. 9Literal typesYou can constrain a value to an exact set of allowed strings or numbers using literal types.9m23xp
10. 10Union typesYou can declare a union type and explain why only members shared by all branches are usable directly.10m25xp

You can prove to the compiler which member of a union you are holding using control flow analysis and custom guards.

1. 1typeof narrowingYou can split a primitive union into safe branches using typeof checks.9m23xp
2. 2Truthiness narrowing and its trapsYou can narrow out null and undefined without accidentally excluding valid falsy values.9m23xp
3. 3Equality narrowingYou can narrow two unions simultaneously by comparing them for equality.8m20xp
4. 4The in operator narrowingYou can distinguish object shapes by testing for the presence of a property name.8m20xp
5. 5instanceof narrowingYou can narrow class-based unions with instanceof and say when it will not work.8m20xp
6. 6Discriminated unionsYou can add a literal tag field to a union so that switching on it narrows each branch exactly.12m30xp
7. 7Exhaustiveness checking with neverYou can add a never-typed default case that fails to compile when a new union member is added.10m25xp
8. 8User-defined type guardsYou can write a function returning 'arg is T' and use it to narrow at call sites.11m28xp
9. 9Assertion signaturesYou can write an asserts signature that narrows a value for the rest of the enclosing scope.10m25xp
10. 10Control flow analysis and narrowing lossYou can identify the operations that discard an earlier narrowing and restructure the code to keep it.11m28xp
11. 11Choosing a narrowing strategyYou can pick the appropriate narrowing tool for a given union shape and justify the choice.9m23xp

You can specify function signatures and object shapes precisely, including optionals, readonly members and index signatures.

1. 1Function type expressionsYou can annotate a variable or parameter with a function type using arrow syntax.8m20xp
2. 2Optional and default parametersYou can declare optional and defaulted parameters and predict the resulting parameter type.9m23xp
3. 3Rest parameters and spread argumentsYou can type a variadic function and spread a tuple into it safely.9m23xp
4. 4Overload signaturesYou can declare multiple overload signatures over one implementation and order them correctly.12m30xp
5. 5Typing this in functionsYou can add an explicit this parameter to constrain the receiver of a callback.9m23xp
6. 6void versus undefined return typesYou can explain why a callback typed to return void accepts a function that returns a value.8m20xp
7. 7Interfaces versus type aliasesYou can choose between an interface and a type alias based on the capability you need.10m25xp
8. 8Optional object propertiesYou can mark properties optional and handle their undefined case at read sites.8m20xp
9. 9readonly properties and ReadonlyArrayYou can prevent reassignment of properties and array elements through a readonly type.9m23xp
10. 10Index signaturesYou can type a dictionary-shaped object with an index signature and guard the missing-key case.10m25xp
11. 11Excess property checkingYou can explain why an object literal is rejected while an equivalent variable is accepted.9m23xp
12. 12Intersection typesYou can combine object types with & and predict conflicts between shared property types.9m23xp
13. 13Structural typingYou can predict assignability between two unrelated named types with the same shape.10m25xp

You can write reusable generic functions and types with constraints, defaults and correct inference.

1. 1Generic functionsYou can introduce a type parameter so a function preserves its input type in its output.10m25xp
2. 2Inference of type argumentsYou can predict which type argument the compiler infers and when to supply one explicitly.10m25xp
3. 3Constraining type parametersYou can use extends on a type parameter to require capabilities inside the function body.10m25xp
4. 4The keyof operatorYou can produce the union of an object type's keys and use it to constrain a key parameter.9m23xp
5. 5Indexed access typesYou can look up the type of a property using T[K] instead of restating it.9m23xp
6. 6The typeof type operatorYou can derive a type from an existing value declaration using typeof in type position.9m23xp
7. 7Generic interfaces and type aliasesYou can parameterise a container type and instantiate it with concrete arguments.9m23xp
8. 8Default type argumentsYou can give a type parameter a default so common instantiations omit it.8m20xp
9. 9Generic classesYou can declare a class with a type parameter and use it in fields and methods.9m23xp
10. 10Conditional typesYou can select between two types based on an extends check.11m28xp
11. 11Extracting types with inferYou can capture a nested type from a matched pattern using infer.11m28xp
12. 12Mapped typesYou can transform every property of a type using a mapped type with key iteration.11m28xp
13. 13Template literal typesYou can build string literal types by interpolating unions into a template.10m25xp
14. 14Built-in utility typesYou can select the right built-in utility type instead of hand-rolling a transformation.10m25xp

You can model behaviour with typed classes and organise code across modules with correct import and export forms.

1. 1Class fields and constructorsYou can declare typed fields and initialise them so strict property initialisation passes.9m23xp
2. 2public, private and protectedYou can choose an access modifier and describe its runtime visibility.9m23xp
3. 3Parameter propertiesYou can declare and assign a field from a constructor parameter in one step.8m20xp
4. 4AccessorsYou can add a getter and setter pair with compatible types.8m20xp
5. 5extends and superYou can subclass, call super correctly, and override a member with a compatible type.10m25xp
6. 6Abstract classes and membersYou can define an abstract base that forces subclasses to supply an implementation.9m23xp
7. 7implements versus extendsYou can declare that a class satisfies an interface and explain what implements does not do.9m23xp
8. 8Static members and static blocksYou can add static state and initialisation logic to a class.8m20xp
9. 9ES module imports and exportsYou can export and import named and default bindings across files.9m23xp
10. 10Type-only imports and exportsYou can import a type without producing a runtime import.9m23xp
11. 11Declaration merging and namespacesYou can extend an existing interface through merging and say when namespaces are still appropriate.9m23xp
12. 12Enums versus literal unionsYou can compare enum and literal-union modelling and pick one deliberately.9m23xp
13. 13Type assertions and satisfiesYou can distinguish an assertion from a check and use satisfies to validate without widening.10m25xp

You can type asynchronous code and untrusted external data so failures surface at the boundary.

1. 1Typing promisesYou can annotate an async function's return type and read a promise's payload type.9m23xp
2. 2Typing caught errorsYou can handle a catch clause value typed as unknown and narrow it to a usable error.9m23xp
3. 3Result types versus exceptionsYou can model a fallible operation as a discriminated result and compare it with throwing.10m25xp
4. 4Validating data at the boundaryYou can convert an unknown external payload into a typed value using a runtime check.11m28xp
5. 5Branded nominal typesYou can prevent two structurally identical primitives from being interchanged.10m25xp
6. 6Deep readonly and immutable updatesYou can express a deeply readonly type and write an update that produces a new value.10m25xp
7. 7Variance in function typesYou can predict whether one function type is assignable to another based on parameter and return positions.11m28xp
8. 8Designing generic APIsYou can decide whether a type parameter belongs on a function and remove ones that add no value.10m25xp

You can configure a project's compiler options, module output and library types deliberately.

1. 1tsconfig.json structureYou can create a tsconfig that selects the right files and explain include, exclude and files.9m23xp
2. 2The strict family of optionsYou can enumerate the checks strict enables and turn one off deliberately.10m25xp
3. 3target and libYou can set the output language level and the ambient library types independently.9m23xp
4. 4module and moduleResolutionYou can choose a module format and resolution strategy that matches the runtime.10m25xp
5. 5ESM and CommonJS interopYou can import a CommonJS module from ESM correctly using the interop flags.10m25xp
6. 6Declaration files and .d.ts outputYou can emit declarations for a library and read an existing .d.ts file.10m25xp
7. 7Declaring untyped modules and globalsYou can write an ambient declaration for an untyped dependency or a global variable.10m25xp
8. 8Project references and incremental buildsYou can split a codebase into referenced projects and build them in dependency order.10m25xp
9. 9Checking JavaScript filesYou can enable JavaScript checking and add types with JSDoc annotations.9m23xp
10. 10Migrating a JavaScript codebaseYou can sequence a JavaScript-to-TypeScript migration so the build stays green throughout.11m28xp
11. 11Diagnosing slow type checkingYou can measure compile cost and identify a type-level construct that is causing it.10m25xp
12. 12Using escape hatches responsiblyYou can choose the least damaging escape hatch and document why it is needed.9m23xp