DEV Community

Dipankar Paul
Dipankar Paul

Posted on

Understanding Operators in Rust Programming

#rust #tutorial #beginners #programming

In Rust, operators are essential elements for performing various computations and operations on values. They encompass a range of functionalities, including arithmetic, assignment, comparison, and logical operations. This article provides a comprehensive overview of these operators, along with examples to illustrate their usage and behavior.

Arithmetic Operators

Arithmetic operators such as addition (+), subtraction (-), multiplication (*), division (/), and remainder (%) are used for basic mathematical calculations. It's important to note that when dividing integers, the result is also an integer, discarding any remainder.

fn main() {
    let a = 10;
    let b = 3;

    println!("Addition: {}", a + b); // 13
    println!("Subtraction: {}", a - b); // 7
    println!("Multiplication: {}", a * b); // 30
    println!("Division: {}", a / b); // 3
    println!("Remainder: {}", a % b); // 1
}
Enter fullscreen mode Exit fullscreen mode

Assignment Operators

Assignment operators (=, +=, -= , *= , /=, %=) are used to assign values to variables and perform arithmetic operations simultaneously. These operators are convenient for concise and readable code.

  • = (Assignment)
  • += (Add and assign)
  • -= (Subtract and assign)
  • *= (Multiply and assign)
  • /= (Divide and assign)
  • %= (Remainder and assign) 
fn main() {
    let mut a = 5;

    a += 2; // equivalent to a = a + 2;
    println!("After addition: {}", a); // 7

    a *= 3; // equivalent to a = a * 3;
    println!("After multiplication: {}", a); // 21
}
Enter fullscreen mode Exit fullscreen mode

Comparison Operators

Comparison operators (==, !=, <, >, <=, >=) are used to compare values and determine their relationship. These operators return a boolean value (true or false) based on the comparison result.

  • == (Equal to)
  • != (Not equal to)
  • < (Less than)
  • > (Greater than)
  • <= (Less than or equal to)
  • >= (Greater than or equal to) 
fn main() {
    let x = 5;
    let y = 7;

    println!("Equal: {}", x == y); // false
    println!("Not equal: {}", x != y); // true
    println!("Less than: {}", x < y); // true
    println!("Greater than: {}", x > y); // false
    println!("Less than or equal to: {}", x <= y); // true
    println!("Greater than or equal to: {}", x >= y); // false
}
Enter fullscreen mode Exit fullscreen mode

Logical Operators

Logical operators (&&, ||, !) are used to perform logical operations on boolean values. && represents logical AND, || represents logical OR, and ! represents logical NOT. These operators are often used in conditional statements and loops.

fn main() {
    let a = true;
    let b = false;

    println!("Logical AND: {}", a && b); // false
    println!("Logical OR: {}", a || b); // true
    println!("Logical NOT: {}", !a); // false
}
Enter fullscreen mode Exit fullscreen mode

Understanding and mastering these operators are fundamental to writing efficient and effective Rust code. They provide the building blocks for complex algorithms and logic in Rust programs.

Top comments (0)