Dart Function - SyntBlaze

A function in Dart is a first-class object of type Function that encapsulates a reusable block of code. Because Dart is a true object-oriented language, functions can be assigned to variables, passed as arguments to other functions, and returned as results from other functions.

Basic Syntax

A standard function declaration includes a return type, an identifier, a parameter list, and a block body. Type annotations are optional but recommended for static type checking.

ReturnType functionName(ParameterType parameterName) {
  // execution block
  return expression;
}

If no return type is explicitly defined, it defaults to dynamic. If a function does not explicitly return a value, it implicitly returns null.

Parameter Structures

Dart categorizes parameters into two primary types: positional and named. A function can utilize both, but positional parameters must precede named parameters.

1. Positional Parameters

Arguments are mapped to parameters based on their exact position in the signature.

Required Positional: Must be provided by the caller.

void executeTask(int a, int b) {}

Optional Positional: Wrapped in square brackets []. They must be nullable or have a default value.

void executeTask(int a, [int? b, int c = 0]) {}

2. Named Parameters

Arguments are passed by name, making the call site order-independent. They are wrapped in curly braces {}. Named parameters are optional by default unless explicitly annotated with the required keyword.

void configureSettings({required String host, int port = 8080, bool? isSecure}) {}

// Invocation
configureSettings(host: 'localhost', isSecure: true);

Arrow Syntax (Expression Bodies)

For functions containing only a single expression, Dart provides the => (fat arrow) shorthand. The => expr syntax is strictly equivalent to { return expr; }. It accepts only an expression, not a statement.

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

Anonymous Functions

Functions can be declared without an identifier. These are known as anonymous functions, lambdas, or closures. They consist of a parameter list followed by a block body or an arrow expression.

(Type param) {
  // execution block
};

// Or using arrow syntax
(Type param) => expression;

Lexical Scope and Closures

Dart is a lexically scoped language, meaning the scope of variables is determined statically by the layout of the code. A closure is a function object that captures variables from its lexical scope. The function retains access to those variables even if it is executed outside of their original scope.

Function makeAdder(int addBy) {
  return (int i) => addBy + i; // Captures 'addBy' from the outer scope
}

Generator Functions

Dart supports generator functions to lazily produce a sequence of values.

Synchronous Generator: Returns an Iterable. Marked with sync* and yields values using the yield keyword.

Iterable<int> generateSequence(int max) sync* {
  for (int i = 0; i < max; i++) yield i;
}

Asynchronous Generator: Returns a Stream. Marked with async* and yields values asynchronously.

Stream<int> generateAsyncSequence(int max) async* {
  for (int i = 0; i < max; i++) yield i;
}

Tired of Poor Dart Skills? Fix That With Deep Grasping!Learn More

​Basic Syntax

​Parameter Structures

​1. Positional Parameters

​2. Named Parameters

​Arrow Syntax (Expression Bodies)

​Anonymous Functions

​Lexical Scope and Closures

​Generator Functions