Default Parameter Values

Default Parameter Values in Dart allow you to set default values for function parameters. This means that if a function is called without passing a value for a parameter with a default value, the default value will be used instead. It provides flexibility and convenience in function definitions.

What are Default Parameter Values?

Default Parameter Values were introduced in Dart 2.2. They were added to simplify function calls and reduce the need for overloading functions with different parameter sets. By providing default values for parameters, developers can define functions that can be called with fewer arguments, making the code more readable and concise.

Syntax

void functionName({Type parameterName = defaultValue}) {
  // function body
}

• ✅ functionName: The name of the function.
• ✅ Type: The data type of the parameter.
• ✅ parameterName: The name of the parameter.
• ✅ defaultValue: The default value assigned to the parameter.

Key Features

• ✅ Allows defining functions with default parameter values.
• ✅ Simplifies function calls by providing default values for parameters.
• ✅ Reduces the need for overloaded functions with different parameter sets.
• ✅ Improves code readability and conciseness.

Example 1: Basic Usage

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

void main() {
  greet(); // no argument provided
  greet(name: 'Alice'); // argument provided
}
Try it Yourself

Output:

Hello, Guest!
Hello, Alice!

In this example, the greet function has a default parameter value for name. When called without an argument, it uses the default value 'Guest'. When called with an argument, it uses the provided value.

Example 2: Practical Application

void generateReport({String format = 'pdf', bool includeCharts = true}) {
  print('Generating report in $format format with charts: $includeCharts');
}

void main() {
  generateReport(); // default values used
  generateReport(format: 'csv', includeCharts: false); // custom values provided
}

Output:

Generating report in pdf format with charts: true
Generating report in csv format with charts: false

In this example, the generateReport function demonstrates using default parameter values for format and includeCharts. When the function is called without arguments, it uses the default values. When specific values are provided, they override the defaults.

Comparison Table

Common Mistakes to Avoid

1. Ignoring Optional Parameters

Problem: Beginners often forget that Dart allows for both positional and named optional parameters. Failing to use them correctly can lead to confusion and errors in function calls.

// BAD - Don't do this
void greet(String name) {
  print("Hello, $name!");
}

// Calling without optional parameters
greet(); // Error: Too few positional arguments

Solution:

// GOOD - Do this instead
void greet([String name = "Guest"]) {
  print("Hello, $name!");
}

// Now it can be called with or without an argument
greet(); // Output: Hello, Guest!
greet("Alice"); // Output: Hello, Alice!

Why: The original code requires a name to be passed every time, leading to runtime errors if not provided. By using optional parameters with a default value, the function becomes more flexible and user-friendly.

2. Mixing Positional and Named Parameters Incorrectly

Problem: Beginners often mix positional and named parameters without understanding their precedence, which can lead to unexpected behavior.

// BAD - Don't do this
void displayInfo(String name, {int age}) {
  print("Name: $name, Age: $age");
}

// Calling with positional argument only
displayInfo("Alice", 30); // Error: The argument type 'int' can't be assigned to the parameter type 'Map<String, int>'

Solution:

// GOOD - Do this instead
void displayInfo(String name, {int age = 0}) {
  print("Name: $name, Age: $age");
}

// Correctly using named parameters
displayInfo("Alice", age: 30); // Output: Name: Alice, Age: 30

Why: In Dart, named parameters must be specified by their names in function calls. Mixing positional and named parameters without proper syntax leads to confusion and errors.

3. Not Providing Default Values

Problem: Some developers neglect to provide default values for optional parameters, which can result in null values being used in code.

// BAD - Don't do this
void calculateArea(int width, int height) {
  int area = width * height;
  print("Area: $area");
}

// Not handling optional cases
calculateArea(5); // Error: Too few positional arguments

Solution:

// GOOD - Do this instead
void calculateArea([int width = 1, int height = 1]) {
  int area = width * height;
  print("Area: $area");
}

// Now can be called with fewer arguments
calculateArea(5); // Output: Area: 5
calculateArea(5, 10); // Output: Area: 50

Why: Not providing default values forces the user to always supply both parameters, which can be inconvenient. By providing default values, you enhance the function's usability.

4. Using Nullable Types Unnecessarily

Problem: Beginners sometimes declare optional parameters as nullable types even when default values are provided, leading to unnecessary complexity.

// BAD - Don't do this
void printMessage(String message, {String? prefix}) {
  print("$prefix$message");
}

// Calling with null prefix
printMessage("Hello!"); // Output: nullHello!

Solution:

// GOOD - Do this instead
void printMessage(String message, {String prefix = ""}) {
  print("$prefix$message");
}

// Prefix is now safely defaulted
printMessage("Hello!"); // Output: Hello!

Why: Using a nullable type with optional parameters can lead to unintended null values. By using a default value, you eliminate the risk of null and simplify your code.

5. Overloading Functions Incorrectly

Problem: Some beginners try to overload functions with different default parameter values, leading to confusion and errors.

// BAD - Don't do this
void sendMessage(String message, {int priority = 1}) {
  print("Sending message: $message with priority $priority");
}

// Attempting to overload
void sendMessage(String message) {
  sendMessage(message, priority: 2);
}

Solution:

// GOOD - Do this instead
void sendMessage(String message, {int priority = 1}) {
  print("Sending message: $message with priority $priority");
}

// Use function calls instead of overloading
sendMessage("Hello!"); // Output: Sending message: Hello! with priority 1

Why: Dart does not support traditional function overloading based on parameter defaults. Instead, consider using named parameters to handle optional defaults within a single function.

Best Practices

1. Use Named Parameters for Clarity

Using named parameters enhances code readability by allowing you to explicitly indicate what each argument represents.

void createUser({required String username, required String email, String role = "user"}) {
  print("Creating user: $username with email: $email and role: $role");
}

Why: This practice is important as it makes the function calls self-documenting, reducing the need for comments and making code easier to understand.

2. Always Provide Default Values for Optional Parameters

When defining optional parameters, always provide sensible default values to avoid null reference issues.

void logMessage(String message, {String level = "INFO"}) {
  print("[$level] $message");
}

Why: Default values improve reliability and usability, allowing the function to be called without specifying every parameter while still maintaining expected behavior.

3. Document Parameter Defaults

Always include documentation for your functions that use default parameter values, explaining what the defaults are and their purpose.

/// Creates a new user with optional role.
/// If no role is provided, the default is "user".
void createUser(String username, {String role = "user"}) {
  // ...
}

Why: Clear documentation helps other developers (and your future self) understand the intended use and behavior of the function, facilitating easier maintenance.

4. Consistency in Parameter Types

Be consistent with the types of parameters, especially when using optional parameters. Mixing types can lead to confusion and errors.

void loadData({String? url, int? timeout}) {
  // Implementation
}

Why: Consistency in parameter types makes the function easier to use and understand, reducing the cognitive load on other developers.

5. Use Optional Parameters Judiciously

While optional parameters are powerful, avoid overusing them in a single function. Strive for a balance between flexibility and simplicity.

void configureSettings({bool enableFeature = false, int timeout = 30, String mode = "default"}) {
  // Implementation
}

Why: Too many optional parameters can lead to confusion regarding the function's purpose, making it harder to use correctly. Consider breaking complex functions into smaller, more focused ones.

6. Favor Named Parameters for Functions with Multiple Optional Parameters

When dealing with multiple optional parameters, prefer named parameters over positional ones for clarity.

void setupConnection({String host = "localhost", int port = 80, bool secure = false}) {
  // Implementation
}

Why: Named parameters allow for more straightforward function calls, improving code readability and maintainability.

Key Points