> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Dart Bitwise AND
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.
```dart theme={"dark"}
// 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`.
```dart theme={"dark"}
int a = 12; // Binary representation: 1100
int b = 10; // Binary representation: 1010
int result = a & b;
```
**Bitwise Evaluation:**
```text theme={"dark"}
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`.
```dart theme={"dark"}
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
