book

Clean Code with TypeScript

Name: Clean Code with TypeScript
ISBN: 9781835889565

by Rukevwe Ojigbo, Dr. Sanjay Krishna Anbalagan

March 2026

Intermediate to advanced

438 pages

9h 2m

English

Packt Publishing

Read now

Unlock full access

Preface
Free benefits with your book
Chapter 1: Introducing TypeScript
Technical requirementsWhy TypeScript?Advantages of using TypeScriptReal-world applications of TypeScriptGetting started with TypeScript: installation and project setupUnderstanding basic types in TypeScriptWhat are basic types in TypeScript?How to use basic types in TypeScriptArraysType inferenceWorking with complex typesObjectsTypes/interfacesTuplesEnumsMastering advanced typesUnion types: the power of ORIntersection types: merging strengthsGenerics: one tool, many typesApplications of genericsGeneric classes: flexible object structuresGeneric interfacesUnderstanding conditional types in TypeScriptConfiguring tsconfig.jsonDiving into compilerOptionsBest practices for tsconfig.json maintenanceSummaryGet this book's PDF copy, code bundle, and more
Chapter 2: Writing Clean Functions
Technical requirementsLearning principles of clean functionsNaming functionsApplying the Single Responsibility PrincipleUnderstanding and avoiding (bad) side effects in TypeScript functionsConcurrency exampleParallelism exampleWhy this mattersHow to avoid side effectsUnderstanding function signaturesIntegrating TypeDoc for comprehensive TypeScript documentationCreating static documentation pages with TypeDoc integrationBalancing comments and clean codeSummaryGet this book's PDF copy, code bundle, and more
Chapter 3: Object-Oriented Programming with TypeScript
Technical requirementsWhat is object-oriented programming?TypeScript objectsObject literalsExample—the cake objectTypeScript classesStatic methods and properties in TypeScriptTypeScript classes: behind the scenesInheritance and prototype chainsClassical inheritancePrototypal inheritanceKey differencesUnderstanding prototypes in TypeScriptSetting up the prototype chainUsing Object.create to set up the prototype chainES6 class inheritance with extends and superEncapsulation—protecting your cake's recipeGetters and setters: the gatekeepers of your dataAccess modifiers: controlling access to your dataPolymorphism in TypeScript OOPMethod overridingInterfacesInterfaces versus classes: when to use eachComposition over inheritance for agile developmentSummaryGet this book's PDF copy, code bundle, and more
Chapter 4: Clean Code in TypeScript Projects
Technical requirementsBest practices for folder structureStandard folder structureOrganizing by feature versus functionFeature-based organizationFunction-based organizationHybrid approach (common in practice)Examples of both approachesLearning module systemsWhat are module systems?Defining a moduleEncapsulation and scope managementReusability—importing and using modulesMaintainabilityScalabilityImproved testingES6 modulesCommonJSManaging dependencies in TypeScript projectsTypes of dependenciesDependency managers in Node.jsOverview of npm, yarn, and pnpmChecking for outdated dependenciesUpdating dependenciesLinting and code formattingSetting up ESLintStep 1—Install ESLint and required pluginsStep 2—Initialize ESLint configurationStep 3—Test ESLint with a sample code filePrettier setup and configurationSummaryGet this book's PDF copy, code bundle, and more
Chapter 5: Testing and Test-Driven Development
Technical requirementsGrasping the fundamentals of testingUnderstanding levels of testing in softwareUnit testing in TypeScriptCommon terminology used in unit test/testingTest caseAssertionMockTest runnersChoosing the right test runnerSetting up Vitest in a Node.js TypeScript projectIntegration testing in TypeScriptWhat is integration testing?Why integration testing?Types of integration testingBig bang approachIncremental approachManual integration testing versus automated integration testingManual integration testingAutomated integration testingPractical example of integration testingIntroducing TDD and its benefitsBest practices for TDD in TypeScriptSummaryGet this book's PDF copy, code bundle, and more
Chapter 6: Error Handling, Debugging, and Security Best Practices
Technical requirementsUnderstanding error types and patternsIntroducing error typesSyntax errorsType errorsRuntime errorsLogical errorsHandling errors in TypeScriptSynchronous error handlingWhat are synchronous errors?Validating input dataAsynchronous error handlingWhat are asynchronous errors?Strategies for handling asynchronous errorsBest practices for robust asynchronous error handlingDebugging tools in TypeScriptWorking with source mapsUsing the VS Code debuggerStep 1: Create a launch configurationStep 2: Add a breakpointStep 3: Start debuggingLeveraging console logsSecurity best practices in TypeScriptIntroduction to security practicesInput validation and data sanitizationInput validationData sanitizationSecure coding techniquesError handling with security in mindManaging sensitive dataSummaryGet this book's PDF copy, code bundle, and more
Chapter 7: Maximizing Performance Optimization
Technical requirementsUnderstanding performance optimizationWhy performance optimization mattersCommon causes of poor performance in TypeScript applicationsCode example: comparing iteration patternsPerformance versus readabilityKey strategies for performance optimizationWhy these strategies matterIdentifying performance bottlenecksUsing profiling tools to measure performanceChrome DevTools Performance ProfilerWebpack Bundle AnalyzerNode.js performance hooks (for backend performance)Detecting slow functions, excessive re-renders, and memory leaksExample: Optimizing a slow function by avoiding repeated workDetecting excessive re-renders in ReactDetecting memory leaksStrategies for prioritizing optimization effortsPerformance-enhancing techniquesImplementing lazy loading and code splittingHow to implement lazy loading in ReactCode splitting: breaking large bundles into smaller chunksApplying tree shaking to eliminate unused codeOptimized code with tree shakingLeveraging caching mechanisms to improve speedCommon ways to apply cachingOptimizing loops, recursive functions, and asynchronous operationsOptimizing loopsOptimizing recursive functionsChoosing between loops and recursionOptimizing asynchronous operationsBeyond debouncingSummaryGet this book's PDF copy, code bundle, and more
Chapter 8: Mastering Design Patterns in TypeScript
Technical requirementsIntroducing design patternsCreational patterns: Techniques for object creationFactory method: Simplifying object creationAbstract Factory: Creating related objectsStep 1: Define the product interfacesStep 2: Create the concrete products for each themeStep 3: Define the Abstract Factory interfaceStep 4: Implement the concrete factoriesStep 5: Use the factory (client code)Builder: Constructing complex objectsStep 1: Define the complex object (the product)Step 2: Create the Builder classStep 3: Implement fluent methodsStep 4: Use the build methodStep 5: Use the builder (client code)Builder pattern in modern TypeScriptSingleton: One instance onlyStep 1: Use the private constructorStep 2: Use the static accessor methodStep 3: Verifying the Singleton (client code)Structural patterns: Techniques for class and object compositionAdapter: Making incompatible interfaces compatibleStep 1: The old system (the expectation)Step 2: The new system (the incompatible class)Step 3: The adapter (the bridge)Step 4: Using the adapterComposite: Treating individual objects and compositions uniformlyStep 1: Define the common interface (the component)Step 2: Create the leaf nodes (individual objects)Step 3: Create the Composite node (the container)Step 4: Using the Composite structureDecorator: Adding behavior without altering structureStep 1: Define the base interface and componentStep 2: Create the decoratorsStep 3: Stack the decorators (usage):Facade: Simplifying complex subsystemsStep 1: The complex subsystemsStep 2: The facade (the remote control)Step 3: Using the facade (client code)Behavioral patterns: Defining object interaction and communicationObserver: Notifying dependent objects of changes in a subjectStep 1: Define the observer interfaceStep 2: Implement the subject (the weather station)Step 3: Create concrete observersStep 4: Seeing it in actionStrategy: Allowing interchangeable algorithms in a single interfaceStep 1: Define the Strategy interfaceStep 2: Implement concrete strategiesStep 3: Create the contextStep 4: Switch strategies at runtimeCommand: Encapsulating requests as objects to enable Undo and loggingStep 1: The receiver (the hardware)Step 2: The Command interfaceStep 3: Concrete commands (the cartridges)Step 4: The invoker (the controller)Step 5: Wiring it together (client code)Iterator: Accessing elements in a collection without exposing its structureStep 1: Define the Iterator interfaceStep 2: Create the iterator logicStep 3: Create the collection (the aggregate)Step 4: Traversing the collection (client code)Practical examples: Applying design patterns in real-world scenariosCreational patternsExample: Factory method in a notification systemStructural patterns: Adapter for third-party APIsBehavioral patternsExample: Observer in a real-time chat roomExample: Command for undo functionality in a text editorWhen and where each pattern is most usefulAdvantages and disadvantages of design patternsAdvantages of using design patternsDisadvantages of using design patternsWhen patterns might add complexityStriking the right balanceBest practices for implementing design patterns in TypeScriptSummaryGet this book's PDF copy, code bundle, and more
Chapter 9: Understanding Advanced TypeScript Features
Technical requirementsExploring genericsGenerics at workGeneric classesGeneric interfacesGeneric constraintsAdvantages of genericsIntroducing advanced typesUnderstanding decoratorsHow do decorators work?Types of decoratorsBenefits of decoratorsCreating mapped typesHow mapped types workExamples of mapped typesBuilt-in mapped typesAdvantages of mapped typesBest practicesUsing conditional typesHow conditional types workCommon use cases for conditional typesCombining conditional types with other featuresBuilt-in conditional typesBest practicesWorking with utility typesKey utility types in TypeScriptBest practicesSummaryGet this book's PDF copy, code bundle, and more

Chapter 10: Setting Up Scalable TypeScript Projects
Technical requirementsFrom product spec to technical architectureUnderstanding product specificationsFrom product spec to technical architectureBreaking down the specification into a technical planDocumenting architecture decisions with ADRsWriting a simple ADRWhy this mattersChoosing a repository strategy for your projectComparing monorepo and polyrepo approachesDeciding between monorepo and polyrepo strategiesChoosing for DevJobsNx—the professional choiceWhy Nx works well for TypeScript projectsComparing Nx with alternativesSetting up your Nx workspaceWorkspace creation and configurationWorkspace structure and configurationGenerating and organizing your projectsInstalling required Nx pluginsGenerating the frontend and backend applicationsEssential Nx commands and workflowsCode quality automation with Git hooksGit hooks strategyHusky and lint-staged setupStep 1—Install dependenciesStep 2—Initialize GitStep 3—Initialize HuskyStep 4—Add a pre-commit hookTesting the Git hook with a sample fileStep 1—Create a test fileStep 2—Stage the fileStep 3—Commit the fileStep 4—Verify the changesSummaryGet this book's PDF copy, code bundle, and more
Chapter 11: TypeScript in Action: Building Full Stack Applications
Technical requirementsServer-side TypeScript with Node.jsImplementing the contract-first approachStep 1: Creating the openapi.yml fileStep 2: Defining the API specificationStep 3: Installing Orval and adding Orval configStep 4: Generating the typesAdding feature modulesTying it back to our product specUsers moduleCreating the first endpointAdding business logic to UserServiceStep 1: Installing bcrypt for hashing passwordsStep 2: Basic in-memory registration with Orval typesMaking a request to our newly created endpointAdding the findByEmail method to UsersServiceAdding authentication to our backendStep 1: Installing packages to help with authenticationStep 2: Scaffolding the Auth module, controller, and serviceStep 3: Importing the relevant packagesStep 4: Configuring the Auth moduleStep 5: Adding the authentication logic to the AuthService classStep 6: AuthController – exposing /auth/loginStep 7: Testing the authentication flowAdding JWT guards to protect routesAdding file-based persistenceStep 1: Creating a file storage utilityStep 2: Updating UsersService to persist dataCompanies moduleStep 1: Scaffolding the moduleStep 2: Defining the serviceStep 3: Defining the companies controllerJobs moduleStep 1: Service – jobs.service.tsStep 2: Adding the jobs controller – jobs.controller.tsTesting our devjobs backend full flowClient-side TypeScript with ReactInstalling frontend dependenciesCreating the API client instanceConfiguring Orval for frontend hooksSetting up the React Query providerBuilding the authentication flowCreating the auth contextLogin pageProtected routesBuilding the jobs pageSummaryGet this book's PDF copy, code bundle, and more
Chapter 12: TypeScript in Evolving Systems
Technical requirementsStarting with a fast proof of conceptDetecting and handling contract driftMaking the contract explicitThe problem shared types don't solve by themselvesProtecting the JSON boundary with a runtime gateScaling the system without leaking vendor detailsMaking variants explicit with discriminated unionsMultiple endpoints without fragile castsThe payoff: moving failures earlier, on purposeSummaryGet this book's PDF copy, code bundle, and more
Chapter 13: Unlock Your Exclusive Benefits
Unlock this Book's Free Benefits in 3 Easy Steps
Other Books You May Enjoy
Index

Content preview from Clean Code with TypeScript

8 Mastering Design Patterns in TypeScript

In this chapter, we will explore design patterns and how they can be effectively implemented using TypeScript. Design patterns are standard solutions to common problems in software design. They help developers create code that is more flexible, reusable, and easier to maintain. By mastering these patterns, you will improve your ability to solve design issues and enhance the quality of your code.

Understanding design patterns involves knowing their purpose, structure, and when to use them. This chapter will break down various design patterns into three main categories: creational, structural, and behavioral. Each category addresses different aspects of software design, making it easier for you to apply ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781835889565

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Clean Code with TypeScript

by Rukevwe Ojigbo, Dr. Sanjay Krishna Anbalagan

8

Mastering Design Patterns in TypeScript

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.