Welcome to the Certified TypeScript Programming Expert course outline! This is not the full course – it is a roadmap that shows you everything you will learn. Think of it as a treasure map that guides you through the exciting world of TypeScript.
TypeScript is a programming language that helps developers write better, safer, and more organised code. It is built on JavaScript – the language of the web – but adds extra features that make it easier to catch mistakes and build big applications.
In this course outline, you will see all the modules, lessons, and activities that will turn you into a TypeScript expert. You will learn what TypeScript is, why it is used, and how to write programs with it.
By the end of this course, you will be able to:
In Lagos, a group of developers was building a banking app. The app was written in JavaScript. It worked, but there were many bugs – customers were getting wrong balances, and transactions were failing.
One developer, Chidi, suggested, "Let's rewrite it in TypeScript." The team was nervous – they had never used TypeScript before. But Chidi explained, "TypeScript helps us catch errors before they happen. It's like having a safety net."
They rewrote the app in TypeScript. The bugs disappeared. The app became stable, and customers were happy. The team was praised for their excellent work. Chidi said, "TypeScript saved us!"
This story shows why TypeScript is so powerful – it helps developers build reliable software.
What you will learn:
Key Concepts: TypeScript, JavaScript, transpiler, static typing.
Activities: Install TypeScript, write your first TypeScript program.
What you will learn:
Key Concepts: String, number, boolean, array, tuple, any, void.
Activities: Write code using different types.
What you will learn:
Key Concepts: Interface, type alias, optional property.
Activities: Create interfaces for real-world objects.
What you will learn:
Key Concepts: Function, parameter, return, arrow function.
Activities: Write functions with type annotations.
What you will learn:
Key Concepts: Class, object, property, method, constructor, access modifier.
Activities: Build a class-based application.
What you will learn:
Key Concepts: Inheritance, extends, override, polymorphism.
Activities: Create a class hierarchy.
What you will learn:
Key Concepts: Generic, constraint, flexible.
Activities: Write generic functions and classes.
What you will learn:
Key Concepts: Union, intersection, type guard, literal.
Activities: Use advanced types in code.
What you will learn:
Key Concepts: Module, export, import, namespace.
Activities: Build a modular TypeScript project.
What you will learn:
Key Concepts: Decorator, annotation, metadata.
Activities: Use decorators in a project.
What you will learn:
Key Concepts: React, props, state, hooks.
Activities: Build a React app with TypeScript.
What you will learn:
Key Concepts: Node.js, backend, server.
Activities: Build a backend API with TypeScript.
What you will learn:
Key Concepts: Testing, unit test, Jest.
Activities: Write tests for a TypeScript project.
What you will learn:
Key Concepts: Best practices, performance, safety.
Activities: Review and refactor code.
What you will learn:
Key Concepts: Full-stack, API, deployment, certification.
Activities: Build a complete project.
| Word | Simple Definition |
|---|---|
| TypeScript | A programming language that adds types to JavaScript. |
| JavaScript | The language of the web. |
| Type | A label that tells what kind of value something is. |
| Interface | A way to describe the shape of an object. |
| Class | A blueprint for creating objects. |
| Object | A thing that has properties and methods. |
| Function | A block of code that does a specific task. |
| Module | A file or group of code that can be reused. |
| Generic | A flexible type that works with many types. |
| Decorator | A way to add extra functionality to code. |
Write TypeScript
|
V
Compile to JavaScript
|
V
Run JavaScript
|
V
See Output
Types in TypeScript
|
+-- String
|
+-- Number
|
+-- Boolean
|
+-- Array
|
+-- Object
+-----------------------+-----------------------+ | JavaScript | TypeScript | +-----------------------+-----------------------+ | Dynamic types | Static types | | Errors at runtime | Errors at compile | | Less safe | More safe | | No type checking | Type checking | | Flexible | Structured | +-----------------------+-----------------------+
| Type | What It Represents | Example |
|---|---|---|
| string | Text | "Hello" |
| number | Number | 123 |
| boolean | True/False | true |
| array | List of items | [1,2,3] |
| object | Collection of properties | {name:"John"} |
| Feature | Purpose | Benefit |
|---|---|---|
| Types | Define data | Error prevention |
| Interfaces | Shape objects | Consistency |
| Classes | Create blueprints | Reusability |
| Modules | Organise code | Maintainability |
Module 1: Introduction to TypeScript – Understanding the basics.
Module 2: Basic Types – Learning about strings, numbers, and more.
Module 3: Interfaces and Types – Describing objects.
Module 4: Functions – Writing functions with types.
Module 5: Classes and Objects – Creating blueprints.
Module 6: Inheritance and Polymorphism – Extending classes.
Module 7: Generics – Flexible code.
Module 8: Advanced Types – Union, intersection, and more.
Module 9: Modules and Namespaces – Organising code.
Module 10: Decorators – Adding extra functionality.
Module 11: TypeScript and React – Building UI.
Module 12: TypeScript and Node.js – Building backends.
Module 13: Testing TypeScript Code – Ensuring quality.
Module 14: TypeScript Best Practices – Writing good code.
Module 15: Real-World Projects – Building complete applications.
This outline gives you a complete overview of the Certified TypeScript Programming Expert course. You will learn everything from the basics of TypeScript to advanced features and real-world applications. You will understand types, interfaces, classes, generics, modules, and more. By the end, you will be able to build robust applications with TypeScript. Whether you are in Lagos, Abuja, or anywhere else, TypeScript skills are valuable. Get ready to become a TypeScript expert!
Match the term with its definition.
| Term | Definition |
|---|---|
| 1. TypeScript | A. Language with types |
| 2. Interface | B. Describes object shape |
| 3. Class | C. Blueprint for objects |
| 4. Module | D. Reusable code |
| 5. Generic | E. Flexible type |
Answers: 1-A, 2-B, 3-C, 4-D, 5-E
“TypeScript Discussion”
In groups, discuss why TypeScript is better than JavaScript. Share examples of where TypeScript is used. Present your findings.
“My TypeScript Plan”
Write a plan for learning TypeScript. Include: what you will learn, resources, and projects. Share your plan with the class.
“TypeScript Presentation”
Create a presentation on TypeScript for an audience of beginners. Include: what it is, why it is used, and an example. Present to the class.
“Install TypeScript and Write Code”
Install TypeScript on your computer. Write a simple TypeScript program. Share your code and experience.
“TypeScript Project Plan”
Design a project that you will build with TypeScript. Include: what it does, what technologies you will use, and your plan. Present your plan to the class.
(Answers to fill-in-the-blank, true/false, and multiple choice are provided within those sections.)
You are now ready to start the Certified TypeScript Programming Expert course. Before Module 1, do the following:
Get ready to learn TypeScript!
End of Course Outline · Let's get started!
Hello, future programmer! Welcome to the first module of Certified TypeScript Programming Expert. In this module, we will meet a powerful tool called TypeScript.
TypeScript is a programming language that helps developers write better and safer code. It is based on JavaScript – the language that powers the web. But TypeScript adds extra features that make it easier to catch mistakes and build large applications.
In this module, you will learn what TypeScript is, why it was created, and how it works. You will also set up your computer to write TypeScript code.
Let's start our journey into the world of TypeScript!
By the end of this module, you will be able to:
In Lagos, a team of developers was building a banking app. The app was written in JavaScript. It worked well – until one day, a bug appeared. Customers were seeing wrong balances, and money was being transferred incorrectly.
The developers spent days trying to find the bug. They checked line after line of code. Finally, they found it – a simple mistake: a string was being used as a number.
One developer, Chidi, said, "This would not have happened if we had used TypeScript. TypeScript would have caught this error before we even ran the code."
The team decided to learn TypeScript. They rewrote the app in TypeScript and the bugs disappeared. Chidi said, "TypeScript saved our business!"
This is why we are here – to learn how TypeScript can help us build better software.
Definition: JavaScript is a programming language used to make websites interactive.
Why is it important? It is the language of the web – almost every website uses it.
Simple explanation: JavaScript makes things move, change, and respond on web pages.
Real-life example: When you click a button and a message pops up, that's JavaScript.
School example: A student uses JavaScript to create a simple game.
Home example: A family uses a web app that was built with JavaScript.
Nigerian example: Nigerian websites use JavaScript for interactivity.
JavaScript = The language of the web
Mini summary: JavaScript makes websites interactive.
Definition: TypeScript is a programming language that adds types to JavaScript.
Why is it important? It helps developers catch errors early and write better code.
Simple explanation: TypeScript is like JavaScript, but with extra safety features.
Real-life example: A developer uses TypeScript to build a large web app.
School example: A student writes TypeScript code for a school project.
Home example: A parent uses a TypeScript app to manage finances.
Nigerian example: Nigerian developers use TypeScript for secure applications.
TypeScript = JavaScript + Types
Mini summary: TypeScript is JavaScript with types.
Definition: TypeScript was created to solve problems with JavaScript, especially when building large applications.
Why is it important? It makes code more reliable and easier to manage.
Simple explanation: JavaScript is flexible, but sometimes too flexible – TypeScript adds structure.
Real-life example: Large companies use TypeScript to prevent bugs.
School example: A student uses TypeScript to keep code organised.
Home example: A family uses a TypeScript app that works reliably.
Nigerian example: Nigerian fintech companies use TypeScript for safety.
Why TypeScript was created: - To catch errors early - To make code easier to understand - To support large projects
Mini summary: TypeScript was created to make JavaScript safer.
Definition: TypeScript works by checking types and converting (compiling) to JavaScript.
Why is it important? It ensures that your code is correct before it runs.
Simple explanation: You write TypeScript, and a compiler checks it and turns it into JavaScript.
Real-life example: A developer writes TypeScript code and runs the compiler.
School example: A student writes TypeScript code and sees the output.
Home example: A family uses an app built with TypeScript.
Nigerian example: A Nigerian team uses TypeScript to build reliable apps.
How TypeScript Works: 1. You write TypeScript code 2. The compiler checks it 3. The compiler converts it to JavaScript 4. The JavaScript runs
Mini summary: TypeScript compiles to JavaScript.
Definition: A type is a label that tells you what kind of value something is – like a number, text, or true/false.
Why is it important? Types help you avoid mistakes – you can't accidentally use a number as text.
Simple explanation: Types are like labels on boxes – they tell you what's inside.
Real-life example: A number type can only hold numbers.
School example: A student uses types to organise data.
Home example: A parent uses types to keep track of expenses.
Nigerian example: A Nigerian developer uses types for data consistency.
Types: - string: text (e.g., "hello") - number: numbers (e.g., 123) - boolean: true/false
Mini summary: Types tell you what kind of value something is.
Definition: Setting up TypeScript means installing it on your computer so you can write and run TypeScript code.
Why is it important? You need to have TypeScript installed to use it.
Simple explanation: You install TypeScript just like you install a game or app.
Real-life example: A developer installs TypeScript to start a project.
School example: A student installs TypeScript for a school project.
Home example: A parent installs TypeScript to learn programming.
Nigerian example: A Nigerian developer sets up TypeScript for a local project.
Steps to Set Up TypeScript: 1. Install Node.js 2. Open the terminal 3. Run: npm install -g typescript 4. Check: tsc --version
Mini summary: Set up TypeScript to start coding.
Definition: Your first TypeScript code is a simple program that prints a message.
Why is it important? It gets you started and shows you how TypeScript works.
Simple explanation: You write code that says "Hello, World!"
Real-life example: A developer writes "Hello, World!" as their first program.
School example: A student writes "Hello, World!" in class.
Home example: A parent writes "Hello, World!" to learn programming.
Nigerian example: A Nigerian developer starts learning with "Hello, World!"
First TypeScript Program: let message: string = "Hello, World!"; console.log(message);
Mini summary: Your first program prints "Hello, World!"
Definition: Compiling means converting TypeScript code to JavaScript.
Why is it important? Browsers only understand JavaScript – you need to compile.
Simple explanation: You run a command that turns TypeScript into JavaScript.
Real-life example: A developer runs "tsc" to compile code.
School example: A student compiles TypeScript code.
Home example: A parent compiles a TypeScript program.
Nigerian example: A Nigerian developer compiles code for a project.
Compiling: tsc filename.ts
Mini summary: Compiling converts TypeScript to JavaScript.
Definition: Running means executing your code to see the output.
Why is it important? You need to see if your code works.
Simple explanation: You run your code and see the result.
Real-life example: A developer runs code to test it.
School example: A student runs code to see if it works.
Home example: A parent runs code to learn.
Nigerian example: A Nigerian developer runs code to build apps.
Running: node filename.js
Mini summary: Running shows you the output of your code.
Definition: A compiler is a program that converts code from one language to another.
Why is it important? It makes your code runnable.
Simple explanation: It translates TypeScript to JavaScript.
Real-life example: The TypeScript compiler is called tsc.
School example: A student uses a compiler for projects.
Home example: A parent uses a compiler to learn.
Nigerian example: A Nigerian developer uses a compiler for apps.
Compiler = A translator for code
Mini summary: A compiler converts TypeScript to JavaScript.
Definition: Benefits are the good things that come from using TypeScript.
Why is it important? It shows why TypeScript is valuable.
Simple explanation: TypeScript helps you catch errors before they happen.
Real-life example: A developer catches a bug before it reaches production.
School example: A student avoids mistakes in code.
Home example: A parent builds reliable apps.
Nigerian example: A Nigerian team builds secure applications.
Benefits: - Catches errors early - Improves code quality - Makes code easier to understand - Supports large projects
Mini summary: TypeScript helps you write better code.
Definition: TypeScript and JavaScript are similar, but TypeScript has extra features.
Why is it important? You need to know the difference to choose the right one.
Simple explanation: TypeScript is JavaScript with superpowers.
Real-life example: A developer chooses TypeScript for a large project.
School example: A student learns both languages.
Home example: A parent uses TypeScript for safer code.
Nigerian example: A Nigerian developer chooses TypeScript for reliability.
JavaScript: Flexible, runs everywhere TypeScript: JavaScript + Types, safer
Mini summary: TypeScript is JavaScript with types.
Definition: Many companies and developers use TypeScript.
Why is it important? It shows that TypeScript is widely adopted.
Real-life example: Microsoft, Google, and Facebook use TypeScript.
School example: A student uses TypeScript for projects.
Home example: A parent uses TypeScript for personal projects.
Nigerian example: Nigerian tech companies use TypeScript.
Companies using TypeScript: - Microsoft - Google - Facebook - Airbnb - Slack
Mini summary: Many large companies use TypeScript.
Definition: TypeScript is becoming more popular and is likely to be a key skill for developers.
Why is it important? Learning TypeScript can help you get a job.
Simple explanation: TypeScript is a valuable skill for the future.
Real-life example: Many job postings ask for TypeScript skills.
School example: A student learns TypeScript to prepare for a career.
Home example: A parent learns TypeScript for career growth.
Nigerian example: Nigerian developers are learning TypeScript.
TypeScript is a skill for the future.
Mini summary: TypeScript is a valuable future skill.
Definition: You are now a TypeScript programmer – you know the basics.
Why is it important? You have started your journey to becoming a TypeScript expert.
Simple explanation: You have written your first TypeScript program.
Real-life example: You can now build simple TypeScript apps.
School example: You can use TypeScript for school projects.
Home example: You can practice TypeScript at home.
Nigerian example: You can contribute to Nigerian tech projects.
TypeScript Programmer Checklist: - Understands TypeScript basics - Can set up TypeScript - Can write simple programs - Knows how to compile and run
Mini summary: You are on your way to becoming a TypeScript expert!
| Word | Simple Definition |
|---|---|
| TypeScript | A programming language with types. |
| JavaScript | The language of the web. |
| Type | A label for values. |
| Compiler | A program that converts code. |
| String | Text in programming. |
| Number | A numeric value. |
| Boolean | True or false. |
| Variable | A container for data. |
| Function | A block of code that does a task. |
| Console | A place to see output. |
Write TypeScript
|
V
Compile to JavaScript
|
V
Run JavaScript
|
V
See Output
+-----------------------+-----------------------+ | JavaScript | TypeScript | +-----------------------+-----------------------+ | Dynamic types | Static types | | Errors at runtime | Errors at compile | | Less safe | More safe | | No type checking | Type checking | | Flexible | Structured | +-----------------------+-----------------------+
| Type | What It Represents | Example |
|---|---|---|
| string | Text | "Hello" |
| number | Number | 123 |
| boolean | True/False | true |
| array | List of items | [1,2,3] |
| object | Collection of properties | {name:"John"} |
| Feature | Purpose | Benefit |
|---|---|---|
| Types | Define data | Error prevention |
| Interfaces | Shape objects | Consistency |
| Classes | Create blueprints | Reusability |
| Modules | Organise code | Maintainability |
(Included after each lesson above – review them!)
In this first module, you have learned the basics of TypeScript. You discovered what TypeScript is, why it was created, and how it works. You learned about types and how they help catch errors. You also set up TypeScript on your computer and wrote your first program. You are now on your way to becoming a TypeScript expert. In the next module, you will learn about basic types. Congratulations on completing Module One!
Match the term with its definition.
| Term | Definition |
|---|---|
| 1. TypeScript | A. Language with types |
| 2. JavaScript | B. Language of the web |
| 3. Type | C. Label for values |
| 4. Compiler | D. Converts code |
| 5. String | E. Text |
Answers: 1-A, 2-B, 3-C, 4-D, 5-E
“TypeScript Discussion”
In groups, discuss why TypeScript is better than JavaScript. Share examples of where TypeScript is used. Present your findings.
“My TypeScript Plan”
Write a plan for learning TypeScript. Include: what you will learn, resources, and projects. Share your plan with the class.
“TypeScript Presentation”
Create a presentation on TypeScript for an audience of beginners. Include: what it is, why it is used, and an example. Present to the class.
“Install TypeScript and Write Code”
Install TypeScript on your computer. Write a simple TypeScript program. Share your code and experience.
“TypeScript Project Plan”
Design a project that you will build with TypeScript. Include: what it does, what technologies you will use, and your plan. Present your plan to the class.
(Answers to fill-in-the-blank, true/false, and multiple choice are provided within those sections.)
In Module Two, you will learn about basic types. To prepare:
Get ready to learn about types in TypeScript!
End of Module One · Welcome to the world of TypeScript!
Hello, TypeScript builder! In Module One, you learned what TypeScript is and how it works. Now it is time to learn about the building blocks of TypeScript – types.
Types are like labels that tell you what kind of value something is. They help you avoid mistakes and make your code safer. In this module, you will learn about the most common types: string, number, boolean, array, and tuple.
Let's start building with TypeScript types!
By the end of this module, you will be able to:
In Lagos, a young developer named Ada was building a shopping app. She had to store customer names, prices, and whether an item was in stock. She wrote her code in JavaScript.
But she made a mistake – she accidentally used a string (text) where she should have used a number (price). The app showed the wrong price, and customers were confused.
Her mentor said, "Ada, you need to use types. TypeScript would have caught this error. Types are like labels – they tell you what kind of value you are using."
Ada switched to TypeScript. She used the string type for names, number for prices, and boolean for stock status. The errors disappeared. Ada said, "Types are like labels – they keep my code organised and safe!"
Definition: A type is a label that tells you what kind of value something is – like a number, text, or true/false.
Why is it important? Types help you avoid mistakes – you can't accidentally use a number as text.
Simple explanation: Types are like labels on boxes – they tell you what's inside.
Real-life example: A number type can only hold numbers.
School example: A student uses types to organise data.
Home example: A parent uses types to keep track of expenses.
Nigerian example: A Nigerian developer uses types for data consistency.
Types: - string: text (e.g., "hello") - number: numbers (e.g., 123) - boolean: true/false
Mini summary: Types tell you what kind of value something is.
Definition: The string type is used for text – like words, sentences, or names.
Why is it important? Most data in programs is text – names, descriptions, and messages.
Simple explanation: A string is anything inside quotes – "hello", "Ada", "123" as text.
Real-life example: "Ada" is a string.
School example: A student's name is a string.
Home example: A family member's name is a string.
Nigerian example: "Lagos" is a string.
let name: string = "Ada"; let city: string = "Lagos";
Mini summary: The string type is for text.
Definition: The number type is used for numbers – like 5, 10, or 3.14.
Why is it important? Numbers are used for prices, ages, quantities, and more.
Simple explanation: A number is any numeric value – positive, negative, or decimal.
Real-life example: A price of ₦500 is a number.
School example: A student's age is a number.
Home example: The number of family members is a number.
Nigerian example: The price of a product is a number.
let age: number = 25; let price: number = 500.50;
Mini summary: The number type is for numbers.
Definition: The boolean type is for true or false values.
Why is it important? Booleans are used for conditions – like "is it in stock?" or "is it available?"
Simple explanation: A boolean is either true or false.
Real-life example: "Is the light on?" – true or false.
School example: "Did you finish your homework?" – true or false.
Home example: "Is the door locked?" – true or false.
Nigerian example: "Is the item in stock?" – true or false.
let isAvailable: boolean = true; let isExpired: boolean = false;
Mini summary: The boolean type is for true or false.
Definition: An array is a list of values – like a list of names or numbers.
Why is it important? Arrays are used to store multiple items in one place.
Simple explanation: An array is like a shopping list – it holds many items.
Real-life example: A list of customer names.
School example: A list of student grades.
Home example: A list of family members.
Nigerian example: A list of product prices.
let names: string[] = ["Ada", "Chidi", "Bola"]; let prices: number[] = [100, 200, 300];
Mini summary: Arrays hold lists of values.
Definition: A tuple is like an array, but with a fixed number of items and types.
Why is it important? Tuples are used when you know exactly how many items and what types.
Simple explanation: A tuple is a fixed-size list with specific types.
Real-life example: A tuple for a person's name and age – ["Ada", 25].
School example: A tuple for a student's name and grade.
Home example: A tuple for a family member's name and age.
Nigerian example: A tuple for a product name and price.
let person: [string, number] = ["Ada", 25]; let product: [string, number] = ["Rice", 500];
Mini summary: Tuples are fixed-size lists with specific types.
Definition: The any type can hold any value – string, number, boolean, or anything.
Why is it important? It is useful when you are not sure what type a value will be.
Simple explanation: Any is like a wildcard – it can be anything.
Real-life example: A variable that can be a string or a number.
School example: A variable that can hold different types of data.
Home example: A variable that can be anything.
Nigerian example: A variable that can hold any value.
let value: any = "hello"; value = 123; // This is allowed
Mini summary: The any type can hold anything.
Definition: The void type is used for functions that do not return anything.
Why is it important? It tells you that a function does not produce a value.
Simple explanation: Void means "nothing" – the function does not return a value.
Real-life example: A function that prints a message but does not return anything.
School example: A function that displays a grade but does not return it.
Home example: A function that displays a message but does not return anything.
Nigerian example: A function that logs a message but does not return a value.
function greet(): void {
console.log("Hello!");
}
Mini summary: The void type means no return value.
Definition: Type annotations are the way you tell TypeScript what type a variable should be.
Why is it important? They make your code clear and help catch errors.
Simple explanation: You write a colon and the type after the variable name.
Real-life example: let name: string = "Ada";
School example: let grade: number = 90;
Home example: let isActive: boolean = true;
Nigerian example: let city: string = "Lagos";
let name: string = "Ada"; let age: number = 25; let isStudent: boolean = true;
Mini summary: Type annotations tell TypeScript what type to use.
Definition: Type inference is when TypeScript automatically guesses the type of a variable.
Why is it important? It saves you from writing the type every time.
Simple explanation: TypeScript is smart – it can often guess the type from the value.
Real-life example: let name = "Ada"; – TypeScript knows it's a string.
School example: let age = 25; – TypeScript knows it's a number.
Home example: let isReady = true; – TypeScript knows it's a boolean.
Nigerian example: let city = "Lagos"; – TypeScript knows it's a string.
let name = "Ada"; // TypeScript infers string let age = 25; // TypeScript infers number
Mini summary: Type inference saves you from writing types.
Definition: Functions can have types for parameters and return values.
Why is it important? It ensures that functions are used correctly.
Simple explanation: You tell TypeScript what types the function expects and returns.
Real-life example: function add(a: number, b: number): number { return a + b; }
School example: function getGrade(name: string): number { ... }
Home example: function calculatePrice(price: number, tax: number): number { ... }
Nigerian example: function getProduct(name: string): string { ... }
function add(a: number, b: number): number {
return a + b;
}
Mini summary: Functions can have type annotations.
Definition: Common mistakes are errors that beginners often make with types.
Why is it important? Avoiding them saves time and frustration.
Simple explanation: Don't assign a string to a number variable.
Real-life example: let age: number = "twenty"; // Error!
School example: let grade: number = "A"; // Error!
Home example: let isReady: boolean = "yes"; // Error!
Nigerian example: let price: number = "five hundred"; // Error!
let age: number = "twenty"; // Type error let name: string = 123; // Type error
Mini summary: Avoid assigning the wrong type to a variable.
Definition: Best practices are the recommended ways to use types.
Why is it important? They make your code clean and safe.
Simple explanation: Always use types – they help catch errors.
Real-life example: Use string for text, number for numbers, boolean for true/false.
School example: Use types to organise your code.
Home example: Use types to avoid mistakes.
Nigerian example: Use types for reliable apps.
let name: string = "Ada"; // Good let age: number = 25; // Good let isStudent: boolean = true; // Good
Mini summary: Use types to make your code safe.
Definition: Types are not just for code – they are everywhere in life.
Why is it important? It shows that types are natural and easy to understand.
Simple explanation: You use types every day – like labels on boxes.
Real-life example: A box labelled "books" holds books.
School example: A folder labelled "homework" holds homework.
Home example: A drawer labelled "socks" holds socks.
Nigerian example: A container labelled "rice" holds rice.
Types are like labels – they tell you what's inside.
Mini summary: Types are natural and easy to understand.
Definition: You are now a type master – you understand the basic types in TypeScript.
Why is it important? You can now write TypeScript code with confidence.
Simple explanation: You have mastered the building blocks of TypeScript.
Real-life example: You can now build simple TypeScript apps.
School example: You can use types in school projects.
Home example: You can practice TypeScript at home.
Nigerian example: You can build apps with TypeScript in Nigeria.
Type Master Checklist: - Understands string, number, boolean - Can use arrays and tuples - Knows any and void - Uses type annotations - Understands type inference
Mini summary: You are now a type master!
| Word | Simple Definition |
|---|---|
| Type | A label for values. |
| String | Text in programming. |
| Number | A numeric value. |
| Boolean | True or false. |
| Array | A list of values. |
| Tuple | A fixed-size list. |
| Any | Can hold any value. |
| Void | No return value. |
| Annotation | You write the type. |
| Inference | TypeScript guesses the type. |
Types in TypeScript
|
+-- String (text)
|
+-- Number (numbers)
|
+-- Boolean (true/false)
|
+-- Array (list)
|
+-- Tuple (fixed list)
let name: string = "Ada"; let age: number = 25; let isStudent: boolean = true; let grades: number[] = [90, 85, 88]; let person: [string, number] = ["Ada", 25];
| Type | What It Represents | Example |
|---|---|---|
| string | Text | "Hello" |
| number | Number | 123 |
| boolean | True/False | true |
| array | List of items | [1,2,3] |
| tuple | Fixed-size list | ["Ada", 25] |
| Type | Used For | Example |
|---|---|---|
| any | Any value | let a: any = "hello"; |
| void | No return value | function greet(): void {} |
(Included after each lesson above – review them!)
In this module, you learned about the basic types in TypeScript. You discovered the string, number, and boolean types. You also learned about arrays, tuples, any, and void. You learned to use type annotations and understand type inference. You are now a type master. In the next module, you will learn about interfaces and types. Congratulations on completing Module Two!
Match the term with its definition.
| Term | Definition |
|---|---|
| 1. String | A. Text |
| 2. Number | B. Numeric value |
| 3. Boolean | C. True/False |
| 4. Array | D. List of values |
| 5. Tuple | E. Fixed-size list |
Answers: 1-A, 2-B, 3-C, 4-D, 5-E
“Type Exploration”
In groups, create a list of everyday items and assign types to each part (name, price, etc.). Share your examples with the class.
“My Type Examples”
Write TypeScript code using string, number, boolean, array, and tuple. Share your code with the class.
“TypeScript Data Model”
Create a data model for a business (like a store or a school) using types. Include string, number, boolean, array, and tuple. Present your model to the class.
“Write TypeScript Code”
Write a TypeScript program that uses string, number, boolean, array, and tuple. Compile and run it. Share your code and output.
“Type Challenge”
Create a complex data structure using all the basic types. Include an array of objects, each with string, number, boolean, and tuple properties. Share your solution.
(Answers to fill-in-the-blank, true/false, and multiple choice are provided within those sections.)
In Module Three, you will learn about interfaces and types. To prepare:
Get ready to learn about interfaces!
End of Module Two · You are now a type master!
Hello, object builder! In Module Two, you learned about basic types like string, number, and boolean. Now it is time to learn how to describe objects – things that have many properties.
In TypeScript, we use interfaces and type aliases to describe the shape of objects. They help you define what properties an object should have and what types those properties should be.
In this module, you will learn how to use interfaces and type aliases to create clear, organised, and safe code.
Let's start describing objects with TypeScript!
By the end of this module, you will be able to:
In Lagos, a developer named Kemi was building an app for a store. She needed to store information about customers – name, age, email, and whether they were active.
She tried using basic types, but it was messy. She had to remember that a customer had a name (string), age (number), email (string), and isActive (boolean).
Her mentor said, "Kemi, you need an interface – it's like a blueprint that describes what a customer should look like."
Kemi created an interface called Customer. It defined that a customer has a name (string), age (number), email (string), and isActive (boolean).
Now, whenever she created a customer, TypeScript checked that it had all the right properties. Kemi said, "Interfaces make my code so much cleaner and safer!"
Definition: An object is a collection of properties – like a person with a name, age, and email.
Why is it important? Objects are used to represent real-world things in code.
Simple explanation: An object is like a box that holds many pieces of information.
Real-life example: A customer has a name, age, and email.
School example: A student has a name, grade, and class.
Home example: A family member has a name, age, and role.
Nigerian example: A product has a name, price, and description.
let customer = {
name: "Ada",
age: 25,
email: "ada@example.com"
};
Mini summary: Objects hold collections of properties.
Definition: An interface is a way to describe the shape of an object – what properties it should have and what types they are.
Why is it important? It helps you define a blueprint for objects.
Simple explanation: An interface is like a template for an object.
Real-life example: A blueprint for a house.
School example: A template for a student record.
Home example: A form that needs to be filled out.
Nigerian example: A template for a product listing.
interface Customer {
name: string;
age: number;
email: string;
}
Mini summary: An interface describes the shape of an object.
Definition: You use an interface by applying it to an object – the object must have the properties defined in the interface.
Why is it important? It ensures that objects have the correct shape.
Simple explanation: You tell TypeScript that an object should follow the interface.
Real-life example: let customer: Customer = { name: "Ada", age: 25, email: "ada@example.com" };
School example: let student: Student = { name: "Chidi", grade: 90 };
Home example: let person: Person = { name: "Bola", age: 30 };
Nigerian example: let product: Product = { name: "Rice", price: 500 };
let customer: Customer = {
name: "Ada",
age: 25,
email: "ada@example.com"
};
Mini summary: You apply an interface to an object.
Definition: Optional properties are properties that do not have to be present in the object.
Why is it important? Sometimes an object may not have all properties.
Simple explanation: You add a ? after the property name to make it optional.
Real-life example: A customer may or may not have a phone number.
School example: A student may or may not have an email address.
Home example: A family member may or may not have a middle name.
Nigerian example: A product may or may not have a description.
interface Customer {
name: string;
age: number;
email?: string; // optional
}
Mini summary: Optional properties are not required.
Definition: Readonly properties cannot be changed after they are set.
Why is it important? It protects data that should not be modified.
Simple explanation: You add readonly before the property name.
Real-life example: A customer's ID should not be changed.
School example: A student's enrolment number should not be changed.
Home example: A family member's date of birth should not be changed.
Nigerian example: A product's SKU should not be changed.
interface Customer {
readonly id: number;
name: string;
age: number;
}
Mini summary: Readonly properties cannot be changed.
Definition: A type alias is a way to give a name to a type – it can be used for any type, not just objects.
Why is it important? It makes complex types easier to use.
Simple explanation: A type alias is like a nickname for a type.
Real-life example: type Name = string;
School example: type Grade = number;
Home example: type Age = number;
Nigerian example: type Price = number;
type Name = string;
type Age = number;
type Person = {
name: Name;
age: Age;
};
Mini summary: A type alias gives a name to a type.
Definition: Interfaces and type aliases are similar but have some differences.
Why is it important? You need to choose the right tool for the job.
Simple explanation: Interfaces are best for objects; type aliases can be used for anything.
Real-life example: Use interface for a customer object.
School example: Use interface for a student record.
Home example: Use type alias for a simple type like number.
Nigerian example: Use interface for a product.
interface Customer {
name: string;
age: number;
}
type ID = string | number;
Mini summary: Interfaces are for objects; type aliases are for any type.
Definition: You can extend an interface to create a new interface that includes all properties of the original.
Why is it important? It promotes reusability.
Simple explanation: Like inheriting from a parent.
Real-life example: A VIPCustomer extends Customer with a discount property.
School example: A GraduateStudent extends Student with a degree property.
Home example: A FamilyMember extends Person with a role property.
Nigerian example: A PremiumProduct extends Product with a warranty property.
interface Customer {
name: string;
age: number;
}
interface VIPCustomer extends Customer {
discount: number;
}
Mini summary: Extending interfaces reuses properties.
Definition: Intersection types combine multiple types into one.
Why is it important? It allows you to combine types.
Simple explanation: Like mixing two things together.
Real-life example: A Customer and a VIP combined.
School example: A Student and an Athlete combined.
Home example: A Person and a Worker combined.
Nigerian example: A Product and a DiscountedProduct combined.
type Customer = { name: string; age: number };
type VIP = { discount: number };
type VIPCustomer = Customer & VIP;
Mini summary: Intersection types combine types.
Definition: Union types allow a value to be one of several types.
Why is it important? It provides flexibility.
Simple explanation: Like saying "this can be a string or a number."
Real-life example: A customer's ID can be a string or a number.
School example: A student's grade can be a number or a letter.
Home example: A family member's age can be a number or "unknown."
Nigerian example: A product's price can be a number or "free."
type ID = string | number; let id: ID = "123"; id = 123; // also valid
Mini summary: Union types allow multiple types.
Definition: You can use interfaces to describe the shape of parameters and return values.
Why is it important? It ensures functions are used correctly.
Simple explanation: You tell TypeScript what kind of object a function expects.
Real-life example: function greet(customer: Customer): string { ... }
School example: function getGrade(student: Student): number { ... }
Home example: function getAge(person: Person): number { ... }
Nigerian example: function getPrice(product: Product): number { ... }
interface Customer {
name: string;
age: number;
}
function greet(customer: Customer): string {
return `Hello ${customer.name}`;
}
Mini summary: Interfaces can describe function parameters.
Definition: Type assertions tell TypeScript that you know more about the type than it does.
Why is it important? It helps when you are sure about the type.
Simple explanation: Like saying "trust me, I know what type this is."
Real-life example: let value =
School example: let result =
Home example: let item =
Nigerian example: let product =
let someValue: any = { name: "Ada", age: 25 };
let customer = someValue;
Mini summary: Type assertions tell TypeScript what type to expect.
Definition: Common mistakes are errors that beginners often make with interfaces.
Why is it important? Avoiding them saves time and frustration.
Simple explanation: Don't forget required properties.
Real-life example: Missing a required property in an object.
School example: Forgetting to include a student's name.
Home example: Forgetting a family member's age.
Nigerian example: Forgetting a product's price.
interface Customer {
name: string;
age: number;
}
// Error: missing age
let customer: Customer = { name: "Ada" };
Mini summary: Always include required properties.
Definition: Best practices are the recommended ways to use interfaces.
Why is it important? They make your code clean and safe.
Simple explanation: Use interfaces to describe objects, and use type aliases for other types.
Real-life example: Use interface for customer, product, etc.
School example: Use interface for student, teacher, etc.
Home example: Use interface for person, family, etc.
Nigerian example: Use interface for product, order, etc.
interface Customer {
name: string;
age: number;
email?: string;
}
Mini summary: Use interfaces for objects; use type aliases for other types.
Definition: You are now an interface master – you can describe objects with interfaces and type aliases.
Why is it important? You can now write clean, organised, and safe code.
Simple explanation: You have mastered interfaces and type aliases.
Real-life example: You can now define complex objects in your code.
School example: You can use interfaces in school projects.
Home example: You can practice at home.
Nigerian example: You can build apps with TypeScript in Nigeria.
Interface Master Checklist: - Defines interfaces - Uses optional and readonly properties - Uses type aliases - Extends interfaces - Uses union and intersection types
Mini summary: You are now an interface master!
| Word | Simple Definition |
|---|---|
| Interface | A description of an object's shape. |
| Object | A collection of properties. |
| Property | A piece of data inside an object. |
| Optional | Not required. |
| Readonly | Cannot be changed. |
| Type Alias | A name for a type. |
| Extend | Inherit from another interface. |
| Union | One of several types. |
| Intersection | Combine multiple types. |
| Assertion | Tell TypeScript the type. |
interface Customer {
name: string;
age: number;
email?: string;
}
type ID = string | number;
type Person = {
name: string;
age: number;
};
+-----------------------+-----------------------+ | Interface | Type Alias | +-----------------------+-----------------------+ | For objects | For any type | | Extendable | Not extendable | | Best for objects | Best for simple types | | More readable | More flexible | +-----------------------+-----------------------+
| Feature | Interface | Type Alias |
|---|---|---|
| For objects | Yes | Yes |
| For primitives | No | Yes |
| Extendable | Yes | No |
| Union types | No | Yes |
| Tuple types | No | Yes |
| Type | Description | Example |
|---|---|---|
| Required | Must be present | name: string |
| Optional | May be present | email?: string |
| Readonly | Cannot be changed | readonly id: number |
(Included after each lesson above – review them!)
In this module, you learned about interfaces and type aliases. You discovered how to describe objects using interfaces and how to give names to types using type aliases. You also learned about optional properties, readonly properties, extending interfaces, and union and intersection types. You are now an interface master. In the next module, you will learn about functions in TypeScript. Congratulations on completing Module Three!
Match the term with its definition.
| Term | Definition |
|---|---|
| 1. Interface | A. Describes an object |
| 2. Type Alias | B. Name for a type |
| 3. Optional | C. Not required |
| 4. Readonly | D. Cannot be changed |
| 5. Union | E. One of several types |
Answers: 1-A, 2-B, 3-C, 4-D, 5-E
“Interface Design”
In groups, design interfaces for a real-world scenario (like a store or a school). Share your designs with the class.
“My Interfaces”
Define interfaces for a business scenario (like a store or a school). Use optional and readonly properties. Share your code with the class.
“TypeScript Data Model”
Create a complete data model for a business using interfaces and type aliases. Include optional and readonly properties. Present your model to the class.
“Write TypeScript Code”
Write a TypeScript program that uses interfaces and type aliases. Include optional and readonly properties. Compile and run it. Share your code and output.
“Interface Challenge”
Create a complex data structure using interfaces, type aliases, union types, and intersection types. Share your solution with the class.
(Answers to fill-in-the-blank, true/false, and multiple choice are provided within those sections.)
In Module Four, you will learn about functions. To prepare:
Get ready to learn about functions in TypeScript!
End of Module Three · You are now an interface master!
Hello, function builder! In Module Three, you learned about interfaces and types. Now it is time to learn about functions – the building blocks of any program.
Functions are reusable blocks of code that perform a specific task. They help you organise your code, avoid repetition, and make your programs more powerful. In TypeScript, functions can have types for parameters and return values.
In this module, you will learn how to write functions with type annotations, use optional and default parameters, and work with arrow functions.
Let's start building functions with TypeScript!
By the end of this module, you will be able to:
In Lagos, a developer named Olu was building a calculator app. He had to write the same code many times to add, subtract, multiply, and divide numbers.
His mentor said, "Olu, you should use functions – they are reusable blocks of code. Write a function for each operation."
Olu wrote a function for addition, one for subtraction, and so on. He could now use them again and again. He said, "Functions saved me so much time!"
Definition: A function is a block of code that performs a specific task.
Why is it important? Functions help you reuse code and keep things organised.
Simple explanation: A function is like a recipe – you can use it whenever you want.
Real-life example: A recipe for making jollof rice.
School example: A formula for calculating grades.
Home example: A routine for cleaning the house.
Nigerian example: A function for calculating prices with VAT.
function greet() {
console.log("Hello!");
}
Mini summary: Functions are reusable blocks of code.
Definition: Parameters are values that you pass to a function for it to use.
Why is it important? They make functions flexible and reusable.
Simple explanation: Parameters are like ingredients in a recipe.
Real-life example: A function that greets a person by name.
School example: A function that calculates a student's grade.
Home example: A function that calculates the cost of groceries.
Nigerian example: A function that calculates tax.
function greet(name: string) {
console.log(`Hello ${name}!`);
}
Mini summary: Parameters let you pass data to functions.
Definition: A return type is the type of value that a function returns.
Why is it important? It tells you what kind of value the function produces.
Simple explanation: It's like what you get after following a recipe.
Real-life example: A function that returns a number.
School example: A function that returns a grade.
Home example: A function that returns the total cost.
Nigerian example: A function that returns the price with tax.
function add(a: number, b: number): number {
return a + b;
}
Mini summary: Return types tell you what a function produces.
Definition: Optional parameters are parameters that are not required.
Why is it important? They give you flexibility.
Simple explanation: You can call the function with or without the parameter.
Real-life example: A function that greets a person, but you can skip the name.
School example: A function that grades a student, but you can skip the subject.
Home example: A function that calculates cost, but you can skip the tax.
Nigerian example: A function that calculates price, with an optional discount.
function greet(name?: string) {
if (name) {
console.log(`Hello ${name}!`);
} else {
console.log("Hello!");
}
}
Mini summary: Optional parameters are not required.
Definition: Default parameters have a default value if no value is provided.
Why is it important? They ensure that a function always has a value.
Simple explanation: You provide a fallback value.
Real-life example: A function that greets a person, with a default name.
School example: A function that calculates grades, with a default subject.
Home example: A function that calculates cost, with a default tax rate.
Nigerian example: A function that calculates price, with a default discount.
function greet(name: string = "Guest") {
console.log(`Hello ${name}!`);
}
Mini summary: Default parameters have a fallback value.
Definition: Arrow functions are a shorter way to write functions.
Why is it important? They make your code more concise.
Simple explanation: It's like a shortcut for writing functions.
Real-life example: const greet = (name: string) => console.log(`Hello ${name}!`);
School example: const add = (a: number, b: number) => a + b;
Home example: const multiply = (a: number, b: number) => a * b;
Nigerian example: const tax = (price: number) => price * 0.075;
const add = (a: number, b: number): number => {
return a + b;
};
Mini summary: Arrow functions are a shorter way to write functions.
Definition: Function types describe the shape of a function – its parameters and return type.
Why is it important? They help you use functions as values.
Simple explanation: You can assign functions to variables.
Real-life example: let add: (a: number, b: number) => number;
School example: let grade: (score: number) => string;
Home example: let cost: (price: number, tax: number) => number;
Nigerian example: let tax: (price: number) => number;
let add: (a: number, b: number) => number; add = (a, b) => a + b;
Mini summary: Function types describe the shape of functions.
Definition: Void functions do not return anything.
Why is it important? They are used for actions, not calculations.
Simple explanation: They perform a task but don't give back a value.
Real-life example: A function that prints a message.
School example: A function that displays a grade.
Home example: A function that shows a cost.
Nigerian example: A function that logs a transaction.
function greet(name: string): void {
console.log(`Hello ${name}!`);
}
Mini summary: Void functions do not return a value.
Definition: Rest parameters allow a function to accept any number of arguments.
Why is it important? They are useful when you don't know how many arguments you'll get.
Simple explanation: You can pass as many values as you want.
Real-life example: A function that adds any number of numbers.
School example: A function that averages any number of scores.
Home example: A function that calculates total cost of multiple items.
Nigerian example: A function that calculates total price with tax.
function sum(...numbers: number[]): number {
return numbers.reduce((acc, cur) => acc + cur, 0);
}
Mini summary: Rest parameters accept any number of arguments.
Definition: Function overloads allow a function to have different parameter types.
Why is it important? They provide flexibility.
Simple explanation: You can call the same function with different types.
Real-life example: A function that can accept a string or a number.
School example: A function that can accept a name or an ID.
Home example: A function that can accept a price or a discount.
Nigerian example: A function that can accept a product name or ID.
function greet(name: string): void;
function greet(age: number): void;
function greet(value: any): void {
console.log(value);
}
Mini summary: Function overloads allow different parameter types.
Definition: You can use interfaces to describe functions.
Why is it important? It makes your code more organised.
Simple explanation: You define a function shape with an interface.
Real-life example: interface Add { (a: number, b: number): number; }
School example: interface Grade { (score: number): string; }
Home example: interface Cost { (price: number, tax: number): number; }
Nigerian example: interface Tax { (price: number): number; }
interface Add {
(a: number, b: number): number;
}
let add: Add = (a, b) => a + b;
Mini summary: Interfaces can describe functions.
Definition: Common mistakes are errors that beginners often make with functions.
Why is it important? Avoiding them saves time and frustration.
Simple explanation: Don't forget to return a value.
Real-life example: Forgetting to return a number from a function.
School example: Forgetting to return a grade.
Home example: Forgetting to return a total cost.
Nigerian example: Forgetting to return a price.
function add(a: number, b: number): number {
// Missing return statement
}
Mini summary: Always return a value if the function expects one.
Definition: Best practices are the recommended ways to write functions.
Why is it important? They make your code clean and safe.
Simple explanation: Use types for parameters and return values.
Real-life example: function add(a: number, b: number): number { return a + b; }
School example: function getGrade(score: number): string { ... }
Home example: function getCost(price: number, tax: number): number { ... }
Nigerian example: function calculateTax(price: number): number { ... }
function add(a: number, b: number): number {
return a + b;
}
Mini summary: Use types for parameters and return values.
Definition: Functions are not just for code – they are everywhere in life.
Why is it important? It shows that functions are natural and easy to understand.
Simple explanation: You use functions every day – like recipes and routines.
Real-life example: A recipe is like a function.
School example: A formula is like a function.
Home example: A cleaning routine is like a function.
Nigerian example: A cooking process is like a function.
Functions are like recipes – they give you instructions.
Mini summary: Functions are natural and easy to understand.
Definition: You are now a function master – you understand functions in TypeScript.
Why is it important? You can now write reusable, organised code.
Simple explanation: You have mastered functions.
Real-life example: You can now write functions for any task.
School example: You can use functions in school projects.
Home example: You can practice at home.
Nigerian example: You can build apps with functions in Nigeria.
Function Master Checklist: - Understands parameters and return types - Uses optional and default parameters - Writes arrow functions - Knows function types - Uses rest parameters
Mini summary: You are now a function master!
| Word | Simple Definition |
|---|---|
| Function | A reusable block of code. |
| Parameter | Input to a function. |
| Return | The output of a function. |
| Optional | Not required. |
| Default | A fallback value. |
| Arrow | A shorter function syntax. |
| Void | No return value. |
| Rest | Any number of arguments. |
| Overload | Different parameter types. |
| Interface | Describes a function shape. |
function add(a: number, b: number): number {
return a + b;
}
const add = (a: number, b: number): number => a + b;
+-----------------------+-----------------------+
| Function | Arrow Function |
+-----------------------+-----------------------+
| function add(a,b){...}| const add=(a,b)=>... |
| Has its own 'this' | No own 'this' |
| Can be used as method | Best for callbacks |
| More verbose | More concise |
| Traditional | Modern |
+-----------------------+-----------------------+
| Type | Description | Example |
|---|---|---|
| Regular | Standard function | function add(a: number, b: number): number |
| Arrow | Concise function | const add = (a: number, b: number): number => a + b |
| Void | No return value | function greet(name: string): void |
| Rest | Any number of arguments | function sum(...numbers: number[]): number |
| Type | Description | Example |
|---|---|---|
| Required | Must be provided | function greet(name: string) |
| Optional | May be omitted | function greet(name?: string) |
| Default | Has a fallback value | function greet(name: string = "Guest") |
| Rest | Any number of arguments | function sum(...numbers: number[]) |
(Included after each lesson above – review them!)
In this module, you learned about functions in TypeScript. You discovered how to write functions with parameters and return types. You also learned about optional parameters, default parameters, arrow functions, and rest parameters. You are now a function master. In the next module, you will learn about classes and objects. Congratulations on completing Module Four!
Match the term with its definition.
| Term | Definition |
|---|---|
| 1. Function | A. Reusable block of code |
| 2. Parameter | B. Input to a function |
| 3. Return | C. Output of a function |
| 4. Optional | D. Not required |
| 5. Default | E. Fallback value |
Answers: 1-A, 2-B, 3-C, 4-D, 5-E
“Function Design”
In groups, design functions for a real-world scenario (like a calculator or a store). Share your functions with the class.
“My Functions”
Write functions for a business scenario (like a store or a school). Use parameters and return types. Share your code with the class.
“Function Library”
Create a library of functions for a business. Include functions for calculations, greetings, and validation. Present your library to the class.
“Write TypeScript Functions”
Write a TypeScript program with multiple functions. Include parameters, return types, optional parameters, and arrow functions. Compile and run it. Share your code and output.
“Function Challenge”
Create a complex function that uses optional parameters, default parameters, and rest parameters. Share your solution with the class.
(Answers to fill-in-the-blank, true/false, and multiple choice are provided within those sections.)
In Module Five, you will learn about classes and objects. To prepare:
Get ready to learn about classes!
End of Module Four · You are now a function master!
Hello, object builder! In Module Four, you learned about functions. Now it is time to learn about classes and objects – the blueprints for creating real-world things in code.
Classes are like blueprints or templates. They describe how to create objects. Objects are things you create from classes – like a specific person, car, or product.
In this module, you will learn how to create classes, use constructors, add properties and methods, and create objects from your classes.
Let's start building with classes and objects!
By the end of this module, you will be able to:
In Lagos, a car company wanted to build many cars. Instead of building each car from scratch, they created a blueprint – a design that described what a car should look like and how it should work.
The blueprint said: "A car has a brand, a model, and a colour. It can start, stop, and drive."
Using this blueprint, they could create many cars – each with different brands, models, and colours.
In programming, a class is like that blueprint. An object is the actual car built from the blueprint. This is what we will learn in this module!
Definition: A class is a blueprint for creating objects.
Why is it important? Classes help you organise and reuse code.
Simple explanation: A class is like a recipe – it tells you how to make something.
Real-life example: A blueprint for a house.
School example: A template for a student record.
Home example: A recipe for a meal.
Nigerian example: A design for a traditional outfit.
class Car {
// Blueprint for cars
}
Mini summary: A class is a blueprint for objects.
Definition: An object is an instance of a class – a real thing created from the blueprint.
Why is it important? Objects are what you actually use in your program.
Simple explanation: An object is a specific thing made from a class.
Real-life example: A specific car (Toyota Camry) is an object.
School example: A specific student is an object.
Home example: A specific meal is an object.
Nigerian example: A specific Ankara outfit is an object.
let myCar = new Car();
Mini summary: An object is an instance of a class.
Definition: You create a class using the class keyword.
Why is it important? It defines the structure for your objects.
Simple explanation: You write a class to describe what objects will look like.
Real-life example: class Car { }
School example: class Student { }
Home example: class Recipe { }
Nigerian example: class Outfit { }
class Car {
brand: string;
model: string;
}
Mini summary: The class keyword creates a class.
Definition: Properties are the data that a class holds – like brand, model, or colour.
Why is it important? They define the characteristics of an object.
Simple explanation: Properties are the attributes of an object.
Real-life example: A car has brand, model, and colour.
School example: A student has name, grade, and class.
Home example: A recipe has name, ingredients, and instructions.
Nigerian example: An outfit has type, colour, and size.
class Car {
brand: string;
model: string;
colour: string;
}
Mini summary: Properties are the data of a class.
Definition: Methods are functions inside a class that define behaviour.
Why is it important? They describe what objects can do.
Simple explanation: Methods are actions that an object can perform.
Real-life example: A car can start, stop, and drive.
School example: A student can study, take tests, and graduate.
Home example: A recipe can be cooked and served.
Nigerian example: An outfit can be worn and washed.
class Car {
start(): void {
console.log("Car started");
}
}
Mini summary: Methods are actions a class can perform.
Definition: A constructor is a special method that initialises an object when it is created.
Why is it important? It sets up the initial state of an object.
Simple explanation: A constructor is like the first step in building something.
Real-life example: A car is assembled at the factory.
School example: A student is enrolled in a school.
Home example: A meal is prepared before cooking.
Nigerian example: An outfit is sewn by a tailor.
class Car {
brand: string;
constructor(brand: string) {
this.brand = brand;
}
}
Mini summary: Constructors initialise objects.
Definition: this refers to the current object.
Why is it important? It helps you access properties and methods inside the class.
Simple explanation: this is like saying "me" or "myself."
Real-life example: this.brand refers to the brand of this car.
School example: this.name refers to the name of this student.
Home example: this.ingredients refers to the ingredients of this recipe.
Nigerian example: this.type refers to the type of this outfit.
class Car {
brand: string;
constructor(brand: string) {
this.brand = brand;
}
}
Mini summary: this refers to the current object.
Definition: You create an object using the new keyword.
Why is it important? It instantiates a class into an object.
Simple explanation: You use new to build an object from a class.
Real-life example: let myCar = new Car("Toyota");
School example: let student = new Student("Ada");
Home example: let recipe = new Recipe("Jollof Rice");
Nigerian example: let outfit = new Outfit("Ankara");
let myCar = new Car("Toyota");
console.log(myCar.brand); // Toyota
Mini summary: The new keyword creates objects.
Definition: Public means the property or method is accessible from anywhere.
Why is it important? It allows access to the member.
Simple explanation: Everyone can see it.
Real-life example: Public information.
School example: A public announcement.
Home example: A shared family calendar.
Nigerian example: Public services.
class Car {
public brand: string;
}
Mini summary: Public members are accessible anywhere.
Definition: Private means the property or method is accessible only inside the class.
Why is it important? It protects data from outside access.
Simple explanation: Only the class can see it.
Real-life example: A personal diary.
School example: A student's private notes.
Home example: A family secret.
Nigerian example: Personal information.
class Car {
private engine: string;
}
Mini summary: Private members are only accessible inside the class.
Definition: Protected means the property or method is accessible in the class and its subclasses.
Why is it important? It allows inheritance.
Simple explanation: The class and its children can see it.
Real-life example: Family heirlooms.
School example: A teacher's lesson notes shared with student teachers.
Home example: A parent's advice to their children.
Nigerian example: Cultural traditions passed down.
class Car {
protected engine: string;
}
Mini summary: Protected members are accessible in subclasses.
Definition: Getters and setters are methods that control access to properties.
Why is it important? They allow you to add logic when getting or setting values.
Simple explanation: They are like guards for your properties.
Real-life example: A security guard at a gate.
School example: A teacher checking homework.
Home example: A parent checking on a child.
Nigerian example: A security checkpoint.
class Car {
private _brand: string;
get brand(): string {
return this._brand;
}
set brand(value: string) {
this._brand = value;
}
}
Mini summary: Getters and setters control access to properties.
Definition: Static members belong to the class itself, not instances.
Why is it important? They are useful for utility functions.
Simple explanation: They are shared by all objects.
Real-life example: A factory that builds cars.
School example: A school's motto.
Home example: A family name.
Nigerian example: A national anthem.
class Car {
static brand: string = "Toyota";
}
console.log(Car.brand);
Mini summary: Static members belong to the class.
Definition: Common mistakes are errors that beginners often make with classes.
Why is it important? Avoiding them saves time and frustration.
Simple explanation: Don't forget to use the new keyword.
Real-life example: Forgetting to use new when creating an object.
School example: Forgetting to instantiate a student.
Home example: Forgetting to prepare ingredients before cooking.
Nigerian example: Forgetting to use new when creating an object.
// Error: missing new
let myCar = Car("Toyota");
Mini summary: Always use new to create objects.
Definition: You are now a class master – you understand classes and objects.
Why is it important? You can now build real-world applications.
Simple explanation: You have mastered classes.
Real-life example: You can now create classes for any purpose.
School example: You can use classes in school projects.
Home example: You can practice at home.
Nigerian example: You can build apps with classes in Nigeria.
Class Master Checklist: - Creates classes - Uses constructors - Adds properties and methods - Creates objects - Uses access modifiers
Mini summary: You are now a class master!
| Word | Simple Definition |
|---|---|
| Class | A blueprint for objects. |
| Object | An instance of a class. |
| Property | A piece of data in a class. |
| Method | A function in a class. |
| Constructor | Initialises an object. |
| this | Refers to the current object. |
| Public | Accessible anywhere. |
| Private | Accessible only in the class. |
| Protected | Accessible in subclasses. |
| Static | Belongs to the class. |
class Car {
brand: string;
model: string;
constructor(brand: string, model: string) {
this.brand = brand;
this.model = model;
}
start(): void {
console.log("Car started");
}
}
let myCar = new Car("Toyota", "Camry");
console.log(myCar.brand); // Toyota
myCar.start(); // Car started
+-----------------------+-----------------------+ | Class | Object | +-----------------------+-----------------------+ | Blueprint | Instance | | Template | Real thing | | Defines structure | Holds data | | Not usable directly | Usable | | One class | Many objects | +-----------------------+-----------------------+
| Modifier | Accessible In |
|---|---|
| public | Everywhere |
| private | Only the class |
| protected | Class and subclasses |
| Component | Description | Example |
|---|---|---|
| Property | Data | brand: string |
| Method | Action | start(): void |
| Constructor | Initialisation | constructor() |
| Static | Class-level | static brand: string |
(Included after each lesson above – review them!)
In this module, you learned about classes and objects. You discovered how to create classes, use constructors, add properties and methods, and create objects. You also learned about access modifiers (public, private, protected) and static members. You are now a class master. In the next module, you will learn about inheritance and polymorphism. Congratulations on completing Module Five!
Match the term with its definition.
| Term | Definition |
|---|---|
| 1. Class | A. Blueprint for objects |
| 2. Object | B. Instance of a class |
| 3. Property | C. Data in a class |
| 4. Method | D. Action in a class |
| 5. Constructor | E. Initialises an object |
Answers: 1-A, 2-B, 3-C, 4-D, 5-E
“Class Design”
In groups, design a class for a real-world scenario (like a store or a school). Include properties, methods, and a constructor. Share your design with the class.
“My Class”
Write a TypeScript class for a real-world thing (like a car, person, or product). Include properties, a constructor, and methods. Create an object from your class. Share your code with the class.
“Class Project”
Create a class for a business (like a store or a school). Include properties, a constructor, and methods. Create objects from your class and use them. Present your project to the class.
“Write TypeScript Classes”
Write a TypeScript program with a class and objects. Include properties, a constructor, and methods. Compile and run it. Share your code and output.
“Class Challenge”
Create a complex class with multiple properties, methods, and access modifiers. Include static members. Create objects and use them. Share your solution with the class.
(Answers to fill-in-the-blank, true/false, and multiple choice are provided within those sections.)
In Module Six, you will learn about inheritance and polymorphism. To prepare:
Get ready to learn about inheritance!
End of Module Five · You are now a class master!
Hello, inheritor! In Module Five, you learned about classes and objects. Now it is time to learn about inheritance and polymorphism – two powerful concepts that help you build on existing code.
Inheritance allows a class to inherit properties and methods from another class. Polymorphism allows objects to take many forms. These concepts make your code more organised, reusable, and flexible.
In this module, you will learn how to use inheritance to extend classes, override methods, and use polymorphism to write more flexible code.
Let's start building on what exists with TypeScript!
By the end of this module, you will be able to:
In a Nigerian village, a teacher named Mrs. Okafor was explaining animals to her students. She said, "All animals have a name and an age. Some animals walk, some swim, and some fly."
She created a class called Animal with name and age. Then she created subclasses: Dog, Fish, and Bird. Each subclass inherited from Animal and added its own special behaviour.
The students understood that all animals share common things, but each is special. Mrs. Okafor said, "This is like inheritance in programming – you build on what exists."
Definition: Inheritance is a way for a class to inherit properties and methods from another class.
Why is it important? It promotes reusability and reduces duplication.
Simple explanation: It's like a child inheriting traits from a parent.
Real-life example: A child inherits their parent's eyes.
School example: A student inherits traits from their family.
Home example: A child inherits their parent's habits.
Nigerian example: A child inherits their parent's cultural traditions.
class Animal {
name: string;
age: number;
}
class Dog extends Animal {
// Dog inherits name and age
}
Mini summary: Inheritance is when a class inherits from another class.
Definition: The extends keyword is used to inherit a class.
Why is it important? It tells TypeScript that a class is a child of another class.
Simple explanation: It's like saying "this class is a type of that class."
Real-life example: class Dog extends Animal.
School example: class Student extends Person.
Home example: class Child extends Parent.
Nigerian example: class Nigerian extends Person.
class Animal {
name: string;
}
class Dog extends Animal {
// Dog has all Animal properties
}
Mini summary: The extends keyword is used to inherit.
Definition: The parent class is the class being inherited from. The child class is the class that inherits.
Why is it important? It defines the relationship between classes.
Simple explanation: Parent = base; child = derived.
Real-life example: Animal is parent; Dog is child.
School example: Person is parent; Student is child.
Home example: Parent is parent; Child is child.
Nigerian example: Person is parent; Nigerian is child.
class Animal {
// Parent class
}
class Dog extends Animal {
// Child class
}
Mini summary: Parent classes are inherited from; child classes inherit.
Definition: The super keyword is used to call the parent class's constructor or methods.
Why is it important? It allows you to reuse parent logic.
Simple explanation: It's like calling your parent for help.
Real-life example: super(name) calls the parent constructor.
School example: super(name) calls the parent constructor.
Home example: super(name) calls the parent constructor.
Nigerian example: super(name) calls the parent constructor.
class Animal {
constructor(name: string) {
this.name = name;
}
}
class Dog extends Animal {
constructor(name: string) {
super(name); // call parent constructor
}
}
Mini summary: super calls the parent class.
Definition: Overriding means providing a new implementation of a method in a child class.
Why is it important? It allows child classes to customise behaviour.
Simple explanation: You replace a parent method with your own.
Real-life example: A dog's makeSound() barks; a cat's makeSound() meows.
School example: A student's study() method is different from a teacher's.
Home example: A child's play() method is different from a parent's.
Nigerian example: A Nigerian's greet() method is different from an American's.
class Animal {
makeSound(): void {
console.log("Some sound");
}
}
class Dog extends Animal {
makeSound(): void {
console.log("Bark");
}
}
Mini summary: Overriding replaces a parent method.
Definition: Polymorphism means "many forms" – it allows objects to be treated as their parent type.
Why is it important? It makes code more flexible.
Simple explanation: The same method can work differently for different classes.
Real-life example: An animal can be a dog, a cat, or a bird.
School example: A person can be a student or a teacher.
Home example: A family member can be a parent or a child.
Nigerian example: A citizen can be a Nigerian or a foreigner.
let animal: Animal = new Dog(); animal.makeSound(); // Bark
Mini summary: Polymorphism means many forms.
Definition: Polymorphism allows you to use a child class where a parent class is expected.
Why is it important? It gives you flexibility.
Simple explanation: You can treat a dog as an animal.
Real-life example: function feed(animal: Animal) { animal.eat(); }
School example: function grade(person: Person) { person.study(); }
Home example: function care(family: Family) { family.love(); }
Nigerian example: function greet(person: Person) { person.sayHello(); }
function feed(animal: Animal) {
animal.eat();
}
let dog = new Dog();
feed(dog); // Works because Dog is an Animal
Mini summary: Polymorphism allows flexibility.
Definition: Method overriding is a key part of polymorphism.
Why is it important? It allows different classes to have different behaviours.
Simple explanation: Each class can implement the same method differently.
Real-life example: Dog barks; Cat meows.
School example: Student studies; Teacher teaches.
Home example: Child plays; Parent works.
Nigerian example: Nigerian greets; American greets.
class Animal {
makeSound(): void {
console.log("Some sound");
}
}
class Dog extends Animal {
makeSound(): void {
console.log("Bark");
}
}
class Cat extends Animal {
makeSound(): void {
console.log("Meow");
}
}
Mini summary: Overriding enables polymorphism.
Definition: Abstract classes cannot be instantiated – they are only used for inheritance.
Why is it important? They provide a blueprint for subclasses.
Simple explanation: They are like templates.
Real-life example: Animal is abstract; you can't create an Animal object.
School example: Person is abstract; you can't create a Person object.
Home example: Family is abstract; you can't create a Family object.
Nigerian example: Citizen is abstract; you can't create a Citizen object.
abstract class Animal {
abstract makeSound(): void;
}
class Dog extends Animal {
makeSound(): void {
console.log("Bark");
}
}
Mini summary: Abstract classes are templates.
Definition: Abstract methods are methods that must be implemented by subclasses.
Why is it important? They force subclasses to provide behaviour.
Simple explanation: You say "you must do this."
Real-life example: Animal says "you must make a sound."
School example: Person says "you must study."
Home example: Family says "you must contribute."
Nigerian example: Citizen says "you must obey the law."
abstract class Animal {
abstract makeSound(): void;
}
class Dog extends Animal {
makeSound(): void {
console.log("Bark");
}
}
Mini summary: Abstract methods must be implemented.
Definition: Access modifiers (public, private, protected) control what is accessible in subclasses.
Why is it important? They protect your code.
Simple explanation: Public is visible everywhere; protected is visible in subclasses; private is only visible in the class itself.
Real-life example: public: everyone sees it; protected: family sees it; private: only you see it.
School example: public: whole school; protected: class; private: only you.
Home example: public: all family; protected: parents; private: only you.
Nigerian example: public: all Nigerians; protected: your family; private: only you.
class Animal {
public name: string;
protected age: number;
private id: number;
}
class Dog extends Animal {
// Can access name and age, but not id
}
Mini summary: Access modifiers control visibility.
Definition: Common mistakes are errors that beginners often make with inheritance.
Why is it important? Avoiding them saves time and frustration.
Simple explanation: Don't forget to call super().
Real-life example: Forgetting to call the parent constructor.
School example: Forgetting to call super in a subclass.
Home example: Forgetting to call super in a child class.
Nigerian example: Forgetting to call super in a derived class.
class Dog extends Animal {
constructor(name: string) {
super(name); // Forgetting this causes an error
}
}
Mini summary: Always call super in subclasses.
Definition: Best practices are the recommended ways to use inheritance.
Why is it important? They make your code clean and safe.
Simple explanation: Use inheritance when classes share common properties.
Real-life example: Use inheritance for Animal and Dog.
School example: Use inheritance for Person and Student.
Home example: Use inheritance for Family and Child.
Nigerian example: Use inheritance for Citizen and Nigerian.
class Animal {
name: string;
}
class Dog extends Animal {
breed: string;
}
Mini summary: Use inheritance when classes share commonality.
Definition: Inheritance is not just for code – it is everywhere in life.
Why is it important? It shows that inheritance is natural and easy to understand.
Simple explanation: You inherit traits from your parents.
Real-life example: A child inherits their parent's eyes.
School example: A student inherits traits from their family.
Home example: A child inherits habits from parents.
Nigerian example: A child inherits cultural traditions.
Inheritance is like a child inheriting traits from a parent.
Mini summary: Inheritance is natural and everywhere.
Definition: You are now an inheritance master – you understand inheritance and polymorphism.
Why is it important? You can now write flexible, organised code.
Simple explanation: You have mastered inheritance.
Real-life example: You can now build class hierarchies.
School example: You can use inheritance in school projects.
Home example: You can practice at home.
Nigerian example: You can build apps with inheritance in Nigeria.
Inheritance Master Checklist: - Uses extends to inherit - Uses super to call parent - Overrides methods - Understands polymorphism - Uses abstract classes
Mini summary: You are now an inheritance master!
| Word | Simple Definition |
|---|---|
| Inheritance | Inheriting from another class. |
| extends | Keyword to inherit. |
| super | Call the parent class. |
| Override | Replace a method. |
| Polymorphism | Many forms. |
| Abstract | Cannot be instantiated. |
| Protected | Visible in subclasses. |
| Public | Visible everywhere. |
| Private | Visible only in the class. |
| Class | A blueprint for objects. |
class Animal {
name: string;
}
class Dog extends Animal {
breed: string;
}
let animal: Animal = new Dog(); animal.makeSound(); // Bark
+-----------------------+-----------------------+ | Inheritance | Composition | +-----------------------+-----------------------+ | "Is a" relationship | "Has a" relationship | | Child inherits parent | Object contains object| | Tight coupling | Loose coupling | | Reuse code | More flexible | | Simple | More complex | +-----------------------+-----------------------+
| Modifier | Accessible In |
|---|---|
| public | Everywhere |
| protected | Subclasses |
| private | Only the class |
| Type | Description | Example |
|---|---|---|
| Single | One parent | Dog extends Animal |
| Multi-level | Chain of inheritance | Dog extends Animal; Animal extends LivingBeing |
| Hierarchical | Multiple children | Dog, Cat extends Animal |
(Included after each lesson above – review them!)
In this module, you learned about inheritance and polymorphism. You discovered how to use the extends keyword, call super(), and override methods. You also learned about polymorphism, abstract classes, and access modifiers. You are now an inheritance master. In the next module, you will learn about generics. Congratulations on completing Module Six!
Match the term with its definition.
| Term | Definition |
|---|---|
| 1. Inheritance | A. Inheriting from another class |
| 2. extends | B. Keyword to inherit |
| 3. super | C. Call parent class |
| 4. Override | D. Replace a method |
| 5. Polymorphism | E. Many forms |
Answers: 1-A, 2-B, 3-C, 4-D, 5-E
“Inheritance Design”
In groups, design a class hierarchy for a real-world scenario (like a store or a school). Use inheritance and polymorphism. Share your design with the class.
“My Inheritance Code”
Write TypeScript code using inheritance and polymorphism. Include a parent class, child classes, and method overriding. Share your code with the class.
“Inheritance Project”
Create a class hierarchy for a business (like a store or a school). Use inheritance, method overriding, and polymorphism. Present your project to the class.
“Write Inheritance Code”
Write a TypeScript program that uses inheritance and polymorphism. Include a parent class, child classes, and method overriding. Compile and run it. Share your code and output.
“Inheritance Challenge”
Create a complex class hierarchy using inheritance and polymorphism. Include abstract classes and method overriding. Share your solution with the class.
(Answers to fill-in-the-blank, true/false, and multiple choice are provided within those sections.)
In Module Seven, you will learn about generics. To prepare:
Get ready to learn about generics!
End of Module Six · You are now an inheritance master!
Hello, generic builder! In Module Six, you learned about inheritance and polymorphism. Now it is time to learn about generics – a powerful feature that makes your code more flexible and reusable.
Generics allow you to write code that works with many different types. Instead of writing the same code for strings, numbers, and other types, you write it once with generics.
In this module, you will learn how to use generics to create flexible functions, classes, and interfaces.
Let's start writing flexible code with generics!
By the end of this module, you will be able to:
In Lagos, a store owner named Mr. Okonkwo wanted to store different items in boxes. He had boxes for shoes, boxes for books, and boxes for clothes. Each box was different.
He thought, "Wouldn't it be great if I had one type of box that could hold anything?"
In programming, generics are like that universal box. They allow you to create a single class or function that can work with any type.
Definition: Generics are a way to write code that works with many different types.
Why is it important? They make your code flexible and reusable.
Simple explanation: Generics are like a template that can work with any type.
Real-life example: A container that can hold anything.
School example: A bag that can carry any subject books.
Home example: A drawer that can store different items.
Nigerian example: A vehicle that can carry any load.
function identity(value: T): T { return value; }
Mini summary: Generics work with many types.
Definition: A generic function is a function that works with any type.
Why is it important? It avoids code duplication.
Simple explanation: You write one function that works for all types.
Real-life example: A function that returns whatever you give it.
School example: A function that copies any data.
Home example: A function that stores any item.
Nigerian example: A function that processes any data.
function identity(value: T): T { return value; }
Mini summary: Generic functions work with any type.
Definition: A generic class is a class that works with any type.
Why is it important? It makes classes reusable.
Simple explanation: A class that can hold any type of data.
Real-life example: A box that can hold any item.
School example: A folder that can hold any document.
Home example: A container that can hold anything.
Nigerian example: A storage unit that can hold any goods.
class Box{ private value: T; constructor(value: T) { this.value = value; } getValue(): T { return this.value; } }
Mini summary: Generic classes work with any type.
Definition: A generic interface is an interface that works with any type.
Why is it important? It makes interfaces flexible.
Simple explanation: An interface that can describe any type.
Real-life example: A blueprint for a container.
School example: A template for a document.
Home example: A design for a storage box.
Nigerian example: A plan for a shop.
interface GenericInterface{ value: T; getValue(): T; }
Mini summary: Generic interfaces work with any type.
Definition: You can use multiple type parameters in generics.
Why is it important? It allows more flexibility.
Simple explanation: You can work with two or more types.
Real-life example: A function that works with two different types.
School example: A function that takes a student and a grade.
Home example: A function that takes a person and a task.
Nigerian example: A function that takes a product and a price.