Оператор use позволяет добавить путь к функционалу из других модулей к текущую область видимости или, грубо говоря, импортировать функционал. Формальное применение:
use модуль::функция/структура/перечисление/трейт;
Особенно данный оператор может быть полезен, если нам приходится по многу раз функционал модуля. Например, вызовем функцию модуля:
mod my_module{ pub mod inner_module{ pub fn hello(){ println! ("Hello"); } } } fn main(){ my_module::inner_module::hello(); my_module::inner_module::hello(); my_module::inner_module::hello(); }
Функция hello()
прекрасно работает, но вот прописывать полный путь к этой функции с учетом всех модулей может быть утомительно, кроме того,
это само по себе утяжеляет код. Теперь применим оператор use
для подключения или импорта функции в текущую область видимости:
mod my_module{ pub mod inner_module{ pub fn hello(){ println! ("Hello"); } } } use my_module::inner_module::hello; fn main(){ hello(); hello(); hello(); }
Инструкция
use my_module::inner_module::hello;
добавляет в текущую область видимости функцию hello
из модуля my_module::inner_module::
, благодаря чему далее
при вызове функции можно не прописывать весь набор модулей.
Возможно, в некотором модуле определено несколько функций, структур, перечислений. И мы хотим, чтобы они все были доступны в рамках используемой области видимости:
mod my_module{ pub mod inner_module{ pub fn hello(){ println! ("Hello"); } pub fn bye(){ println! ("Good bye"); } } } use my_module::inner_module::*; fn main(){ hello(); bye(); }
Символ звездочка (*) позволяет подключить всю функциональность модуля:
use my_module::inner_module::*;
Возможно, мы захотим подключить не весь модуль, а только несколько компонентов из него:
mod my_module{ pub mod inner_module{ pub fn hello(){ println! ("Hello"); } pub fn bye(){ println! ("Good bye"); } pub fn welcome(){ println! ("Welcome"); } } } use my_module::inner_module::{hello, bye}; fn main(){ hello(); bye(); }
Здесь инструкция
use my_module::inner_module::{hello, bye};
подключает две функции - hello и bye - набор подключаемых компонентов одного и того же модуля указывается в фигурных скобках через запятую. Все остальные компоненты этого модуля (как например, в данном случае функция welcome) будут не доступны.
Но, возможно, в модуле есть еще какие-то компоненты, которые мы также хотим подключить, но обращаться к ним через имя модуля. Тогда для подключения модуля можно использовать ключевое слово self:
mod my_module{ pub mod inner_module{ pub fn hello(){ println! ("Hello"); } pub fn bye(){ println! ("Good bye"); } pub fn welcome(){ println! ("Welcome"); } } } use my_module::inner_module::{self, hello, bye}; fn main(){ hello(); bye(); inner_module::welcome(); }
Выше подключалась функция hello()
, но что если в области видимости, в которую подключается функция hello()
из другого модуля,
уже есть своя функция hello()
:
mod my_module{ pub mod inner_module{ pub fn hello(){ println! ("Hello"); } } } use my_module::inner_module::hello; fn main(){ hello(); } fn hello(){ println!("Welcome to Rust"); }
В этом случае мы получим при компиляции ошибку. И, чтобы избежать подобных ситуаций, можно подключить модуль, в котором определена функция, и обращать к функции через имя модуля:
mod my_module{ pub mod inner_module{ pub fn hello(){ println! ("Hello"); } } } use my_module::inner_module; fn main(){ hello(); // Welcome to Rust inner_module::hello(); // Hello } fn hello(){ println!("Welcome to Rust"); }
Оператор as позволяет установить для подключаемого функционала псевдоним:
mod my_module{ pub struct Person { pub name: String, pub age: u8 } impl Person{ pub fn display(&self){ println!("Name: {} Age: {}", &self.name, &self.age); } } } use my_module::Person as User; fn main(){ let tom = User{ name: String::from("Tom"), age: 36 }; tom.display(); }
Здесь инструкция
use my_module::Person as User;
указывает, что для обращения к структуре Person теперь применяется имя "User":
let tom = User{ name: String::from("Tom"), age: 36 };
С помощью псевдонимов мы могли бы решить проблему в предыдущем примере с одноименными функциями:
mod my_module{ pub mod inner_module{ pub fn hello(){ println! ("Hello"); } } } use my_module::inner_module::hello as simple_hello; fn main(){ hello(); simple_hello(); } fn hello(){ println!("Welcome to Rust"); }
Здесь для функции hello()
из модуля my_module::inner_module
устанавливается псевдоним "simple_hello",
через который мы можем к ней обращаться.