Skip to main content
The & operator in Dart functions as a bitwise AND operator for integers and a non-short-circuiting logical AND (logical conjunction) operator for booleans. It evaluates both operands and returns a result based on the intersection of their binary bits or logical truth values. 
// Integer bitwise AND
int intResult = intExpression1 & intExpression2;

// Boolean non-short-circuiting AND
bool boolResult = boolExpression1 & boolExpression2;

​
Integer Implementation (Bitwise AND)

When applied to int operands, the & operator evaluates the two’s complement binary representation of the values. It compares the operands bit-by-bit, returning a new integer where each bit is set to 1 only if both corresponding bits in the operands are 1. 
int a = 12; // Binary representation: 1100
int b = 10; // Binary representation: 1010

int result = a & b;
Bitwise Evaluation: 
  1100  (12)
& 1010  (10)

  1000  (8)
In this evaluation, only the leftmost bit is 1 in both operands. Therefore, the resulting binary sequence is 1000, which translates to the decimal integer 8.

​
Boolean Implementation (Non-Short-Circuiting AND)

When applied to bool operands, the & operator performs a logical conjunction. Unlike the standard logical AND operator (&&), which short-circuits and skips evaluating the right operand if the left operand evaluates to false, the & operator guarantees the evaluation of both operands. It returns true only if both operands evaluate to true. 
bool evaluateLeft() => false;
bool evaluateRight() => true;

// Both evaluateLeft() and evaluateRight() are executed
bool result = evaluateLeft() & evaluateRight();
Boolean Truth Table:
  • false & false yields false
  • false & true yields false
  • true & false yields false
  • true & true yields true

​
Type Constraints

The & operator is explicitly defined as an instance method in both the int and bool core classes. The operands on both sides of the operator must match the expected type of the class implementing it (int & int or bool & bool). Attempting to use the & operator on unsupported types, such as double or String, will result in a compile-time error unless the class explicitly overrides the operator &.
Tired of Poor Dart Skills? Fix That With Deep Grasping!Learn More