Файлы и ввод-вывод в Rust
В этой главе представлены операции ввода-вывода языка Rust.
Получение аргументов командной строки
Программы командной строки — самая базовая форма компьютерных программ. Почти все операционные системы поддерживают программы командной строки и основывают выполнение визуальных программ на механизме командной строки.
Программа командной строки должна уметь получать аргументы из среды командной строки. Эти аргументы обычно указываются после команды командной строки и разделяются пробелами.
Во многих языках (таких как Java и C/C++) аргументы среды передаются программе в качестве параметров функции main (часто массива строк). Однако в Rust функция main является функцией без параметров, и аргументы среды нужно получать разработчику через модуль std::env. Процесс очень прост:
Пример
let args = std::env::args();
println!("{:?}", args);
}
Теперь запустите программу напрямую:
Args { inner: ["D:\\rust\\greeting\\target\\debug\\greeting.exe"] }Возможно, полученный результат окажется намного длиннее этого, и это нормально. В этом результате структура Args содержит внутренний массив, который хранит только одну строку, представляющую местоположение текущей запущенной программы.
Но эту структуру данных трудно понять. Ничего страшного; можно просто перебрать её:
Пример
let args = std::env::args();
for arg in args {
println!("{}", arg);
}
}
Вывод:
D:\rust\greeting\target\debug\greeting.exe
Аргументы, как правило, предназначены для перебора, не так ли?
Теперь давайте откроем давно не тронутый launch.json, найдём "args": [], где можно задать аргументы времени выполнения. Мы изменим его на "args": ["first", "second"], затем сохраним и снова запустим предыдущую программу. Вывод:
D:\rust\greeting\target\debug\greeting.exe first second
Как настоящая программа командной строки, мы на самом деле ею никогда не пользовались. Поскольку это руководство по языку, мы не будем здесь описывать, как запускать программы на Rust из командной строки. Но если вы хорошо обученный разработчик, вы должны уметь найти местоположение исполняемого файла. Попробуйте перейти в каталог и с помощью команд командной строки проверить, как программа принимает аргументы среды командной строки.
Ввод из командной строки
В предыдущих главах подробно описывалось, как использовать вывод в командную строку, что необходимо для изучения языка, так как программы невозможно отлаживать без вывода. Однако получение входной информации из командной строки всё ещё довольно важно для программы командной строки.
В Rust модуль std::io предоставляет функциональность, связанную со стандартным вводом (который можно считать вводом из командной строки):
Пример
fn main() {
let mut str_buf = String::new();
stdin().read_line(&mut str_buf)
.expect("Failed to read line.");
println!("Your input line is \n{}", str_buf);
}
Обеспечение поддержки ввода из командной строки в среде VSCode — очень хлопотное дело, связанное с кросс-платформенными проблемами и проблемами невозможности отладки, поэтому мы будем запускать программу прямо в терминале VSCode. Запустите её из командной строки:
D:\rust\greeting> cd ./target/debug D:\rust\greeting\target\debug> ./greeting.exe EXAMPLE Your input line is EXAMPLE
std::io::Stdio содержит метод read_line, который может прочитать строку в буфер. Возвращаемое значение — это перечисление Result, используемое для передачи ошибок, возникающих при чтении, поэтому для обработки ошибок обычно используются функции expect или unwrap.
Примечание: В настоящее время стандартная библиотека Rust ещё не предоставляет метод для прямого чтения чисел или форматированных данных из командной строки. Мы можем прочитать строку и использовать функции разбора строк для обработки данных.
Чтение файлов
Создаём файл text.txt в каталоге D:\ компьютера со следующим содержимым:
This is a text file.
Это программа, которая считывает содержимое текстового файла в строку:
Пример
fn main() {
let text = fs::read_to_string("D:\\text.txt").unwrap();
println!("{}", text);
}
Вывод:
This is a text file.
В Rust чтение целого файла, который помещается в память, — крайне простая задача. Метод read_to_string в модуле std::fs легко выполняет чтение текстового файла.
Но если читаемый файл является бинарным, мы можем использовать функцию std::fs::read, чтобы прочитать коллекцию типа u8:
Пример
fn main() {
let content = fs::read("D:\\text.txt").unwrap();
println!("{:?}", content);
}
Вывод:
[84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 116, 101, 120, 116, 32, 102, 105, 108, 101, 46]
Два вышеуказанных метода выполняют однократное чтение, что очень подходит для разработки веб-приложений. Однако для некоторых низкоуровневых программ традиционный метод чтения на основе потоков по-прежнему незаменим, поскольку в большинстве случаев размер файла может значительно превышать объём памяти.
Потоковое чтение файла в Rust:
Пример
use std::fs;
fn main() {
let mut buffer = [0u8; 5];
let mut file = fs::File::open("D:\\text.txt").unwrap();
file.read(&mut buffer).unwrap();
println!("{:?}", buffer);
file.read(&mut buffer).unwrap();
println!("{:?}", buffer);
}
Вывод:
[84, 104, 105, 115, 32] [105, 115, 32, 97, 32]
Класс File в модуле std::fs — это класс, описывающий файлы и позволяющий открывать файлы. После открытия файла мы можем использовать метод read у File, чтобы потоково прочитать следующие байты файла в буфер (буфер — это массив u8), при этом количество прочитанных байтов равно длине буфера.
Примечание: в VSCode сейчас нет возможности автоматически добавлять ссылки на стандартную библиотеку, поэтому иногда ошибки вроде «функция или метод не существует» могут быть вызваны проблемами со ссылками на стандартную библиотеку. Мы можем проверить комментарии к документации стандартной библиотеки (они появляются при наведении на неё), чтобы вручную добавить стандартную библиотеку.
Метод open у std::fs::File открывает файл в режиме «только для чтения», и соответствующего метода close нет, потому что компилятор Rust может автоматически закрыть файл, когда он больше не используется.
Запись в файл
Запись в файл делится на однократную запись и потоковую запись. Потоковая запись требует открытия файла, и есть два способа его открыть: «create» и «append».
Однократная запись:
Пример
fn main() {
fs::write("D:\\text.txt", "FROM RUST PROGRAM")
.unwrap();
}
Это так же просто и удобно, как однократное чтение. После запуска программы содержимое файла D:\text.txt будет перезаписано на FROM RUST PROGRAM. Поэтому используйте однократную запись с осторожностью! Потому что она напрямую удалит содержимое файла (независимо от размера файла). Если файл не существует, он будет создан.
Если вы хотите записывать содержимое файла потоком, можно использовать метод create из std::fs::File:
Пример
use std::fs::File;
fn main() {
let mut file = File::create("D:\\text.txt").unwrap();
file.write(b"FROM RUST PROGRAM").unwrap();
}
Эта программа эквивалентна предыдущей.
Примечание: открытый файл должен храниться в изменяемой переменной, чтобы можно было использовать методы File!
В классе File нет статического метода append, но мы можем использовать OpenOptions, чтобы открыть файл с определённым методом:
Пример
use std::fs::OpenOptions;
fn main() -> std::io::Result<()> {
let mut file = OpenOptions::new()
.append(true).open("D:\\text.txt")?;
file.write(b" APPEND WORD")?;
ОК(())
}
После запуска содержимое файла D:\text.txt станет:
FROM RUST PROGRAM APPEND WORD
OpenOptions — это гибкий способ открытия файлов. Он позволяет задавать разрешения на открытие. Помимо разрешения на добавление, также есть разрешения на чтение и запись. Если мы хотим открыть файл с разрешениями на чтение и запись, мы можем написать:
Пример
use std::io::prelude::*;
use std::fs::OpenOptions;
fn main() -> std::io::Result<()> {
let mut file = OpenOptions::new()
.read(true).write(true).open("D:\\text.txt")?;
file.write(b"COVER")?;
ОК(())
}
После запуска содержимое файла D:\text.txt станет:
COVERRUST PROGRAM APPEND WORDДругие расширения