1:25:22
TypeScript for Playwright | Functions in TypeScript Part-1 (Session 7)
SDET- QA
Overview
This video introduces functions in TypeScript, explaining their fundamental purpose as reusable blocks of code. It details three primary ways to define functions: named functions, anonymous functions, and arrow (lambda) functions. The session focuses heavily on named functions, exploring various parameter types (standard, rest, optional, default) and return types. It then briefly touches upon anonymous and arrow functions, highlighting their syntax and use cases, with a particular emphasis on the conciseness and prevalence of arrow functions in modern development.
How was this?
Save this permanently with flashcards, quizzes, and AI chat
Chapters
- A function is a reusable block of code designed to perform a specific task.
- Functions enhance code reusability, preventing the need to write the same logic multiple times.
- Functions can accept input parameters to customize their behavior.
- Functions can optionally return a value after completing their task.
Understanding functions is crucial for writing organized, efficient, and maintainable code by abstracting complex operations into callable units.
A function to add two numbers, which takes the numbers as parameters and returns their sum.
- Named functions are declared using the `function` keyword followed by a specific name.
- The syntax includes the function name, optional parameters, an optional return type, and the function body.
- Functions can be declared with no parameters and no return value (void).
- To execute a named function, you call it using its name followed by parentheses.
Named functions provide a clear, identifiable structure for code blocks, making them easy to reference and understand within a program.
A `display` function that takes no arguments and prints 'Welcome to TypeScript' to the console.
- Functions can accept multiple parameters, each with a defined type (e.g., `x: number`, `y: number`).
- The return type of a function must be explicitly declared (e.g., `: number`).
- The `return` keyword is used to send a value back from the function.
- The returned value can be stored in a variable or used directly, for example, within `console.log`.
This allows functions to be dynamic and interactive, processing specific data and providing results that can be used elsewhere in the application.
An `addNumbers` function that accepts two numbers and returns their sum.
- Rest parameters (`...nums: number[]`) allow a function to accept an indefinite number of arguments as an array.
- Optional parameters (e.g., `mailId?: string`) can be omitted during function calls; they will be `undefined` if not provided.
- Default parameters (e.g., `rate: number = 0.50`) provide a fallback value if an argument is not supplied.
- These parameter types offer flexibility, allowing functions to handle varying input scenarios gracefully.
These advanced parameter types make functions more robust and adaptable, enabling them to handle situations where the number or presence of inputs is uncertain.
A `calculateDiscount` function where the `rate` parameter has a default value of `0.50` if not explicitly provided.
- Anonymous functions are defined without a name and must be assigned to a variable to be invoked.
- The syntax uses the `function` keyword but omits the function name.
- The variable holding the anonymous function is used to call it.
- Optional, rest, and default parameters are also applicable to anonymous functions.
Anonymous functions are useful for creating functions on-the-fly, especially when they are needed only once or as callbacks, without cluttering the scope with named functions.
A function assigned to a variable `msg` that returns the string 'Hello TypeScript'.
- Arrow functions are a concise syntax for writing anonymous functions, often preferred for their brevity.
- They use the `=>` (fat arrow) notation instead of the `function` keyword.
- Arrow functions also require assignment to a variable for invocation.
- When a function body contains only a single return statement, curly braces and the `return` keyword can be omitted (implicit return).
Arrow functions significantly reduce boilerplate code, making functions more readable and easier to write, especially in functional programming patterns and event handlers.
A function assigned to `add` that takes two numbers `a` and `b` and implicitly returns their sum using `(a, b) => a + b`.
Key takeaways
- Functions are fundamental building blocks in programming for code organization and reusability.
- TypeScript offers flexibility in defining functions through named, anonymous, and arrow syntaxes.
- Understanding parameter types like rest, optional, and default is key to writing adaptable functions.
- Arrow functions provide a concise and modern way to define functions, often replacing traditional anonymous functions.
- The choice between function types depends on the need for naming, conciseness, and specific parameter handling.
- Explicitly defining parameter and return types in TypeScript functions improves code clarity and catches errors early.
Key terms
FunctionNamed FunctionAnonymous FunctionArrow FunctionLambda FunctionParametersReturn TypeVoidRest ParametersOptional ParametersDefault ParametersImplicit Return
Test your understanding
- What is the primary benefit of using functions in programming?
- How does a named function differ from an anonymous function in TypeScript?
- Explain the purpose and syntax of rest parameters in a TypeScript function.
- When would you choose to use an arrow function over a named function?
- What is the advantage of using default parameters in a function definition?