Dart Functions|Declaring and calling functions, Parameters and return values, Function expressions

---

Mastering Dart Functions: A Comprehensive Guide with Examples

 

Introduction:

Unlock the power of Dart functions with our comprehensive guide! Whether you’re a beginner or looking to enhance your Dart programming skills, this lesson covers everything from basic function declarations to advanced concepts like optional parameters, function expressions, and closures. Dive into practical examples and gain a solid understanding of how to leverage Dart functions effectively.

Dart is a programming language that allows you to define and use functions in various ways. Here’s an overview of declaring and calling functions, working with parameters and return values, and using function expressions in Dart.

Declaring and Calling Functions in Dart:

Dart function Declaration:

// Function declaration
void sayHello() {
print("Hello, world!");
}

// Function with parameters
void greet(String name) {
print("Hello, $name!");
}

Dart function Calling:

// Calling functions
sayHello(); // Output: Hello, world!

String myName = "John";
greet(myName); // Output: Hello, John!

Parameters and Return Values:

Parameters:

dart

// Function with multiple parameters
void printDetails(String name, int age) {
print("Name: $name, Age: $age");
}

// Named parameters (optional)
void printPersonalDetails({String name = "John", int age = 30}) {
print("Name: $name, Age: $age");
}

Return Values:

dart

// Function with return value
int add(int a, int b) {
return a + b;
}

// Shortened syntax for one-liner functions
int multiply(int a, int b) => a * b;

Dart Function Expressions:

Dart allows using function expressions, which are concise ways of defining functions.

dart

// Function expression
int square(int num) => num * num;

// Anonymous function
var multiplyByTwo = (int number) {
return number * 2;
};

Higher-Order Functions in Dart:

Dart supports higher-order functions, which means you can pass functions as arguments or return them from other functions.

dart

// Higher-order function
void performOperation(int a, int b, Function operation) {
var result = operation(a, b);
print("Result: $result");
}

void main() {
performOperation(5, 3, add); // Result: 8
performOperation(5, 3, multiply); // Result: 15
}

These examples cover the basics of declaring and calling functions, working with parameters and return values, and using function expressions in Dart.

Let’s delve deeper into some advanced concepts related to Dart functions.

Optional Parameters IN Dart function:

Dart allows you to specify optional parameters in function declarations.

There are two types: positional and named.

Positional Optional Parameters:

dart

// Positional optional parameters
void printMessage(String message, [String additionalMessage]) {
if (additionalMessage != null) {
print("$message $additionalMessage");
} else {
print(message);
}
}

// Example usage
printMessage("Hello"); // Output: Hello
printMessage("Hi", "there"); // Output: Hi there
Named Optional Parameters:
dart

// Named optional parameters
void printInfo({String name, int age}) {
print("Name: $name, Age: $age");
}

// Example usage
printInfo(name: "Alice", age: 25); // Output: Name: Alice, Age: 25
printInfo(age: 30); // Output: Name: null, Age: 30

Default Parameter Values:

You can provide default values for parameters in Dart, making them optional.

dart

// Function with default parameter values
void printPersonDetails(String name, {int age = 30, String country = "Unknown"}) {
print("Name: $name, Age: $age, Country: $country");
}

// Example usage
printPersonDetails("Bob"); // Output: Name: Bob, Age: 30, Country: Unknown
printPersonDetails("Charlie", age: 28, country: "USA"); // Output: Name: Charlie, Age: 28, Country: USA

Anonymous Functions and Closures:

Dart supports anonymous functions, also known as lambda or closures.

dart

// Anonymous function as a parameter
void performOperation(int a, int b, Function(int, int) operation) {
var result = operation(a, b);
print("Result: $result");
}

void main() {
// Using an anonymous function
performOperation(5, 3, (x, y) => x * y); // Result: 15
}

Lexical Closures:

Dart has lexical closures, which means a function can access variables from its lexical scope, even if it’s executed outside that scope.

dart

Function outerFunction() {
int outerVar = 10;

// Closure
return () {
outerVar++;
print(outerVar);
};
}

void main() {
var closure = outerFunction();
closure(); // Output: 11
}

These advanced concepts provide flexibility and power when working with Dart functions. Optional parameters, default values, anonymous functions, and closures contribute to the expressiveness and conciseness of Dart code. 

Examples about types dart functions 

Let’s provide complete examples for each type of function with explanations.

1. Basic Function with Parameters and Return Value:

// Function with parameters and return value
int add(int a, int b) {
return a + b;
}

void main() {
// Calling the function
int result = add(5, 3);
print("Sum: $result"); // Output: Sum: 8
}

This example defines a function add that takes two parameters and returns their sum.

2. Function with Optional Positional Parameters:

dart

// Function with optional positional parameters
void printMessage(String message, [String additionalMessage]) {
if (additionalMessage != null) {
print("$message $additionalMessage");
} else {
print(message);
}
}

void main() {
// Example usage
printMessage("Hello"); // Output: Hello
printMessage("Hi", "there"); // Output: Hi there
}

Here, additionalMessage is an optional positional parameter. If provided, it appends to the original message.

3. Function with Optional Named Parameters:

dart

// Function with optional named parameters
void printInfo({String name, int age}) {
print("Name: $name, Age: $age");
}

void main() {
// Example usage
printInfo(name: "Alice", age: 25); // Output: Name: Alice, Age: 25
printInfo(age: 30); // Output: Name: null, Age: 30
}

This example uses named parameters name and age, allowing for clarity when calling the function.

4. Function with Default Parameter Values:

dart

// Function with default parameter values
void printPersonDetails(String name, {int age = 30, String country = "Unknown"}) {
print("Name: $name, Age: $age, Country: $country");
}

void main() {
// Example usage
printPersonDetails("Bob"); // Output: Name: Bob, Age: 30, Country: Unknown
printPersonDetails("Charlie", age: 28, country: "USA"); // Output: Name: Charlie, Age: 28, Country: USA
}

Here, the function has default values for age and country, which are used when not explicitly provided.

5. Anonymous Function and Higher-Order Function:

dart

// Higher-order function
void performOperation(int a, int b, int Function(int, int) operation) {
var result = operation(a, b);
print("Result: $result");
}

void main() {
// Using an anonymous function
performOperation(5, 3, (x, y) => x * y); // Result: 15
}

This example showcases a higher-order function that takes an anonymous function as an argument to perform an operation.

6. Lexical Closure:

dart

Function outerFunction() {
int outerVar = 10;

// Closure
return () {
outerVar++;
print(outerVar);
};
}

void main() {
var closure = outerFunction();
closure(); // Output: 11
}

Here, the inner function forms a closure over the outerVar from its lexical scope, allowing access even after outerFunction has finished executing.

These examples cover a range of Dart function concepts, from basic functions to advanced features like optional parameters, default values, anonymous functions, higher-order functions, and closures. Feel free to experiment and modify these examples to better suit your needs.

Let’s explore a few examples that demonstrate Dart function concepts.

7. Recursive Function:

dart

// Recursive function to calculate factorial
int factorial(int n) {
if (n == 0 || n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}

void main() {
// Example usage
int result = factorial(5);
print("Factorial of 5: $result"); // Output: Factorial of 5: 120
}

This example defines a recursive function to calculate the factorial of a number.

8. Function Expression:

dart

// Function expression
int square(int num) => num * num;

void main() {
// Example usage
int result = square(4);
print("Square of 4: $result"); // Output: Square of 4: 16
}

The square function here is defined using a function expression, providing a concise syntax for a single-expression function.

9. Using Functions as Objects:

dart

// Using functions as objects
void greet(String name) {
print("Hello, $name!");
}

void farewell(String name) {
print("Goodbye, $name!");
}

void main() {
// Function as an object
Function messageFunction = greet;
messageFunction("Alice"); // Output: Hello, Alice!

// Reassigning the function
messageFunction = farewell;
messageFunction("Bob"); // Output: Goodbye, Bob!
}

In Dart, functions are first-class citizens, so you can assign them to variables and pass them as arguments.

10. Function with Generic Type:

dart

// Function with generic type
T identity<T>(T value) {
return value;
}

void main() {
// Example usage
String stringValue = identity("Dart");
int intValue = identity(42);

print("String Identity: $stringValue"); // Output: String Identity: Dart
print("Int Identity: $intValue"); // Output: Int Identity: 42
}

This example defines a generic function identity that returns the input value with the same type.

11. Currying:

dart

// Currying example
int Function(int) curryMultiply(int a) {
return (int b) => a * b;
}

void main() {
// Example usage
int Function(int) multiplyByTwo = curryMultiply(2);
print("Curried Multiply: ${multiplyByTwo(5)}"); // Output: Curried Multiply: 10
}

This example showcases currying, a technique where a function with multiple parameters is transformed into a sequence of functions, each taking a single parameter.

These additional examples cover recursive functions, function expressions, using functions as objects, functions with generic types, and currying. Dart’s flexibility with functions allows for a wide range of programming techniques. 

An application: simple Dart console application

• Let’s create a simple Dart console application that incorporates the concepts we’ve discussed.
• This application will include functions with different features like optional parameters, recursion, higher-order functions, and function expressions.

dart

// Dart Console Application

// 1. Basic Function with Parameters and Return Value
int add(int a, int b) {
return a + b;
}

// 2. Function with Optional Positional Parameters
void printMessage(String message, [String additionalMessage]) {
if (additionalMessage != null) {
print("$message $additionalMessage");
} else {
print(message);
}
}

// 3. Recursive Function
int factorial(int n) {
if (n == 0 || n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}

// 4. Higher-Order Function
void performOperation(int a, int b, int Function(int, int) operation) {
var result = operation(a, b);
print("Result: $result");
}

// 5. Function Expression
int square(int num) => num * num;

void main() {
// Example 1: Basic Function
int sum = add(5, 3);
print("Sum: $sum"); // Output: Sum: 8

// Example 2: Optional Positional Parameters
printMessage("Hello"); // Output: Hello
printMessage("Hi", "there"); // Output: Hi there

// Example 3: Recursive Function
int factResult = factorial(5);
print("Factorial of 5: $factResult"); // Output: Factorial of 5: 120

// Example 4: Higher-Order Function
performOperation(6, 4, (x, y) => x - y); // Result: 2

// Example 5: Function Expression
int squareResult = square(4);
print("Square of 4: $squareResult"); // Output: Square of 4: 16
}

Explanation:

• We start by defining various functions, each illustrating different Dart function concepts.
• In the main function, we demonstrate the use of these functions with specific examples.
• Example 1 shows the use of a basic function with parameters and a return value.
• Example 2 demonstrates a function with optional positional parameters.
• Example 3 calculates the factorial of a number using a recursive function.
• Example 4 showcases a higher-order function taking an anonymous function as an argument.
• Example 5 uses a function expression for a concise way to define a simple function.

You can run this Dart program in a Dart-enabled environment, such as DartPad or a local Dart development environment, to see the output. Quiz about this lesson :15 questions with explanation

Dart Functions Quiz:

Here’s a quiz with 15 questions about Dart functions, along with explanations for each answer.

1-What is a Dart function?

a) A class
b) A variable
c) A reusable block of code that performs a specific task
d) A loop

Explanation: Option (c) is correct. A Dart function is a reusable block of code that performs a specific task.

2-How do you declare a basic function in Dart?

a) function myFunction() { }
b) void myFunction() { }
c) def myFunction() { }
d) function void myFunction() { }
Explanation: Option (b) is correct. In Dart, you use void for functions that do not return a value.

3-Which parameter type is used for optional positional parameters?

a) Square brackets []
b) Curly braces {}
c) Angle brackets <>
d) Parentheses ()
Explanation: Option (a) is correct. Optional positional parameters are enclosed in square brackets [].

4-What is the purpose of a recursive function?

a) To print messages
b) To execute a block of code repeatedly
c) To calculate a value by breaking the problem into smaller instances of the same problem
d) To define variables

Explanation: Option (c) is correct. A recursive function solves a problem by breaking it down into smaller instances of the same problem.

5-Which keyword is used for defining default parameter values?

a) let
b) default
c) with
d) =

Explanation: Option (d) is correct. The = symbol is used to provide default values for parameters.

6-What is the primary benefit of using named parameters in Dart functions?

a) Improved code readability
b) Better performance
c) Reduced code size
d) Simplified syntax

Explanation: Option (a) is correct. Named parameters improve code readability by explicitly specifying the parameter names when calling a function.

7-In Dart, how are functions used as first-class citizens?

a) They can only be declared in the global scope
b) They cannot be passed as arguments to other functions
c) They can be assigned to variables and passed as arguments
d) They cannot be returned from other functions

Explanation: Option (c) is correct. Functions in Dart can be assigned to variables and passed as arguments to other functions.

8-What does a function expression in Dart represent?

a) A reusable block of code
b) A one-liner function
c) A function that takes no parameters
d) A function with named parameters

Explanation: Option (b) is correct. A function expression in Dart represents a concise one-liner function.

9-Which Dart feature allows a function to access variables from its lexical scope?

a) Inheritance
b) Closure
c) Encapsulation
d) Abstraction

Explanation: Option (b) is correct. Dart supports lexical closures, allowing a function to access variables from its lexical scope.

10-What is the purpose of currying in Dart?

a) To add multiple parameters to a function
b) To transform a function with multiple parameters into a sequence of functions
c) To remove parameters from a function
d) To concatenate functions

Explanation: Option (b) is correct. Currying transforms a function with multiple parameters into a sequence of functions, each taking a single parameter.

11-Which Dart concept is used to define a generic function?

a) Templates
b) Generics
c) Dynamic types
d) Polymorphism

Explanation: Option (b) is correct. Dart uses generics to define functions that can work with various types.

12-What is the primary use of higher-order functions in Dart?

a) Performing arithmetic operations
b) Handling exceptions
c) Working with functions as data
d) Implementing class constructors

Explanation: Option (c) is correct. Higher-order functions in Dart allow working with functions as data, enabling powerful programming techniques.

13-How is a function expression different from a regular function declaration?

a) Function expressions are always asynchronous
b) Function expressions cannot have parameters
c) Function expressions use a concise one-liner syntax
d) Function expressions do not have a return statement

Explanation: Option (c) is correct. Function expressions use a concise one-liner syntax compared to regular function declarations.

14-Which keyword is used to define an anonymous function in Dart?

a) anonymous
b) anon
c) lambda
d) No specific keyword is used

Explanation: Option (d) is correct. In Dart, you don’t need a specific keyword to define an anonymous function; you can use the function expression syntax.

15-What is the primary advantage of using default values in function parameters?

a) Improved performance
b) Reduced code size
c) Easier debugging
d) Increased flexibility and convenience when calling functions

Explanation: Option (d) is correct. Using default values in function parameters provides increased flexibility and convenience when calling functions.