The operators are special symbols that are used to carry out certain operations on the operands. The Dart has a large number of built-in operators which can be used to carry out different functions, for example, ‘+’ is used to add two operands. Operators are meant to carry operations on one or two operands.

## Different types of operators in Dart:

- Arithmetic Operators
- Relational Operators
- Type Test Operators
- Bitwise Operators
- Assignment Operators
- Logical Operators
- Conditional Operator
- Casecade Notation Operator

#### 1. Arithmetic Operators:

These class of operators contain those operators which are used to perform arithmetic operation on the operands. They are binary operators i.e they act on two operands. They goes like this:

Operator Symbol | Operator Name | Operator Description |
---|---|---|

+ | Addition | Use to add two operands |

– | Subtraction | Use to subtract two operands |

-expr | Unary Minus | It is Use to reverse the sign of the expression |

* | Multiply | Use to multiply two operands |

/ | Division | Use to divide two operands |

~/ | Division | Use two divide two operands but give output in integer |

% | Modulus | Use to give remainder of two operands |

**Example: Using Arithmetic Operators in the program**

`void` `main()` `{` ` ` `int` `a = ` `2` `;` ` ` `int` `b = ` `3` `;` ` ` ` ` `// Adding a and b` ` ` `var c = a + b;` ` ` `print(` `"Sum of a and b is $c"` `);` ` ` ` ` `// Subtracting a and b` ` ` `var d = a - b;` ` ` `print(` `"The difference between a and b is $d"` `);` ` ` ` ` `// Using unary minus` ` ` `var e = -d;` ` ` `print(` `"The negation of difference between a and b is $e"` `);` ` ` ` ` `// Multipication of a and b` ` ` `var f = a * b;` ` ` `print(` `"The product of a and b is $f"` `);` ` ` ` ` `// Division of a and b` ` ` `var g = b / a;` ` ` `print(` `"The quotient of a and b is $g"` `);` ` ` ` ` `// Using ~/ to divide a and b` ` ` `var h = b ~ / a;` ` ` `print(` `"The quotient of a and b is $h"` `);` ` ` ` ` `// Remainder of a and b` ` ` `var i = b % a;` ` ` `print(` `"The remainder of a and b is $i"` `);` `}` |

**Output:**

Sum of a and b is 5 The difference between a and b is -1 The negation of difference between a and b is 1 Product of a and b is 6 The quotient of a and b is 1.5 The quotient of a and b is 1 The remainder of a and b is 1

#### 2. Relational Operators:

These class of operators contain those operators which are used to perform relational operation on the operands. They goes like this:

Operator Symbol | Operator Name | Operator Description |
---|---|---|

> | Greater than | Check which operand is bigger and give result as boolean expression. |

< | Less than | Check which operand is smaller and give result as boolean expression. |

>= | Greater than or equal to | Check which operand is greater or equal to each other and give result as boolean expression. |

<= | less than equal to | Check which operand is less than or equal to each other and give result as boolean expression. |

== | Equal to | Check whether the operand are equal to each other or not and give result as boolean expression. |

!= | Not Equal to | Check whether the operand are not equal to each other or not and give result as boolean expression. |

**Example: Using Relational Operators in the program**

`void` `main()` `{` ` ` `int` `a = ` `2` `;` ` ` `int` `b = ` `3` `;` ` ` ` ` `// Greater between a and b` ` ` `var c = a > b;` ` ` `print(` `"a is greater than b is $c"` `);` ` ` ` ` `// Smaller between a and b` ` ` `var d = a < b;` ` ` `print(` `"a is smaller than b is $d"` `);` ` ` ` ` `// Greater than or equal to between a and b` ` ` `var e = a >= b;` ` ` `print(` `"a is greater than b is $e"` `);` ` ` ` ` `// Less than or equal to between a and b` ` ` `var f = a <= b;` ` ` `print(` `"a is smaller than b is $f"` `);` ` ` ` ` `// Equality between a and b` ` ` `var g = b == a;` ` ` `print(` `"a and b are equal is $g"` `);` ` ` ` ` `// Unequality between a and b` ` ` `var h = b != a;` ` ` `print(` `"a and b are not equal is $h"` `);` `}` |

**Output:**

a is greater than b is false a is smaller than b is true a is greater than b is false a is smaller than b is true a and b are equal is false a and b are not equal is true

#### 3. Type Test Operators:

These class of operators contain those operators which are used to perform comparison on the operands. They goes like this:

Operator Symbol | Operator Name | Operator Description |
---|---|---|

is | is | Gives boolean value true as output if the object has specific type |

is! | is not | Gives boolean value false as output if the object has specific type |

**Example: Using Type Test Operators in the program**

`void` `main()` `{` ` ` `String a = ` `'GFG'` `;` ` ` `double` `b = ` `3.3` `;` ` ` ` ` `// Using is to compare` ` ` `print(a is String);` ` ` ` ` `// Using is! to compare` ` ` `print(b is !` `int` `);` `}` |

**Output:**

true true

#### 4. Bitwise Operators:

These class of operators contain those operators which are used to perform bitwise operation on the operands. They goes like this:

Operator Symbol | Operator Name | Operator Description |
---|---|---|

& | Bitwise AND | Performs bitwise and operation on two operands. |

| | Bitwise OR | Performs bitwise or operation on two operands. |

^ | Bitwise XOR | Performs bitwise XOR operation on two operands. |

~ | Bitwise NOT | Performs bitwise NOT operation on two operands. |

<< | Left Shift | Shifts a in binary representation to b bits to left and inserting 0 from right. |

>> | Right Shift | Shifts a in binary representation to b bits to left and inserting 0 from left. |

**Example: Using Bitwise Operators in the program**

`void` `main()` `{` ` ` `int` `a = ` `5` `;` ` ` `int` `b = ` `7` `;` ` ` ` ` `// Performing Bitwise AND on a and b` ` ` `var c = a & b;` ` ` `print(c);` ` ` ` ` `// Performing Bitwise OR on a and b` ` ` `var d = a | b;` ` ` `print(d);` ` ` ` ` `// Performing Bitwise XOR on a and b` ` ` `var e = a ^ b;` ` ` `print(e);` ` ` ` ` `// Performing Bitwise NOT on a` ` ` `var f = ~a;` ` ` `print(f);` ` ` ` ` `// Performing left shift on a` ` ` `var g = a << b;` ` ` `print(g);` ` ` ` ` `// Performing right shift on a` ` ` `var h = a >> b;` ` ` `print(h);` `}` |

**Output:**

5 7 2 4294967290 640 0

#### 5. Assignment Operators:

These class of operators contain those operators which are used to assign value to the operands. They goes like this:

Operator Symbol | Operator Name | Operator Description |
---|---|---|

= | Equal to | Use to assign values to the expression or variable |

??= | Assignment opereator | Assign the value only if it is null. |

**Example: Using Assignment Operators in the program**

`void` `main()` `{` ` ` `int` `a = ` `5` `;` ` ` `int` `b = ` `7` `;` ` ` ` ` `// Assigning value to variable c` ` ` `var c = a * b;` ` ` `print(c);` ` ` ` ` `// Assigning value to variable d` ` ` `var d;` ` ` `d ? ? = a + b; ` `// Value is assign as it is null` ` ` `print(d);` ` ` `// Again trying to assign value to d` ` ` `d ? ? = a - b; ` `// Value is not assign as it is not null` ` ` `print(d);` `}` |

**Output:**

35 12 12

#### 6. Logical Operators:

These class of operators contain those operators which are used to logically combine two or more conditions of the operands. They goes like this:

Operator Symbol | Operator Name | Operator Description |
---|---|---|

&& | And Operator | Use to add two conditions and if both are true than it will return true. |

|| | Or Operator | Use to add two conditions and if even one of them is true than it will return true. |

! | Not Operator | It is use to reverse the result. |

**Example: Using Logical Operators in the program**

`void` `main()` `{` ` ` `int` `a = ` `5` `;` ` ` `int` `b = ` `7` `;` ` ` ` ` `// Using And Operator` ` ` `bool c = a > ` `10` `&& b < ` `10` `;` ` ` `print(c);` ` ` ` ` `// Using Or Operator` ` ` `bool d = a > ` `10` `|| b < ` `10` `;` ` ` `print(d);` ` ` ` ` `// Using Not Operator` ` ` `bool e = !(a > ` `10` `);` ` ` `print(e);` `}` |

**Output:**

false true true

#### 7. Conditional Operators:

These class of operators contain those operators which are used to perform comparison on the operands. They goes like this:

Operator Symbol | Operator Name | Operator Description |
---|---|---|

condition ? expersion1 : expersion2 | Conditional Operator | It is a simple version of if..else statement. If the condition is true than expersion1 is executed else expersion2 is executed. |

expersion1 ?? expersion2 | Conditional Operator | If expersion1 is non-null returns its value else returns expression2 value. |

**Example: Using Conditional Operators in the program**

`void` `main()` `{` ` ` `int` `a = ` `5` `;` ` ` `int` `b = ` `7` `;` ` ` ` ` `// Conditional Statement` ` ` `var c = (a < ` `10` `) ? ` `"Statement is Correct, Geek"` `: ` `"Statement is Wrong, Geek"` `;` ` ` `print(c);` ` ` ` ` `// Condtional statement` ` ` `int` `n;` ` ` `var d = n ? ? ` `"n has Null value"` `;` ` ` `print(d);` ` ` ` ` `// After assigning value to n` ` ` `n = ` `10` `;` ` ` `d = n ? ? ` `"n has Null value"` `;` ` ` `print(d);` `}` |

**Output:**

Statement is Correct, Geek n has Null value 10

#### 8. Casecade Notation Operators:

These class of operators allows you to perform a sequence of operation on the same element. It allows you to perform multiple methods on the same object. They goes like this:

Operator Symbol | Operator Name | Operator Description |
---|---|---|

.. | cascading Method | It is used to perform multiple methods on the same object. |

**Example: Using Casecade Notation Operators in the program**

`class` `GFG {` ` ` `var a;` ` ` `var b;` ` ` ` ` `void` `set(x, y)` ` ` `{` ` ` `this` `.a = x;` ` ` `this` `.b = y;` ` ` `}` ` ` ` ` `void` `add()` ` ` `{` ` ` `var z = ` `this` `.a + ` `this` `.b;` ` ` `print(z);` ` ` `}` `}` ` ` `void` `main()` `{` ` ` `// Creating objects of class GFG` ` ` `GFG geek1 = ` `new` `GFG();` ` ` `GFG geek2 = ` `new` `GFG();` ` ` ` ` `// Without using Cascade Notation` ` ` `geek1.set(` `1` `, ` `2` `);` ` ` `geek1.add();` ` ` ` ` `// Using Cascade Notation` ` ` `geek2..set(` `3` `, ` `4` `)` ` ` `..add();` `}` |

**Output:**

3 7