}
// ^ Требует 3 уровня вложенности!
},
// Выходим из цикла в случаи ошибки деструктуризации:
_ => { break; }
// ^ Зачем это нужно? Должен быть способ сделать это лучше!
}
}
}
Использование while let делает этот пример немного приятнее:
fn main() {
// Создадим переменную `optional` с типом `Option`
let mut optional = Some(0);
// Это можно прочитать так: "Пока `let` деструктурирует `optional` в
// `Some(i)`, выполняем блок (`{}`). В противном случае `break`.
while let Some(i) = optional {
if i > 9 {
println!("Больше 9, уходим отсюда!");
optional = None;
} else {
println!("`i` равен `{:?}`. Попробуем ещё раз.", i);
optional = Some(i + 1);
}
// ^ Меньше смещаемся вправо, к тому же
// нет необходимости обрабатывать ошибки.
}
// ^ К `if let` можно добавить дополнительный блок `else`/`else if`
// `while let` подобного нет.
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Смотрите также:
enum, Option, and the RFC
Функции
Функции объявляются с помощью ключевого слова fn. Их аргументы имеют явно заданный тип, как у переменных, и, если функция возвращает значение, возвращаемый тип должен быть указан после стрелки ->.
Последнее выражение в функции будет использовано как возвращаемое значение. Так же можно использовать оператор 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;
2.0 * ((x1 - x2).abs() + (y1 - y2).abs())
}
// Этот метод требует чтобы вызываемый объект был изменяемым
// `&mut self` - сахар для `self: &mut Self`
fn translate(&mut self, x: f64, y: f64) {
self.p1.x += x;
self.p2.x += x;
self.p1.y += y;
self.p2.y += y;
}
}
// `Pair` владеет ресурсами: два целых числа в куче
struct Pair(Box, Box);
impl Pair {
// Этот метод "съедает" ресурсы вызываемого объекта
// `self` - сахар для `self: Self`
fn destroy(self) {
// деструктуризация `self`
let Pair(first, second) = self;
println!("Destroying Pair({}, {})", first, second);