7. Операторы

Арифметические операторы

С операторами все просто, почти как в школьном учебнике.

Сложение a + b

Вычитание a - b

Умножение a * b

Деление a / b

Остаток от деления a % b

Приоритет арифметических операторов

Выражения обрабатываются последовательно слева направо. Операторы с более высоким приоритетом выполняются первыми. Выражения в скобках вычисляются отдельно.

Умножение, деление и остаток имеют более высокий приоритет, чем сложение и вычитание.

3 + 4 * 5    эквивалентно    3 + (4 * 5)

Оператор присваивания

Знак = означает присваивание или назначение (assignment). С этим оператором мы уже познакомились при изучении переменных.

Пример вычитания

let sum_num: i8;
sum_num = 15 - 6;	// sum_num сохранит 9

Составное присваивание

Применяется для укорачивания кода. Допустим нам нужно увеличить переменную на какую-то величину:

let mut sum_num: i8 = 10;
sum_num = sum_num + 2;	//12

То же самое можно сделать чуть короче, не повторяя имя переменной.

let mut sum_num: i8 = 10;
sum_num += 2;	//12

Перечень составных операторов присваивания (compound assignment):

А увеличить на число X a += x

А уменьшить на число X a -= x

А разделить на число X a /= x

А умножить на число X a *= x

А присвоить остаток от деления на число X a %= x

Операторы сравнения

А равно Б a == b

А не равно Б a != b

А больше, чем Б a > b

А меньше, чем Б a < b

А больше или равно Б a >= b

А меньше или равно Б a <= b

Операторы сравнения части используются в программировании. Результатом этих выражений будет истина или ложь (true or false).

fn main() {
    let a = 2;
    let b = 3;
    println!("Operand 1:{}, Operand 2:{}", a , b);
    println!("a > b  : {}", a > b);
    println!("a < b  : {}", a < b);
    println!("a >= b : {}", a >= b);
    println!("a <= b : {}", a <= b);
    println!("a == b : {}", a == b);
    println!("a != b : {}", a != b);
}

Результат: a > b : false a < b : true a >= b : false a <= b : true a == b : false a != b : true

Приоритет операторов сравнения

Выражения обрабатываются последовательно слева направо

fn main() {
	let x = (3 > 2) > (5 == 5);
	print!("{}", x);
}

Результат: false

Давайте разбираться почему именно такой результат. Сначала происходит вычисление выражений в скобках и мы получаем: (true) > (true) или это можно интерпретировать как (1) > (1), что, конечно же, ложь.

Логические операторы

Отрицание (not) Не А !a

Конъюнкция (логическое умножение)(and) А и Б a && b

Дизъюнкция (логическое сложение)(or) А или Б a || b

Пример:

fn main() {
    let a = true;
    let b = false;
    println!("NOT: {}", !a);
    println!("AND: {}", a && b);
    println!("OR:  {}", a || b);
}

Результат: NOT: false AND: false OR: true

Самый простой оператор отрицания, он просто превращает истину в ложь, а ложь в истину. 

С операторами AND и OR часто возникает путаница, но в них не так уж сложно разобраться. Пусть истина это 1, а ложь это 0. Соответственно для AND перемножьте их.

true && true == true эквивалентно 1 * 1 == 1

true && false == false эквивалентно 1 * 0 == 0

false && false == false эквивалентно 0 * 0 == 0

А для OR нужно складывать истину и ложь.

true || true == true эквивалентно 1 + 1 == 1

true || false == true эквивалентно 1 + 0 == 1

false || false == false эквивалентно 0 + 0 == 0

Опишу более образно. Чтобы понять как работает AND(и), представьте человека, которые делает высказывания, соответственно, если этот человек хоть раз вам соврал, то он лжец. Чтобы понять как работает OR(или), то представьте, что вы загадываете другому человеку загадки и если он хоть раз угадал, то он молодец, нашел истину.

Приоритет логических операторов

Приоритет оператора && выше приоритета ||.

a && b || s    эквивалентно    (a && b) || s

Приоритет логических операторов ниже операторов сравнения.

3 > 2 || 4< 1    эквивалентно    (3 > 2) || (4< 1)

Эта запись сводится к выражению true || false, в результате получим Истину

Несколько полезных методов

Пока нет необходимости вникать в то как это устроено, просто запомните их для решения будущих практических задач.

Корень квадратный (sqrt)

Чтобы вычислить корень квадратный, нужно после числа или переменной поставить точку и написать .sqrt().

Пример вычисления квадратного корня из положительного, отрицательного числа, нуля и отрицательного нуля:

fn main() {
	println!("√+6.25 ==  {}", 6.25_f64.sqrt());
	println!("√-6.25 == {}", (-6.25_f64).sqrt());
	println!("√ 0 ==  {}", 0_f64.sqrt());
	println!("√-0 == {}", (-0_f64).sqrt());
}

Результат: √+6.25 == 2.5 √-6.25 == NaN √ 0 == 0 √-0 == -0

NaN - означает что результат неопределен.

Возведение в степень (pow)

Можно просто перемножить числа несколько раз, а можно воспользоваться методом .powf() для чисел с плавающей запятой.

Пример:

fn main() {
	println!("{}", 2.0_f64.powf(3.0));
}

Результат: 8

Больше методов в документации по стандартной библиотеке Rust: https://doc.rust-lang.org/std/primitive.f64.html#implementations