Trinity's thoughts

Модули и pub в Rust - Когда программа в Rust становится больше пары файлов, без структуры легко потеряться. Модули помогают разбить код на части, а ключевое слово pub управляет доступом к этим частям. Что такое модуль Модуль — это просто область, в которой мы группируем функции, структуры и другие элементы. Создаём модуль так:

mod greetings {
    fn hello() {
        println!("Hello!");
    }
}

Внутри модуля лежит функция hello. Но прямо вызвать её нельзя, т.к Rust по умолчанию делает всё внутри модуля приватным. Таков раст, всё хочет обезопасить. Но иногда полезно открыть доступ, и тут к нам на помощь приходит pub Ключевое слово pub - Чтобы функция или структура стали видимыми снаружи, используем pub:

mod greetings {
    pub fn hello() {
        println!("Hello!");
    }
}
  
fn main() {
    greetings::hello(); // работает
}

Файловая структура и mod В реальном проекте модули чаще лежат в отдельных файлах. Например src ├─ main.rs └─ greetings.rs А чтобы подключить модули из другого файла в main.rs используется mod имя файла. В нашем случае, mod greetings И помним про pub!) Честно скажу, сначала я думал, что лучше сразу всё делать pub, чтоб не мешало. Но на самом деле приватность иногда помогает избежать путаницы, так что думайте До завтра ✈️ Telegram | Админ

Почему этой папки у меня не было раньше? Сразу же делюсь с вами! Вместе с парнями показываем вам как выносить биржи и топ проекты

- Как сделать свой кошелёк Eligible? - Как торговать, чтобы не выбивало по стопам? - Куда закинуть стейблы на медвежке для постоянной подпитки?

На все эти вопросы у нас есть ответ! Подписаться

Замыкания в Rust Замыкание — это безымянная функция, которую можно создать прямо в месте использования. Главный её плюс в том, что она может захватывать переменные из её области видимости Синтаксис В Rust замыкания записываются по шаблону |аргументы| { тело } Пример

fn main() {
    let add_one = |x: i32| -> i32 { x + 1 };
    let result = add_one(5);
    println!("Результат: {}", result);
}

-> Объединяем с основной концепцией раста - владением

fn main() {
    let num = 10;
    let add_num = |x: i32| x + num;
    println!("Результат: {}", add_num(5));
}

Что здесь происходит? - Замыкание add_num "помнит" значение переменной num из внешней области. Отсюда и название — они замыкают переменные из своей области видимости) -> Типы замыканий Rust сам определяет тип замыкания, но мы же с вами разработчики, нам все равно это нужно знать. И так, вот же они: 1 - Fn — просто захватывает переменные по ссылке, но не изменяет их 2 - FnMut — захватывает переменные по изменяемой ссылке и изменяет их 3 - FnOnce — захватывает переменные, забирая их. Просто берет и в наглую ворует) -> Пример с FnMut

fn main() {
    let mut count = 0;
    let mut increment = || {
        count += 1;
        count
    };
    
    println!("{}", increment()); // 1
    println!("{}", increment()); // 2
}

До завтра ✈️ Telegram | Админ

📊👀 #SOL SolanaFloor: Максимальная скорость обработки транзакций одного блока в сети Solana достигла 107 664 TPS, что стало новым рекордом пропускной способности сети.

Библиотека chrono в Rust По-тихоньку мы с вами подбираемся к тому, ради чего учим раст - освоению фрейма anchor. Но остаётся ещё несколько уроков, которые было бы неплохо пройти. Библиотека chrono - как раз такой случай Чтобы работать с ней, нужно добавить в cargo.toml ->

chrono = "0.4"

Это подключит библиотеку. Текущее время

use chrono::Local;

fn main() {
    let now = Local::now(); //Локальное время
    let utc_now = chrono::Utc::now(); // Время в UTC

Форматирование даты

fn main() {
    println!("{}", now.format("%Y-%m-%d %H:%M:%S"));

Пояснение: %Y — год, %m — месяц, %d — день, %H — час, %M — минуты, %S — секунды. Сложение и вычитание времени

use chrono::Duration;

fn main() {
    let plus = now + Duration::days(3); // Через 3 дня
    let minus = now - Duration::hours(5); // 5 часов назад

До завтра ✈️ Telegram | Админ

Всем Gm, помните биржу Blofin? Опять проводят акцию - торгуем в обычном режиме, набиваем объём на фьючерсах - крутим колесо и выигрываем призы! Подробности -> Аккаунт на BloFin -> Депозит минимум на 100$ и торговля во время промо - За первый депозит дают 1 спин, и потом за каждые 10K$ фьючерсного объема. Ссылка на промо https://blofin.com/rewards?activity_id=2076

Что такое HashMap? HashMap — это структура данных, которая хранит пары ключ → значение. Можно быстро находить значение по ключу, как в словаре. Например: ключ: имя человека значение: его возраст 📦В Rust HashMap находится в стандартной библиотеке:

use std::collections::HashMap

2 - Создание HashMap Пример: создаём пустой хешмап и добавляем в него данные.

fn main() {
    let mut ages = HashMap::new();

    // Добавляем пары (ключ, значение)
    ages.insert("Alice", 25);
    ages.insert("Bob", 30);

    println!("{:?}", ages);
}

insert(key, value) — вставляет новую пару 3 - Доступ к значениям Чтобы получить значение, используем .get(&ключ):

fn main() {
    let mut capitals = HashMap::new();
    capitals.insert("France", "Paris");
    capitals.insert("Italy", "Rome");

    if let Some(capital) = capitals.get("France") {
        println!("Столица Франции: {}", capital);
    } else {
        println!("Не нашли столицу");
    }
}

ВАЖНО!!! get() возвращает Option, потому что ключ может отсутствовать 4 - Перезапись значений Если вставить пару с тем же ключом, старое значение заменится:

fn main() {
    let mut scores = HashMap::new();
    scores.insert("Alice", 10);
    scores.insert("Alice", 20); // Перезапишет значение

    println!("{:?}", scores); // Alice → 20
}

5 - Удаление элементов

fn main() {
    let mut fruits = HashMap::new();
    fruits.insert("apple", 5);
    fruits.insert("banana", 3);

    fruits.remove("banana");

    println!("{:?}", fruits);
}

А завтра в меню: - Библиотека chrono ✈️ Telegram | Админ

Привет) Много чего говорят об арче, но точно одно: arch юзеры действительно умеют общаться с компьютером, и могут по праву считаться его владельцами. Если тебе необходимо следить за своим трафиком, пользоваться антиками, да и просто, например, автоматизировать отработку тестнетов, на арче все это делать гораздо, гораздо проще 👇 1 - Первым делом заходим на сайт archlinux.org • Заходим во вкладку Download. Гортаем в самый низ, ищем Russia и качаем с любого зеркала. После того как скачали образ, записываем его на флешку с помощью rufus.com 2 - Вставляем флешку уже с записанным арчем. • Выключаем комп, ждем секунд 10 и включаем. Входим в BIOS/boot menu(для каждого компьютера свои горячие клавиши, поэтому загуглите). В меню биоса выбираем нашу флэшку, дальше ещё одно меню - нас интересует первый пункт, что-то вроде Arch Install medium (x86_64, UEFI). Нажимаем Enter, кайфуем от загрзуки 3 - Для начала я рекомендую установить шрифт покрупнее:

setfont /usr/share/kbd/consolefonts/sun12x22.psfu.gz

5 - Подключаемся к интернету(если не проводной):

iwctl

Далее проверяем видит ли компьютер Wi-Fi адаптер:

device list

Должно быть что-то типа "Device wlan0..." Далее прописываем следующие команды:

station wlan0 scan

station wlan0 get-networks

И наконец:

bash
station wlan0 connect "Имя_сети"

Выходим из iwctl сочетанием клавиш ctrl + c (Вообще в любой непонятной ситуации юзайте) 6 - Настраиваем пакетный менеджер

nano /etc/pacman.conf

В этом файлике ищем строчку Parallel Downloads = 5 и заменяем на 15. Для быстрого поиска можете использовать сочетание клавиш ctrl+w 7 - Размечаем диски Для начала

lsblk

Чтобы проверить какие вообще диски есть в системе. loop0 и sr0 нас не интересуют У меня на пк помимо них был диск sda, у вас это может быть, например, vda, особой роли это не играет. • Теперь нам нужно удалить все разделы которые там есть, и создать свою таблицу разделов. Для этого воспользуемся утилитой cfdisk

cfdisk /dev/название вашего диска

Дальше нас спрашивают тип разметки, нажимаем enter Я рассмотрю наиболее простой вариант, где мы разделим диск на загрузочный и основной Подробнее: • Загрузочный раздел: 512МB, тип EFI system • Основной отдел: Всё оставшееся свободное место, тип Linux filesystem Разметили диск, вышли из утилиты 8 - Далее нам нужно их отформатировать Начнем с загрузочного диска:

mkfs.vfat /dev/диск1

Основной:

mkfs.ext4 /dev/диск2

9 - Теперь нам нужно их примонтировать Начнём с основного раздела:

mount /dev/диск2 /mnt

Для загрузочного нам сначала понадобится создать директорию по пути /mnt/boot/efi:

mkdir -p /mnt/boot/efi

И теперь можем примонтировать загрузочный раздел:

mount /dev/диск1 /mnt/boot/efi

10 - С дисками мы закончили, теперь приступим к установке пакетов

pacstrap /mnt linux linux-firmware base base-devel linux-headers nano nvidia #если у вас видюха nvidia
bash-completion grub efibootmgr networkmanager xorg sddm ttf-ubuntu-font-family ttf-hack ttf-dejavu ttf-opensans #и добавьте вместо этого комментария желаемое окружение рабочего стола, примеры: gnome, xfce4, kdе

Это все одна команда! Без переноса строки, просто запишите все пакеты через пробел! 11 - Далее нам желательно сгенерировать fstab

genfstab /mnt >> /mnt/etc/fstab

12 - Меняем корень системы на свежеустановленную

arch-chroot /mnt

Если у приглашение в терминале изменилось - поздравляю, всё идёт как надо) 13 - Давайте включим необходимые сервисы

systemctl enable NetworkManager


systemctl enable sddm

14 - Осталось создать пользователя - Под рутом работать неудобно и небезопасно, поэтому создадим пользователя

useradd -m scriptland_sh

Добавим пароль нашему пользователю:

passwd scriptland_sh

Давайте не будем обделять нашего с вами root, зададим пароль и ему:

passwd root

Буквально заключительные шажочки остались 🔥 Но это уже во второй части Продолжение следует...

👣 Углубление во владение Владение - основная концепция языка Rust, обеспечивающая ему безопасность и скорость 📦 Владение и функции В Rust значение передаётся в функцию с перемещением:

fn take(s: String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("Hello");
    take(s);
    println!("{}", s); // ошибка: s перемещена
}

Если вы не хотите передавать значение вашей переменной какой-то там функции, можете использовать ссылку - &

fn print(a: &String) {
    println!("{}", a);
}

fn main() {
    let s = String::from("Hello");
    print(&s);
    println!("{}", s); // все хорошо 
}

Copy и Clone Примитивные типы (i32, bool, char) копируются автоматически:

    let x = 5;
    let y = x; // x всё ещё доступен
    println!("{}", x)
}

Типы как String, Vec — не копируются, а перемещаются. Чтобы скопировать их, нужно вызвать метод .clone()

fn main() {
    let s1 = String::from("Hi");
    let s2 = s1.clone(); // глубокая копия
}

Важно! Одновременно можно либо: • Иметь любое число неизменяемых ссылок (&T) • Либо иметь одну изменяемая (&mut T) 🔃 Структуры и владение И напоследок про структуры и как дела обстоят с ними. Да очень просто: вся структура перемещается целиком:

struct User {
    name: String,
    age: u8,
}

fn main() {
    let u1 = User {
        name: String::from("Alice"),
        age: 30,
    };
    let u2 = u1;
    println!("{}", u1.name) // ошибка
}

А завтра в меню: Hashmaps ✈️ Telegram | Админ

👣 Функции в Rust Что такое функция? Функция — это именованный блок кода, который выполняет определённую задачу 📌 Объявление функции

fn main () {}
fn sum(a: u8, b: u8) -> u8 {
        return a+b;
}

fn say_hello() {
    println!("Hello, World!");
}

А как вызвать?

fn main () {
    let result = sum(7, 15);
    println!("{}", result);
}
fn sum(a: u8, b: u8) -> u8 {
    return a+b;
}

Особенности - Все параметры и возвращаемые значения обязательно типизированы - А ещё функции можно вкладывать друг в друга (внутри других функций) А завтра в меню: Углубление во владение ✈️ Telegram | Админ

👣 Структуры в Rust Структуры - способ сгруппировать данные, относящиеся к одному и тому же • Создаём структуру Для примера, определим структуру Person

struct Person {
    name: String,
    age: u8,
}

fn main () {}

И теперь мы можем создать нашего человечка:

struct Person {
    name: String,
    age: u8,
}

fn main () {
    let Person1 = Person {
        name: Michael,
        age: 17,
    }
}

Одна из важнейших тем в разработке на Solana - там структуры используются в работе с аккаунтами А завтра в меню: Функции ✈️ Telegram | Админ

👣 Циклы в Rust В Rust есть три вида циклов: loop — бесконечный цикл while — цикл с условием for — перебор диапазона или коллекции ☉ loop Цикл loop повторяет код бесконечно, пока ты не скажешь ему остановиться командой break.

fn main() {
    let mut n = 0;

    loop {
        println!("n = {}", n);
        n += 1;

        if n == 3 {
            break;
        }
    }
}

☉ while Цикл while сначала проверяет условие, и если оно true, запускает код. Подходит, когда условие может изменяться внутри цикла.

fn main() {
    let mut n = 0;

    while n < 3 {
        println!("n = {}", n);
        n += 1;
    }
}

☉ for Цикл for используется для прохода по диапазону или коллекции. Он удобный, безопасный и читаемый.

Rust
fn main() {
    let fruits = ["яблоко", "банан", "груша"];

    for fruit in fruits {
        println!("{}", fruit);
    }
}

☉ break и continue break — выходит из цикла полностью. continue — пропускает текущую итерацию и переходит к следующей.

for i in 0..5 {
    if i == 3 {
        continue;
    }
    if i == 4 {
        break;
    }
    println!("i = {}", i);
}

А завтра в меню: Структуры ✈️ Telegram | Админ

👣 Что такое условные операторы и для чего они? Условные операторы позволяют выполнять разные действия в зависимости от условий. Знакомьтесь! ❤️if, else, else if

fn main() {
    let number = 5;

    if number > 0 {
        println!("Число положительное");
    } else if number < 0 {
        println!("Число отрицательное");
    } else {
        println!("Это ноль");
    }
}

А ещё, if может возвращать значение в зависимости от значения переменной, что делает его очень универсальным инструментом в разработке

fn main() {
    let age = 20;

    let is_adult = if age >= 18 {
        true
    } else {
        false
    };

    println!("Совершеннолетний? {}", is_adult);
}

📌 Важно: обе ветки (if и else) должны возвращать одно и то же по типу(true/false, 1/0...) ❤️match Быстро и просто: Выполняет какой-либо код в зависимости от значения переменной

fn main() {
    let number = 3;

    match number {
        1 => println!("Один"),
        2 => println!("Два"),
        3 => println!("Три"),
        _ => println!("Другое число"), // "_" — обрабатываем все остальные случаи
    }
}

match должен покрывать все возможные случаи!!! Иначе компилятор покажет ошибку. '_' — как раз и помогает нам сказать компилятору, что "во всех остальных случаях делаем то-то". И никаких ошибок) А ещё можно возвращать значения, прям как if

fn main() {
    let number = 2;

    let word = match number {
        1 => "один",
        2 => "два",
        3 => "три",
        _ => "другое",
    };

    println!("{}", word)
}

А завтра в меню Циклы ✈️ Telegram | Админ

👣 Методы для работы с векторами ☉ push() Добавляет элемент в конец вектора

fn main() {
    let mut list = vec![1, 2];
    list.push(3);       // [1, 2, 3]
    list.push(4);       // [1, 2, 3, 4]
    println!("{:?}", list);
}

☉ pop() Удаляет последний элемент и возвращает его

fn main() {
    let mut letters = vec!['a', 'b', 'c'];
    let last = letters.pop();        // Записываем удаленный элемент в переменную. Если записывать не хотим, можем просто вызвать:
    letters.pop()
    println!("{:?}", letters);       // ['a', 'b']
}

☉ remove(index) Удаляет элемент по индексу и возвращает его.

fn main() {
    let mut numbers = vec![10, 20, 30, 40];
    let deleted = numbers.remove(1); // Удаляет 20
    println!("{:?}", numbers);       // [10, 30, 40]
    println!("{}", deleted);         // 20

То есть то же самое, что и pop(), только мы можем выбрать индекс элемента, который будем удалять ☉ get(index) Безопасно получает элемент по индексу. Возвращает Some(...) или None. Мы ещё научимся "доставать из скобок" значения, но пока просто знайте, что безопаснее пользоваться именно get()

fn main() {
    let fruits = vec!["apple", "banana", "cherry"];
    let first = fruits.get(0);     //Some("apple")
    let missing = fruits.get(10);  // None
}  

get() не прерывает выполнение программы аварийно, даже если индекс вышел за пределы вектора. А завтра в меню: Условные операторы в Rust ✈️ Telegram | Админ

Что такое Вектора в Rust? Vec (вектор) — это список значений, который можно менять во время работы программы. Что значит "менять"? - Добавлять - Менять - Читать - Очищать Но обо всех этих методах работы с векторами мы поговорим на следующем уроке, а пока подробно о том, как их создавать, писать максимально функциональный и быстрый код Создаём вектор

fn main() {
    let mut numbers = Vec::new();

    numbers.push(10);
    numbers.push(20);
    numbers.push(30);

    println!("{:?}", numbers); // вывод - [10, 20, 30]
}

А можно создать вектор сразу со значениями внутри. И, кстати, этот код будет не‌сколько производительнее! Это происходит из-за того, что во время создания вектора Rust выделяет для него место в памяти на диске. Сначала - покажу второй способ создания вектора, а затем вернусь к этой теме

fn main() {
    let values = vec![1, 2, 3, 4];
    println!("{:?}", values); // [1, 2, 3, 4]
}

То, сколько памяти выделит Раст во время создания вектора отражается на том, сколько значений мы сможем в него записать. По умолчанию, при создании нового пустого вектора в памяти под этот вектор выделяется 4 байта памяти, этого хватит, чтобы, например, записать 4 числа, или 4 знака. Но когда нам потребуется добавить в вектор больше значений, произойдет перераспределение памяти, и количество памяти, которая была выделена под вектор удвоится. Но это перераспределение замедлит нашу программу, что в условии блокчейна недопустимо, так как это не просто замедляет код, так ещё и требует вычислительных мощностей, а, значит, повышает комиссию за операцию. Так что, если мы знаем, сколько в нашем векторе будет значений, мы создаём вектор используя метод

Vec::with_capacity(n)

задавая вместимость вектора вручную Завтра в меню: Операции для работы с векторами ✈️ Telegram | Админ

📌Кортежи и массивы в Rust Кортеж — это структура, которая может хранить несколько значений разных типов. Пример:

fn main() {
    let kortezh: (i32, f64, char) = (25, 1.75, 'A');
    println!("Возраст: {}", person.0);
    println!("Рост: {}", person.1);
    println!("Оценка: {}", person.2);
}

Создаём cortezh — в нём хранится 3 значения: i32 — целое число f64 — дробь char — просто символ. Кстати, заметьте, что символы всегда создаются в одинарных кавычках Доступ к значениям по индексам— через .0, .1, .2 и т.д. ____ А вот массив — это набор значений одного типа и фиксированной длины. Пример:

fn main() {
    let array: [i32; 4] = [10, 20, 30, 40];
    println!("Первый элемент: {}", numbers[0]);
    println!("Второй элемент: {}", numbers[1]);
}

Создаём array - массив из 4 элементов типа i32. Доступ к элементам — так же по индексам - numbers[0], numbers[1] и т.д. А вот для ленивых: короткий способ создания массива из одинаковых элементов

let zeros = [0; 5]; // массив из 5 нулей: [0, 0, 0, 0, 0]

То, что важно помнить: • Массив в Rust имеет фиксированную длину, изменить её нельзя. • Индексация всегда начинается с 0! 💬 Пример для закрепления

fn main() {
    let student: (String, u8, f32)= ("Alice", 18, 4.5);
    let grades: [u8, 5]= [5, 4, 4, 5, 3];

    println!("Имя: {}", student.0);
    println!("Оценки: {:?}", grades);
}

А завтра в меню: Векторы ✈️ Telegram | Админ

📌Что такое макрос? Помните первый урок, когда мы писали программу Hello, World? Оказывается, в ней мы использовали так называемый макрос. Что это? Разберем на примере:

fn main() {
    println!("Hello, World!")
}

Что делает компилятор, когда видет такой код? Можно сказать, что он заменяет этот println! на несколько строк другого кода, который, как раз выводит Hello, World! в консоль. Если бы такого макроса не было, нам бы приходилось в ручную писать примерно это:

use std::io::{self, Write};

fn main() {
    let _ = io::stdout().write_fmt(format_args!("{}\n", format_args!("Hello, {}!", "world")));
}

🚩 Кстати, макросы всегда заканчиваются на ! Приведу ещё пару примеров • print! - Делает то же, что и println!, но не переносит каждый вывод на новую сроку • panic! - Аварийно завершает программу с ошибкой • assert! - Проверяет, ложно или истинно выражение Вот такой сегодня получился короткий урок) Тема несложная, но понимать её не помешает А завтра в меню Кортежи Массивы ✈️ Telegram | Админ

Концепция владения Ownership & Borrowing Концепция владения в Rust — это способ, которым язык управляет памятью автоматически и безопасно. В чем суть? Каждая переменная в Rust владеет каким-то участком памяти. ➡️ Перемещение (move) В Rust нельзя просто скопировать переменную в другую, вместо этого происходит перемещение.

fn main() {
    let s1: String = String::from("hello");
    let s2 = s1;
}

Здесь s1 передаёт право владения s2. То есть s1 теперь ничем не владеет, а значит память лишним не забита. И логично предположить, что s1 теперь нельзя использовать:

fn main() {
    let s1: String = String:: from("hello");
    let s2: String = s1;
    println!("{}", s1);  // Error

📄 Клонирование (clone) Если всё же не хочешь терять исходную переменную — используй .clone()

fn main() {
    let s1: String = String::from("hello");
    let s2: String = s1.clone()

Теперь s1 и s2 — разные владельцы с разными копиями строки 🧠 Ссылки: доступ без владения Чтобы не забирать владение, можно использовать ссылки:

fn main() {
    let s1: String = String::from("hello");
    let s2 = &s1
    println!("{}", s1); //✓
    println!("{}", s2); //✓

То есть, s1 - владелец, ничего не поменялось. А s2 просто получил доступ к значению переменной s1 Это очень важная тема, и я ещё к ней вернусь когда мы будем изучать функции. Попрактикуйтесь - лучше запомнится А завтра в меню: Макросы ✈️ Telegram | Админ

Создаём первую переменную. Изучаем типы данных

fn main() {
    let num: u8 = 11;
}

Что здесь происходит? Мы говорим процессору создать переменную num и записать в неё число 11. С этим вроде понятно А вот что такое u8? А это тип данных, который говорит, что перед нами переменная, в которой лежит число от нуля до 255(2⁸) – А какие ещё бывают типы? ➤ u8 - целые числа от 0 до 255 ➤ u32 - целые числа от 0 до 2³² ➤ u64 - целые числа от 0 до 2⁶⁴ ☞ i8 - целые числа от -128 до 127 ☞ i32 - целые числа от -(2³²/2) до (2³²/2) ☞ i64 - целые числа от -(2⁶⁴/2) до (2⁶⁴/2) ➤ f8 - дроби от -240 до 240 ➤ f32 - дроби от -(1.4*10³⁸) до (3.4*10³⁸) ➤ f64 - дроби от (-5 * 10⁻³²⁴) до (1.7 × 10³⁰⁸) ☞ String - Изменяемый текстовый тип. ☞ &str - Неизменяемый текстовый тип ☞ char - Хранит в себе лишь 1 символ ☞ bool - Логический тип. Значения: true/false И небольшой пример:

fn main() {
    let logic: bool = "true";
    let my_str: &str = "Rust is awesome";
    println!("{}", my_str);
    println!("It is {}", logic)
}

И в выводе мы получим:

Rust is awesome 
It is true

А завтра в меню: Концепция владения ✈️ Telegram | Админ

Знакомство с Rust Что такое Rust? Rust - это современный инструмент для создания безопасных, быстрых и производительных приложений. Создан в 2009 году, и долгое время был под крылом Firefox. С 2015 перешёл под контроль Rust... Что-ж, начнем! 1 - Установка языка Rust. Установка пакетного менеджера Cargo. Основные команды Cargo 💬Инструмент для управления проектом — Cargo Cargo — это менеджер пакетов и сборщик проектов языка Rust. С ним создавать, собирать и запускать программы очень просто. Создаем первый проект 1. Устанавливаем Rust и Cargo : Для GNU/Linux:

sudo pacman -Syu rust

Или

sudo apt update && sudo apt upgrade 
sudo apt install rustc cargo

Для Windows: Скачиваем с сайта https://www.rust-lang.org/ru/tools/install 2 - Команды cargo. Только самые нужные • cargo init создаёт в папке необходимую структуру проекта • cargo build компилирует, загружает зависимости. • cargo build --release всё тоже, но оптимизирует проект под релиз • cargo doc --open создаёт и открывает документацию о вашем проекте. Нужно для больших проектов, что бы ваш код могли понимать не только вы • cargo run запускает ваш проект Hello, World! В файле src/main.rs пишем

fn main() {
    println!("Hello, World !")
}

fn main() {} - главная функция, она же - точка входа в программу. Без неё не запустится ни одна программа на Rust. println!("Текст...") - для вывода в консоль в расте используется макрос println! О макросах я подробно расскажу завтра. А теперь осталось запустить программу

cargo run

Поздравляю! Мы написали первую программу на Rust! A завтра в меню: - Создадим первую переменную - Узнаем что такое макросы, и рассмотрим несколько примеров ✈️ Telegram | Админ