Dart bool

The bool type in Dart is a built-in class representing a boolean logic state. Because Dart is a pure object-oriented language, booleans are objects rather than raw primitive data types. A bool is instantiated using one of two compile-time constant literals: true or false. Unlike languages with “truthy” or “falsy” evaluations, Dart enforces strict boolean typing. Control flow statements, conditional expressions, and logical operators strictly require an expression that evaluates to a bool. Dart will not implicitly cast integers, strings, or objects to boolean values; attempting to do so results in a compile-time error.

Constructors and Environment Declarations

The bool class cannot be instantiated via a standard generative constructor. Instead, it provides two constant factory constructors used exclusively for compile-time configuration via environment declarations:

bool.fromEnvironment(String name, {bool defaultValue = false}): Returns the boolean value of the environment declaration name.
bool.hasEnvironment(String name): Returns true if an environment declaration name exists.

const bool isDebug = bool.fromEnvironment('DEBUG_MODE', defaultValue: false);
const bool hasConfig = bool.hasEnvironment('APP_CONFIG');

Declaration and Null Safety

Under Dart’s sound null safety system, a standard bool is non-nullable. To allow a boolean variable to hold an uninitialized or absent state, it must be explicitly declared as a nullable boolean (bool?).

bool isActive = true;          // Explicitly typed, non-nullable
var isComplete = false;        // Type inferred as bool
bool? isPending = null;        // Nullable boolean

Logical Operators

Dart provides two categories of logical operations for booleans: language-level control flow constructs and operator methods defined directly on the bool class. Language-Level Constructs (Short-Circuiting) The && (logical AND) and || (logical OR) operators are language-level control flow constructs, not methods on the bool class. They perform short-circuit evaluation, meaning the right operand is only evaluated if the left operand does not definitively determine the overall result. The ! operator is a unary prefix operator for logical negation. Class Methods (Non-Short-Circuiting) The bool class explicitly defines three operator methods. Unlike && and ||, these methods evaluate both operands strictly and do not short-circuit:

& (Logical AND): Returns true if both operands are true.
| (Logical OR): Returns true if either operand is true.
^ (Logical XOR): Returns true if exactly one operand is true.

bool a = true;
bool b = false;

// Language-level short-circuiting constructs
bool shortAnd = a && b; // Evaluates to false (evaluates 'b' because 'a' is true)
bool shortOr  = a || b; // Evaluates to true (short-circuits and ignores 'b')
bool notA     = !a;     // Evaluates to false

// bool class methods (non-short-circuiting, evaluates both operands)
bool strictAnd = a & b; // Evaluates to false
bool strictOr  = a | b; // Evaluates to true
bool strictXor = a ^ b; // Evaluates to true

Parsing Strings to Booleans

Dart provides static methods on the bool class to parse string representations of boolean values. Both methods accept an optional caseSensitive named parameter.

bool.parse(String source, {bool caseSensitive = true}): Parses a string into a boolean. By default, it strictly accepts the exact strings 'true' or 'false'. If caseSensitive is set to false, it accepts mixed-case variations. Passing an invalid string throws a FormatException.
bool.tryParse(String source, {bool caseSensitive = true}): Operates identically to parse(), but returns null instead of throwing an exception when provided an invalid string.

bool validParse = bool.parse('true');                           // Returns true
bool validFalse = bool.parse('false');                          // Returns false

bool mixedCase = bool.parse('True', caseSensitive: false);      // Returns true
// bool.parse('True');                                          // Throws FormatException
// bool.parse('1');                                             // Throws FormatException

bool? safeParse = bool.tryParse('FALSE', caseSensitive: false); // Returns false
bool? invalidSafe = bool.tryParse('yes');                       // Returns null

Platform Representation

Because Dart compiles to multiple targets, the underlying memory representation of bool depends on the compilation pipeline:

Dart Native (AOT/JIT VM): true and false are heap-allocated objects (instances of the VM’s internal Bool class). They are not raw machine primitives in memory, which is why they can be assigned to Object variables. However, the Ahead-Of-Time (AOT) compiler may unbox them locally into machine-level registers during optimization.
Dart Web (dart2js/dartdevc): bool maps directly to the underlying JavaScript boolean primitive to ensure zero-overhead interoperability and execution in the browser.

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

Constructors and Environment Declarations

Declaration and Null Safety

Logical Operators

Parsing Strings to Booleans

Platform Representation

​Constructors and Environment Declarations

​Declaration and Null Safety

​Logical Operators

​Parsing Strings to Booleans

​Platform Representation

Constructors and Environment Declarations

Declaration and Null Safety

Logical Operators

Parsing Strings to Booleans

Platform Representation