AI Reading
Quick summary of this article
Dart provides a wide range of operators to handle different programming tasks, including arithmetic, relational, logical, assignment, unary, conditional, type testing, and bitwise operations. These operators allow developers to perform mathematical calculations, compare values, make logical decisions, assign values efficiently, manipulate single operands, check types at runtime, and work with binary data.
- Arithmetic operators (+, -, *, /, %) handle basic math; division returns a decimal value, while modulus returns the remainder.
- Relational operators (==, !=, >, <, >=, <=) compare values and return true or false.
- Logical operators (&&, ||, !) combine boolean conditions; assignment operators like +=, -=, *=, /=, and %= offer shorthand for updating variables.
- Unary operators (++ and --) increment or decrement values; the conditional ternary operator (? 🙂 selects between two expressions based on a condition.
- Bitwise operators (&, |, ^, ~, <<, >>) work on binary representations—for example, 5 & 3 gives 1, and 5 << 1 shifts bits to produce 10.
Dart Operators
Dart provides a variety of operators for different kinds of operations, such as arithmetic, relational, logical, and assignment operations. Here is an overview of the common operators in Dart with examples:
1. Arithmetic Operators
Used for performing mathematical operations.
void main() {
int a = 10;
int b = 3;
print('Addition: ${a + b}'); // 13
print('Subtraction: ${a - b}'); // 7
print('Multiplication: ${a * b}'); // 30
print('Division: ${a / b}'); // 3.3333333333333335
print('Modulus: ${a % b}'); // 1
}
2. Relational Operators
Used for comparing two values.
void main() {
int a = 10;
int b = 20;
print('Equal to: ${a == b}'); // false
print('Not equal to: ${a != b}'); // true
print('Greater than: ${a > b}'); // false
print('Less than: ${a < b}'); // true
print('Greater than or equal to: ${a >= b}'); // false
print('Less than or equal to: ${a <= b}'); // true
}
3. Logical Operators
Used for logical operations, often with boolean values.
void main() {
var x = 10;
var y = 20;
print('Logical AND: ${(x == 10) && (y == 20)}'); // true
print('Logical OR: ${(x != 0) || (y != 0)}'); // true
print('Logical NOT: ${!(x != 0)}'); // false
}
4. Assignment Operators
Used to assign values to variables.
void main() {
int a = 10;
a += 5;
A = a+5
// Equivalent to: a = a + 5
print('a += 5: $a'); // 15
a -= 3; // Equivalent to: a = a - 3
print('a -= 3: $a'); // 12
a *= 2; // Equivalent to: a = a * 2
print('a *= 2: $a'); // 24
a /= 4; // Equivalent to: a = a / 4
print('a /= 4: $a'); // 6.0
a %= 3; // Equivalent to: a = a % 3
print('a %= 3: $a'); // 0.0
}
```
5. Unary Operators
Used for operations on a single operand.
void main() {
int a = 5;
a++;
//a = a + 1;
print('Increment: $a'); // 6
a--;
print('Decrement: $a'); // 5
}
6. Conditional (Ternary) Operator
Used for conditional expressions.
void main() {
int a = 5;
int b = 10;
String result = a > b ? 'a is greater' : 'b is greater';
print(result); // b is greater
}
```
7. Type Test Operators
Used for checking types at runtime.
void main() {
var x = 100;
var y = 'Hello';
print('x is int: ${x is int}'); // true
print('y is String: ${y is String}'); // true
print('x is not double: ${x is! double}'); // true
}
```
8. Bitwise and Shift Operators
Used for bitwise and shift operations.
void main() {
int a = 5; // 0101 in binary
int b = 3; // 0011 in binary
print('Bitwise AND: ${a & b}'); // 1 (0001)
print('Bitwise OR: ${a | b}'); // 7 (0111)
print('Bitwise XOR: ${a ^ b}'); // 6 (0110)
print('Bitwise NOT: ${~a}'); // -6
print('Left shift: ${a << 1}'); // 10 (1010)
print('Right shift: ${a >> 1}'); // 2 (0010)
}
These operators cover most of the common operations you’ll need to perform in Dart. Each operator is used for specific types of operations, making Dart a powerful and flexible language for various programming tasks.
====================================
Bitwise in Details
I can help you visualize how bitwise operations work by breaking down the binary representations of the numbers and showing how the operations are performed step-by-step.
Let’s start with the numbers you provided:
- a = 5 (binary: 0101)
- b = 3 (binary: 0011)
Bitwise AND (a & b)
0101
& 0011
——
0001
The result of 5 & 3 is 1 (binary: 0001).
Bitwise OR (a | b)
0101
| 0011
——
0111
The result of 5 | 3 is 7 (binary: 0111).
Bitwise XOR (a ^ b)
0101
^ 0011
——
0110
The result of 5 ^ 3 is 6 (binary: 0110).
Bitwise NOT (~a)
0101 // a (5)
~ —-
1010 // Invert all bits: -6 in two’s complement form
The result of ~5 is -6.
Left Shift (a << 1)
0101 // a (5)
<< 1
——
1010 // Shift left by 1: 10 in decimal
The result of 5 << 1 is 10 (binary: 1010).
Right Shift (a >> 1)
0101 // a (5)
>> 1
——
0010 // Shift right by 1: 2 in decimal
The result of 5 >> 1 is 2 (binary: 0010).
Full Example in Dart
void main() {
int a = 5; // 0101 in binary
int b = 3; // 0011 in binary
print('Bitwise AND: ${a & b}'); // 1 (0001)
print('Bitwise OR: ${a | b}'); // 7 (0111)
print('Bitwise XOR: ${a ^ b}'); // 6 (0110)
print('Bitwise NOT: ${~a}'); // -6
print('Left shift: ${a << 1}'); // 10 (1010)
print('Right shift: ${a >> 1}'); // 2 (0010)
}
Explanation of Each Operation
- Bitwise AND (a & b):
- Both bits must be 1 to get 1. Result: 0001.
- Bitwise OR (a | b):
- Either bit can be 1 to get 1. Result: 0111.
- Bitwise XOR (a ^ b):
- Bits must be different to get 1. Result: 0110.
- Bitwise NOT (~a):
- Inverts all the bits. The result is -6 because in two’s complement, ~0101 becomes 1010, which is -6 in decimal.
- Left Shift (a << 1):
- Shifts bits to the left by 1 position, filling with 0. Result: 1010.
- Right Shift (a >> 1):
- Shifts bits to the right by 1 position, filling with the sign bit for signed integers. Result: 0010.
This breakdown should help you understand how the bitwise operations work with binary numbers.