Dart Multiplication

The * (asterisk) in Dart functions primarily as a binary infix operator for multiplicative operations, and lexically as a suffix modifier for generator functions and yield delegation.

The Binary Operator (`*`)

As an operator, * is a syntactic sugar for a method call on the left operand. It possesses multiplicative precedence (level 14 in Dart’s precedence table), meaning it evaluates after unary operators but before additive operators, with left-to-right associativity.

Built-in Implementations

1. Numeric Multiplication When applied to num types (int or double), it performs standard arithmetic multiplication. The return type is determined by the operands: if both are int, it returns an int; if either is a double, it returns a double.

int a = 5 * 2;       // Evaluates to 10
double b = 5.0 * 2;  // Evaluates to 10.0

2. String Repetition Dart’s String class implements the * operator, accepting an int as the right operand. It returns a new string containing the original string repeated the specified number of times.

String repeated = 'Dart' * 3; // Evaluates to 'DartDartDart'

Operator Overloading

Because * is implemented as an instance method, it can be overridden in user-defined classes using the operator keyword. The right operand can be of any type specified by the method signature.

class Matrix {
  final List<int> values;
  Matrix(this.values);

  // Overloading the * operator
  Matrix operator *(int scalar) {
    return Matrix(values.map((v) => v * scalar).toList());
  }
}

Matrix m1 = Matrix([1, 2, 3]);
Matrix m2 = m1 * 2; 

Lexical Modifiers (Generators)

Beyond binary operations, the * symbol is a structural component of Dart’s generator syntax. It modifies the behavior of functions and the yield keyword. 1. sync* and async* Appending * to the sync or async keywords transforms a standard function into a generator function.

sync* forces the function to return an Iterable<T> and evaluates synchronously.
async* forces the function to return a Stream<T> and evaluates asynchronously.

Iterable<int> synchronousGenerator() sync* {
  yield 1;
}

Stream<int> asynchronousGenerator() async* {
  yield 1;
}

2. yield* (Yield Delegation) When appended to the yield keyword, * delegates the emission of values to another Iterable or Stream. Instead of emitting the collection as a single object, yield* flattens the sequence, emitting each element of the delegated collection individually into the current generator’s output.

Iterable<int> delegatedGenerator() sync* {
  yield* synchronousGenerator(); 
}

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

Methods

Constructors

Classes

Getters & Setters

Variables

Fields

Parameters

Pattern Matching

Generics

Extensions

Type Aliases

Enums

Control Flow

Loops

Error Handling

Standard Library Types

Annotations

Libraries & Imports

Built-In Types

Comments

Cascade Operators

Spread Operators

Access Operators

Type Cast & Test Operators

Conditional Operators

Arithmetic Operators

Comparison Operators

Logical Operators

Increment & Decrement Operators

Unary Operators

Bitwise Operators

Assignment Operators

Dart Multiplication

The Binary Operator (`*`)

Built-in Implementations

Operator Overloading

Lexical Modifiers (Generators)

​The Binary Operator (*)

​Built-in Implementations

​Operator Overloading

​Lexical Modifiers (Generators)

The Binary Operator (`*`)

Built-in Implementations

Operator Overloading

Lexical Modifiers (Generators)