Operators
## Learning Objectives
- Understand arithmetic operators
- Master comparison and logical operators
- Learn bitwise operators
- Use cascade notation
- Work with type test operators
## Arithmetic Operators
```dart
void main() {
int a = 10;
int b = 3;
print(a + b); // 13 - addition
print(a - b); // 7 - subtraction
print(a * b); // 30 - multiplication
print(a / b); // 3.333... - division (double)
print(a ~/ b); // 3 - integer division
print(a % b); // 1 - modulo (remainder)
}
```
### Increment and Decrement
```dart
void main() {
int x = 5;
print(x++); // 5 (post-increment, then x becomes 6)
print(x); // 6
print(++x); // 7 (pre-increment, x becomes 7 first)
print(x--); // 7 (post-decrement)
print(x); // 6
}
```
## Comparison Operators
```dart
void main() {
print(5 == 5); // true - equal
print(5 != 3); // true - not equal
print(5 > 3); // true - greater than
print(5 < 3); // false - less than
print(5 >= 5); // true - greater than or equal
print(5 <= 3); // false - less than or equal
}
```
## Logical Operators
```dart
void main() {
bool a = true;
bool b = false;
print(a && b); // false - AND
print(a || b); // true - OR
print(!a); // false - NOT
}
```
### Short-circuit Evaluation
```dart
void main() {
// AND - stops if first is false
false && print('never runs');
// OR - stops if first is true
true || print('never runs');
}
```
## Assignment Operators
```dart
void main() {
int x = 10;
x += 5; // x = 15
x -= 3; // x = 12
x *= 2; // x = 24
x ~/= 4; // x = 6
x %= 5; // x = 1
print(x);
}
```
## Bitwise Operators
```dart
void main() {
int a = 5; // binary: 101
int b = 3; // binary: 011
print(a & b); // 1 - AND
print(a | b); // 7 - OR
print(a ^ b); // 6 - XOR
print(~a); // -6 - NOT
print(a << 1); // 10 - left shift
print(a >> 1); // 2 - right shift
}
```
## Type Test Operators
```dart
void main() {
dynamic value = 'Hello';
print(value is String); // true
print(value is int); // false
print(value is! String); // false
}
```
### as Operator (Type Cast)
```dart
void main() {
dynamic value = 'Hello';
// Using 'as' for type promotion
String str = value as String;
print(str.length); // 5
// Caution: will throw if not correct type
// int num = value as int; // Runtime error
}
```
## Null-aware Operators
```dart
void main() {
String? name;
print(name ?? 'Unknown'); // Unknown (if null, use 'Unknown')
print(name?.length); // null (safe navigation)
// print(name!.length); // Error: null (forced unwrap)
}
```
## Cascade Notation
### Problem Without Cascade
```dart
void main() {
var paint = Paint();
paint.color = Colors.black;
paint.strokeWidth = 5.0;
paint.style = PaintingStyle.stroke;
}
```
### With Cascade
```dart
void main() {
var paint = Paint()
..color = Colors.black
..strokeWidth = 5.0
..style = PaintingStyle.stroke;
}
```
### Null-aware Cascade
```dart
void main() {
Paint? paint;
// Only cascades if not null
paint
?..color = Colors.black
..strokeWidth = 5.0;
}
```
## Spread Operator
### List Spread
```dart
void main() {
var list1 = [1, 2, 3];
var list2 = [0, ...list1, 4]; // [0, 1, 2, 3, 4]
// Null-aware spread
List? nullableList;
var list3 = [0, ...?nullableList, 4]; // [0, 4]
}
```
### Map Spread
```dart
void main() {
var map1 = {'a': 1, 'b': 2};
var map2 = {'c': 3, ...map1}; // {'c': 3, 'a': 1, 'b': 2}
}
```
## Conditional Expression
### Ternary Operator
```dart
void main() {
int age = 20;
String status = age >= 18 ? 'Adult' : 'Minor';
print(status); // Adult
}
```
### If-null Operator
```dart
void main() {
String? name;
String displayName = name ?? 'Guest';
print(displayName); // Guest
}
```
## Other Operators
### Member Access
```dart
void main() {
var list = [1, 2, 3];
print(list.length); // 3
print(list.first); // 1
print(list.isEmpty); // false
}
```
### Function Call
```dart
void greet(String name) => print('Hello, $name!');
void main() {
greet('Alice'); // Hello, Alice!
}
```
### Comma Operator
```dart
void main() {
// Comma separates expressions, returns last value
var result = (print('one'), print('two'), print('three'));
// Prints: one, two, three
}
```
## Operator Precedence
| Precedence | Operators |
|------------|-----------|
| Highest | `()` `[]` `.` `?.` |
| | `-` `!` `~` `++` `--` |
| | `*` `/` `%` `~/` |
| | `+` `-` |
| | `<<` `>>` `>>>` |
| | `&` |
| | `^` |
| | `\|` |
| | `>=` `>` `<=` `<` `as` `is` `is!` |
| | `??` |
| | `&&` |
| | `\|\|` |
| Lowest | `? :` `=` `+=` `-=` etc. |
## Summary
- Arithmetic: `+`, `-`, `*`, `/`, `~/`, `%`
- Comparison: `==`, `!=`, `>`, `<`, `>=`, `<=`
- Logical: `&&`, `||`, `!`
- Cascade `..` chains method calls on same object
- Null-aware: `?.`, `??`, `?..`
- Spread: `...`, `...?` for collections
- Ternary: `condition ? expr1 : expr2`
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →