Изучайте ржавчину на простых примерах.

Требование

  • Rust — основной репозиторий исходного кода для Rust. Он содержит компилятор, стандартную библиотеку и документацию.
  • Cargo по умолчанию распространяется вместе с Rust, поэтому, если у вас локально установлен rustc, возможно, у вас также локально установлен Cargo.

Установка

git clone https://github.com/rjoydip/learn-rust.git
cd learn-rust
npm start

привет ржавчина

println!("Hello, rust!");

Комментарии

// single line comment
/*
    Multiline comments
*/

Переменные

// print a variable
let x = 5;
println!("{}", x);
// variable mutant
let mut x = 5;
x = 9;
println!("{}", x);
// print multiple variable
let (x, y): (i32, i16) = (15, 16);
println!("{}", x);
println!("{}", y);
println!("Multiple value print ({}, {})", x, y);
// print variable
let _x = 10;
println!("Binary: {:b}, Hexadecimal: {:x}, Octal: {:o}", _x, _x, _x);
// display disimal value
println!("Display output 1: {:.2}", 1.234);

Примитивные типы данных

  • bool : логический тип.
  • char : тип символа.
  • i8 : 8-битный целочисленный тип со знаком.
  • i16 : 16-битный целочисленный тип со знаком.
  • i32 : 32-битный целочисленный тип со знаком.
  • i64 : 64-битный целочисленный тип со знаком.
  • isize : целочисленный тип со знаком размером с указатель.
  • u8 : 8-битный целочисленный тип без знака.
  • u16 : 16-битный целочисленный тип без знака.
  • u32 : 32-битный целочисленный тип без знака.
  • u64 : 64-битный целочисленный тип без знака.
  • usize : беззнаковый целочисленный тип размером с указатель.
  • f32 : 32-битный тип с плавающей запятой.
  • f64 : 64-битный тип с плавающей запятой.
  • массив : массив фиксированного размера, обозначаемый [T; N], для типа элемента, T, и неотрицательного постоянного размера времени компиляции, N.
  • срез : представление динамического размера в виде непрерывной последовательности, [T].
  • str : срезы строк.
  • tuple : конечная гетерогенная последовательность (T, U, ..).

Условный поток

Если еще

let x = 10;
if x == 1 {
    println!("Inside if");
} else if x > 5{
    println!("Inside else if");
} else {
    println!("Inside else");
}

Если еще с пусть

let condition = false;
let number = if condition {
    5
} else {
    6
};
println!("The value of number is: {}", number);

Кастинг

let f = 24.4321_f32;
let i = f as u8;
println!("{}, {}", f, i);

Множество

Массив фиксированного размера представляет собой набор элементов одного типа.

let array: [i32; 5] = [0, 1, 2, 3, 4];
println!("The first element of the array is: {}", array[0]);
// slice
let slice = &array[0..3];

Кортеж

Кортежи — это конечные гетерогенные последовательности. Давайте распакуем это быстро. Прежде всего они конечны; это довольно очевидно. Они имеют размер, фиксированное количество элементов. Они неоднородны. Они могут содержать несколько разных типов. В отличие от массива, который может содержать элементы только одного типа. И, наконец, это последовательности, то есть они имеют порядок, и, что наиболее важно, к ним можно получить доступ по индексу (хотя и иначе, чем к массивам).

let tuple = ("hello", 42, "world", [3,6,9]);
println!("First element is {}", tuple.0);
println!("Second element is {}", tuple.1);
println!("Third element is {}", tuple.2);
let mut counter = 0;
for x in &tuple.3 {
    println!("Element {} of the fourth element is {}", counter, x);
    counter += 1;
}

Петля

Бесконечный

loop {
    println!("Infinite");
}

Пока

let mut count = 5;
while count > 1 {
    count -= 1;
    println!("Count is {}", count);
}

За

let arr = [10, 20, 30, 40, 50];
for ele in arr.iter() {
    println!("Element of array is {}", ele);
}

Обеспечить регресс

for number in (1..4).rev() {
    println!("{}!", number);
}

перечислить

for (i, x) in (1..10).enumerate() {
    println!("index is: {} and value is: {}", i, x);
}

Ломать

let mut x = 0;
// break with loop
loop {
    println!("Value of i is  {}", x);
    if x >= 10 {
        break;
    }
    x+= 1;
}
// break with while
while x < 100 {
    println!("Value of i is  {}", x);
    if x >= 10 {
        break;
    }
    x+= 1;
}
// break with for
for _ele in 1..100 {
    println!("Value of i is  {}", x);
    if x >= 10 {
        break;
    }
    x+= 1;
}

Продолжать

for i in 1..20 {
    if i == 2 {
        continue;
    }
    println!("Value of i is: {}", i);
}

Нить

расколоть

let str = "This is a simple string";
let (first, second) = str.split_at(3);
println!("First: {} | second: {}", first, second);

кусочек

let str = String::from("String");
println!("{}", &str[2..4]);

конкат

let str1 = String::from("String 1");
let str2 = String::from("String 2");
let concat = str1 + " and "+ &str2;
println!("{:?}", &concat);

Совпадение

// match with number
let x = 4;
match x {
    0 => { println!("Value is 0"); }
    1 => { println!("Value is 1"); }
    2 => { println!("Value is 2"); }
    3 => { println!("Value is 3"); }
    4 => { println!("Value is 4"); }
    5 => { println!("Value is 5"); }
    _ => { println!("Any value match"); }
}
// match with string
let x = '6';
match x {
    '0' => { println!("Value is 0"); }
    '1' => { println!("Value is 1"); }
    '2' => { println!("Value is 2"); }
    '3' => { println!("Value is 3"); }
    '4' => { println!("Value is 4"); }
    '5' => { println!("Value is 5"); }
    _ => { println!("Any value match"); }
}
// match with or
let x = 3;
match x {
    0|1|2 => { println!("Value is {}", x); }
    3 => { println!("Value is three"); }
    _ => { println!("Any value match"); }
}
// match with condition
let x = 1;
let y = 3;
match (x, y) {
    (x,y) if x > y => { println!("Decreasing"); }
    (x,y) if y > x => { println!("Increasing"); }
    _              => { println!("Equal")}
}
// match with ...
let a = 8;
match a {
    4...7 => println!("In between 4...7: {}", a),
    _ => println!("Not in between 4...7"),
}
// pair/tuple match
let pair = (1, 0);
match pair {
    (0, y) => println!("y: {}", y),
    (x, 0) => println!("x: {}", x),
    _ => println!("Not match"),
}
// pattern match
let p = 11;
match p {
    n @ 1 ... 10 => println!("Between 1 to 10 : {}", n),
    n @ 11 ... 20 => println!("Between 11 to 20 : {}", n),
    _ => println!("Not match"),
}

Ссылка

let a = 10;
let b = &a;
let ref c = a;
println!("A: {}, B: {}, C: {}", a, b, c);
if b == c {
    println!("B and C are equal");
}

Структура

// Example 1
struct Object {
    width: u32,
    height: u32,
}
fn area(obj: &Object) -> u32 {
    return obj.height * obj.width;
}
let o = Object {
    width: 3,
    height: 2
};
println!("{}x{} with area: {}", o.width, o.height, area(&o));
// Example 2
#[derive(Debug, Clone, Copy)]
struct A(i32);
#[derive(Debug)]
struct B(f32);
let a = A(1);
let b = B(1.1);
let c = a.clone();
println!("{:?}, {:?}, {:?}", a, b, c);

Воплощать в жизнь

struct Object {
    width: u32,
    height: u32,
}
impl Object {
    fn area(&self) -> u32 {
        return self.height * self.width;
    }
    fn new(width: u32, height: u32) -> Object {
        Object {
            width: width,
            height: height,
        }
    }
    fn show(&self) {
        println!("{}x{} with area: {}", self.width, self.height, self.area());
    }
}
let o = Object {
    width: 3,
    height: 2
};
let obj = Object::new(o.width, o.height);
obj.show();

перечисление

enum Shape {
    Rectangle { height: u32, width: u32},
    Square(u32),
    Circle(f64)
}
impl Shape {
    fn area(&self) -> f64 {
        match *self {
            Shape::Rectangle { height, width } => (height * width) as f64,
            Shape::Square(ref s) => (s * s) as f64,
            Shape::Circle(ref r) => 3.14 * (r * r),
        }
    }
}
let r = Shape::Rectangle { height: 10, width: 10 };
let s = Shape::Square(10);
let c = Shape::Circle(4.5);
println!("Area of rectangle: {}", r.area());
println!("Area of square: {}", s.area());
println!("Area of circle: {}", c.area());

Связанная функция

// Struct
struct Object {
    width: u32,
    height: u32,
}
// Methods
impl Object {
    fn area(&self) -> u32 {
        return self.height * self.width;
    }
    fn show(&self) {
        println!("{}x{} with area: {}", self.width, self.height, self.area());
    }
}
// Related Function
impl Object {
    fn new(width: u32, height: u32) -> Object {
        Object {
            width: width,
            height: height,
        }
    }
}
let o = Object {
    width: 3,
    height: 2
};
let obj = Object::new(o.width, o.height);
obj.show();

Векторное перечисление

#[derive(Debug)]
enum Example {
    Float(f64),
    Int(i32),
    Test(String),
}
let r = vec![
    Example::Int(111),
    Example::Float(11.1),
    Example::Test(String::from("Hello world")),
];
println!("{:?}", r);

Чар матч

let s = Some('c');
// Example 1
match s {
    Some(i) => println!("Value inside match: {}", i),
    None => {},
}
// Example 2
if let Some(i) = s {
    println!("Value inside if: {}", i);
} else {
    println!("Inside else");
}

Черта характера

trait Shape {
    fn area(&self) -> u32;
}
struct Rectangle {
    height: u32,
    width: u32,
}
struct Circle {
    radius: f64,
}
impl Shape for Rectangle {
    fn area(&self) -> u32 {
        self.height * self.width
    }
}
impl Shape for Circle {
    fn area(&self) -> u32 {
        (3.14 * self.radius * self.radius) as u32
    }
}
let c = Circle { radius: 100.2 };
let r = Rectangle { height: 2, width: 3 };
println!("Circle area: {}, Rectangle area: {}", c.area(), r.area());

Собственность и заимствование

Пример 1

let x = 1; // x is owener of one and it stores in stack
let s = String::from("String");
let y = s; // moved refrence s owenership to y
// NOTE: only one reference can own one pice of data
println!("{}", s);

Пример 2

// example is called owenership moving
fn take(_v: Vec<i32>) {
    println!("We took v: {} and {}", _v[0], _v[5]);
}
let mut _v = Vec::new();
for i in 1..10 {
    _v.push(i);
}        
take(_v); // transfering _v owenership from main -> take
println!("Finihed");

Пример 3

// example is called owenership copy
fn copy(a: i32, b: i32) {
    println!("Value of a and b is (inside copy fn): {}, {}",a, b);
}
let a = 1;
let b = 2;
copy(a, b);
// unallocated from main because a,b just copied to another fn 
println!("Value of a and b is (inside main fn): {}, {}", a, b);

Пример 4

// more complecated
// taking v paramater reference of v
fn borrow1(v: &Vec<i32>) { 
    println!("Value of v in borrow1 fn is: {}", (*v)[0]);
}
fn borrow2(v: &Vec<i32>) {
    println!("Value of v in borrow2 fn is: {}", v[1]);
}
fn borrow3(v: &Vec<i32>) {
    println!("Value of v in borrow3 fn is: {}", &v[1]);
}
let v = vec![1,2,3,4,5];
borrow1(&v);
borrow2(&v);
borrow3(&v);
println!("Value of v (inside main fn): {:?}", v);

Пример 5

// complx owenership and borrowing
fn count(v: &Vec<i32>, val: i32) -> usize {
    let res = v.into_iter().filter(|&&x| x == val).count();
    res
}
let v = vec![1,2,1,2,1,3,4,5,3];
for &i in &v {
    let c = count(&v, i); // c an &v are borrowed
    println!("{} is repeated {} times", i, c);
}

Концепции

Примеры

Вся примерная область здесь. "Ссылка на сайт"