The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Functions

Next ►
►

Functions are fundamental building blocks in Dart programming. They allow you to encapsulate a block of code that performs a specific task, which can be reused throughout your program. In this section, we will cover the basics of defining and using functions in Dart, including parameters, return types, and different types of functions.

Key Concepts

  1. Function Definition
  2. Function Parameters
  3. Return Types
  4. Anonymous Functions
  5. Arrow Functions
  6. Higher-Order Functions

Function Definition

A function in Dart is defined using the void keyword if it does not return a value, or a specific return type if it does. The syntax is as follows:

void functionName() {
  // Code to be executed
}

Example

void greet() {
  print('Hello, World!');
}

void main() {
  greet(); // Calling the function
}

In this example, the greet function prints "Hello, World!" to the console.

Function Parameters

Functions can accept parameters to make them more flexible and reusable. Parameters are defined within the parentheses in the function definition.

Example

void greet(String name) {
  print('Hello, $name!');
}

void main() {
  greet('Alice'); // Output: Hello, Alice!
  greet('Bob');   // Output: Hello, Bob!
}

Optional Parameters

Dart supports optional parameters, which can be either positional or named.

Positional Optional Parameters

void greet([String name = 'Guest']) {
  print('Hello, $name!');
}

void main() {
  greet();        // Output: Hello, Guest!
  greet('Alice'); // Output: Hello, Alice!
}

Named Optional Parameters

void greet({String name = 'Guest'}) {
  print('Hello, $name!');
}

void main() {
  greet();        // Output: Hello, Guest!
  greet(name: 'Alice'); // Output: Hello, Alice!
}

Return Types

A function can return a value using the return statement. The return type must be specified in the function definition.

Example

int add(int a, int b) {
  return a + b;
}

void main() {
  int result = add(3, 4);
  print(result); // Output: 7
}

Anonymous Functions

Anonymous functions, also known as lambda or inline functions, are functions without a name. They are often used as arguments to other functions.

Example

void main() {
  var list = ['apples', 'bananas', 'oranges'];
  list.forEach((item) {
    print(item);
  });
}

Arrow Functions

For functions that contain only a single expression, you can use the shorthand syntax known as arrow functions.

Example

int add(int a, int b) => a + b;

void main() {
  print(add(3, 4)); // Output: 7
}

Higher-Order Functions

Functions that take other functions as parameters or return functions are called higher-order functions.

Example

void printResult(int Function(int, int) operation, int a, int b) {
  print(operation(a, b));
}

int add(int a, int b) => a + b;
int subtract(int a, int b) => a - b;

void main() {
  printResult(add, 3, 4);      // Output: 7
  printResult(subtract, 3, 4); // Output: -1
}

Practical Exercises

Exercise 1: Basic Function

Task: Write a function multiply that takes two integers and returns their product.

int multiply(int a, int b) {
  return a * b;
}

void main() {
  print(multiply(3, 4)); // Output: 12
}

Exercise 2: Optional Parameters

Task: Modify the greet function to accept an optional parameter greeting with a default value of "Hello".

void greet(String name, [String greeting = 'Hello']) {
  print('$greeting, $name!');
}

void main() {
  greet('Alice');           // Output: Hello, Alice!
  greet('Bob', 'Hi');       // Output: Hi, Bob!
}

Exercise 3: Higher-Order Function

Task: Write a higher-order function applyOperation that takes a function and two integers, and returns the result of applying the function to the integers.

int applyOperation(int Function(int, int) operation, int a, int b) {
  return operation(a, b);
}

int add(int a, int b) => a + b;
int multiply(int a, int b) => a * b;

void main() {
  print(applyOperation(add, 3, 4));      // Output: 7
  print(applyOperation(multiply, 3, 4)); // Output: 12
}

Common Mistakes and Tips

  • Forgetting to call the function: Ensure you call the function in your main method or wherever necessary.
  • Mismatched parameter types: Ensure the types of arguments match the parameter types defined in the function.
  • Using the wrong return type: Ensure the return type of the function matches the type of the value being returned.

Conclusion

In this section, we covered the basics of functions in Dart, including how to define and use them, handle parameters, and work with different types of functions. Understanding functions is crucial for writing modular and reusable code. In the next module, we will dive into collections, which are essential for managing groups of related data.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved