**Course Title:** Mastering TypeScript: From Basics to Advanced Applications **Section Title:** Control Structures and Functions **Topic:** Create TypeScript functions using various control structures and overloading.(Lab topic) In this lab topic, we'll put into practice the concepts learned so far and create TypeScript functions that utilize various control structures and overloading. You'll gain hands-on experience in designing and implementing functions that handle different scenarios and inputs. **Objective:** By the end of this lab topic, you'll be able to: 1. Create functions that use conditional statements, loops, and function overloading to handle different inputs and scenarios. 2. Understand how to design and implement functions that are reusable, flexible, and efficient. 3. Apply the concepts learned so far to real-world problems and scenarios. **Lab Exercise:** Create a TypeScript program that simulates a simple banking system. The program should have the following functions: 1. `deposit(amount: number)`: Deposits a specified amount into an account. 2. `withdraw(amount: number)`: Withdraws a specified amount from an account. 3. `checkBalance()`: Displays the current account balance. Use conditional statements, loops, and function overloading to handle different scenarios, such as: * Insufficient funds for withdrawal * Invalid deposit amount * Multiple account transactions **Step-by-Step Instructions:** 1. Create a new TypeScript file (e.g., `banking-system.ts`) and add the following code: ```typescript // Initialize account balance let accountBalance: number = 0; // Deposit function function deposit(amount: number): void { // Check if amount is valid (greater than 0) if (amount <= 0) { console.log("Invalid deposit amount. Please deposit a positive amount."); } else { // Update account balance accountBalance += amount; console.log(`Deposited $${amount}. Current balance: $${accountBalance}`); } } // Withdraw function function withdraw(amount: number): void { // Check if amount is valid (greater than 0) and sufficient funds available if (amount <= 0) { console.log("Invalid withdrawal amount. Please withdraw a positive amount."); } else if (amount > accountBalance) { console.log("Insufficient funds for withdrawal. Current balance: $${accountBalance}"); } else { // Update account balance accountBalance -= amount; console.log(`Withdrew $${amount}. Current balance: $${accountBalance}`); } } // Check balance function function checkBalance(): void { console.log(`Current account balance: $${accountBalance}`); } ``` 2. Add function overloading to handle different input scenarios. For example, you can add an overloaded `deposit` function that accepts an object with `amount` and `description` properties: ```typescript // Overloaded deposit function function deposit(depositInfo: { amount: number; description: string }): void { console.log(`Deposited $${depositInfo.amount} - ${depositInfo.description}`); } ``` 3. Test the functions with different input scenarios. For example: ```typescript // Test deposit function deposit(100); deposit(50); // Test withdrawal function withdraw(20); withdraw(150); // Test check balance function checkBalance(); // Test overloaded deposit function deposit({ amount: 50, description: "Payroll deposit" }); ``` **Tips and Variations:** * Use loops to handle multiple account transactions. * Implement additional functions, such as `transfer` or `calculateInterest`. * Use conditional statements to handle different account types (e.g., checking, savings). * Explore the use of `finally` block to log account transactions. **Conclusion:** In this lab topic, you've created a simple banking system using TypeScript functions that utilize various control structures and overloading. You've gained hands-on experience in designing and implementing functions that handle different inputs and scenarios. **What's Next:** In the next topic, 'Primitive and complex types: arrays, tuples, and enums,' we'll explore the world of data types in TypeScript. We'll learn about arrays, tuples, and enums, and how to use them in our applications. **External Resources:** * [TypeScript Documentation: Control Flow](https://www.typescriptlang.org/docs/handbook/basic-types.html#control-flow-types) * [TypeScript Documentation: Functions](https://www.typescriptlang.org/docs/handbook/functions.html) **Leave a Comment or Ask for Help:** If you have any questions or need help with this lab topic, please leave a comment below.