Skip to main content
The <= (less than or equal to) operator is a relational binary operator that evaluates whether the left operand is less than or equivalent to the right operand. In Dart, relational operators are not primitive language constructs but are implemented as instance methods on classes. The expression a <= b is syntactic sugar that invokes the operator <= method on the left operand, passing the right operand as the argument. 
leftOperand <= rightOperand

​
Type Constraints and Evaluation

By default, the <= operator is defined within the core num class and is inherited by its concrete subclasses, int and double. It handles cross-type numerical comparisons (e.g., comparing an int to a double) natively. 
bool isLess = 5 <= 10;                  // Evaluates to true
bool isEquivalent = 3.14 <= 3.14;       // Evaluates to true
bool crossType = 5 <= 5.0;              // Evaluates to true
bool isGreater = 10 <= 5;               // Evaluates to false

​
Operator Overloading

Because <= is an instance method, it can be overridden in custom classes to define domain-specific relational logic. Unlike the == operator (which is constrained by the Object class signature to return a bool), Dart does not enforce a specific return type for the relational operators (<, <=, >, >=). While returning a bool is the standard convention and best practice, the compiler allows the overridden <= method to return any type. Furthermore, Dart does not automatically synthesize the >= operator when <= is overridden; each relational operator must be explicitly defined if required. 
class Magnitude {
  final double value;

  const Magnitude(this.value);

  // Overriding the <= operator
  bool operator <=(Magnitude other) {
    return this.value <= other.value;
  }
}

void main() {
  Magnitude mag1 = Magnitude(10.5);
  Magnitude mag2 = Magnitude(20.0);

  // Invokes the `operator <=` method on mag1, passing mag2 as the argument
  bool result = mag1 <= mag2; 
}
Tired of Poor Dart Skills? Fix That With Deep Grasping!Learn More