Rust на примерах

Последнее выражение в функции будет использовано как возвращаемое значение. Так же можно использовать оператор return, чтобы вернуть значение из функции раньше, даже из цикла или оператора if.

Давайте перепишем FizzBuzz используя функции!

// В отличие от С/С++, нет никаких ограничений касаемо порядка определений функций

fn main() {

// Можно использовать функцию здесь, а определить где-нибудь потом

fizzbuzz_to(100);

}

// Функция, возвращающая логическое значение

fn is_divisible_by(lhs: u32, rhs: u32) -> bool {

// Граничный случай, ранний возврат

if rhs == 0 {

return false;

}

// Это - выражение, ключевое слово `return` здесь не требуется

lhs % rhs == 0

}

// Функция, которая «не возвращает» значение, на самом деле возвращает единичный тип `()`

fn fizzbuzz(n: u32) -> () {

if is_divisible_by(n, 15) {

println!("fizzbuzz");

} else if is_divisible_by(n, 3) {

println!("fizz");

} else if is_divisible_by(n, 5) {

println!("buzz");

} else {

println!("{}", n);

}

}

// Когда функция возвращает `()`, возвращаемый тип можно не указывать

fn fizzbuzz_to(n: u32) {

for n in 1..n + 1 {

fizzbuzz(n);

}

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Методы

Методы - это функции, прикреплённые к объектам. Эти методы имеют допуск к данным объекта и другим его методам через ключевое слово self. Методы определяются под блоком impl.

struct Point {

x: f64,

y: f64,

}

// Блок реализаций, все методы `Point` расположены здесь

impl Point {

// Это статический метод

// Статические методы не нуждаются в вызове от экземпляра

// Эти методы, как правило, используются как конструкторы

fn origin() -> Point {

Point { x: 0.0, y: 0.0 }

}

// Другой статический метод, берёт два аргумента

fn new(x: f64, y: f64) -> Point {

Point { x: x, y: y }

}

}

struct Rectangle {

p1: Point,

p2: Point,

}

impl Rectangle {

// Это метод экземпляра

// `&self` - это сахар для `self: &Self`, где `Self` - это тип

// вызываемого объекта. В этом месте `Self` = `Rectangle`

fn area(&self) -> f64 {

// `self` даёт допуск к полям структуры через оператор точка

let Point { x: x1, y: y1 } = self.p1;

let Point { x: x2, y: y2 } = self.p2;

// `abs` - это метод `f64`, который возвращает абсолютную величину

// вызываемого

((x1 - x2) * (y1 - y2)).abs()

}

fn perimeter(&self) -> f64 {

let Point { x: x1, y: y1 } = self.p1;

let Point { x: x2, y: y2 } = self.p2;