可见性 - Rust By Example
Description: Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries.

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# 可见性

默认情况下，模块中的项具有私有可见性，但可以使用 `pub` 修饰符来覆盖这一默认行为。只有模块中的公有项可以从模块作用域外部访问。

    // 一个名为 `my_mod` 的模块
    mod my_mod {
        // 模块中的项默认为私有可见性。
        fn private_function() {
            println!("调用了 `my_mod::private_function()`");
        }

        // 使用 `pub` 修饰符来覆盖默认的可见性。
        pub fn function() {
            println!("调用了 `my_mod::function()`");
        }

        // 同一模块中的项可以访问其他项，
        // 即使是私有的。
        pub fn indirect_access() {
            print!("调用了 `my_mod::indirect_access()`，它\n> ");
            private_function();
        }

        // 模块也可以嵌套
        pub mod nested {
            pub fn function() {
                println!("调用了 `my_mod::nested::function()`");
            }

            #[allow(dead_code)]
            fn private_function() {
                println!("调用了 `my_mod::nested::private_function()`");
            }

            // 使用 `pub(in path)` 语法声明的函数只在给定的路径中可见。
            // `path` 必须是父模块或祖先模块
            pub(in crate::my_mod) fn public_function_in_my_mod() {
                print!("调用了 `my_mod::nested::public_function_in_my_mod()`，它\n> ");
                public_function_in_nested();
            }

            // 使用 `pub(self)` 语法声明的函数只在当前模块中可见，
            // 这与将它们保持为私有是一样的
            pub(self) fn public_function_in_nested() {
                println!("调用了 `my_mod::nested::public_function_in_nested()`");
            }

            // 使用 `pub(super)` 语法声明的函数仅在父模块中可见

            pub(super) fn public_function_in_super_mod() {
                println!("调用了 `my_mod::nested::public_function_in_super_mod()`");
            }
        }

        pub fn call_public_function_in_my_mod() {
            print!("调用了 `my_mod::call_public_function_in_my_mod()`，它\n> ");
            nested::public_function_in_my_mod();
            print!("> ");
            nested::public_function_in_super_mod();
        }

        // pub(crate) 使函数仅在当前 crate 内可见
        pub(crate) fn public_function_in_crate() {
            println!("调用了 `my_mod::public_function_in_crate()`");
        }

        // 嵌套模块遵循相同的可见性规则
        mod private_nested {
            #[allow(dead_code)]
            pub fn function() {
                println!("调用了 `my_mod::private_nested::function()`");
            }

            // 私有父项仍会限制子项的可见性，
            // 即使子项被声明为在更大范围内可见。
            #[allow(dead_code)]
            pub(crate) fn restricted_function() {
                println!("调用了 `my_mod::private_nested::restricted_function()`");
            }
        }
    }

    fn function() {
        println!("调用了 `function()`");
    }

    fn main() {
        // 模块允许消除同名项之间的歧义。
        function();
        my_mod::function();

        // 公有项（包括嵌套模块内的）可以从父模块外部访问。
        my_mod::indirect_access();
        my_mod::nested::function();
        my_mod::call_public_function_in_my_mod();

        // pub(crate) 项可以在同一个 crate 的任何地方调用
        my_mod::public_function_in_crate();

        // pub(in path) 项只能在指定的模块内调用
        // 错误！函数 `public_function_in_my_mod` 是私有的
        //my_mod::nested::public_function_in_my_mod();
        // TODO ^ 尝试取消此行注释

        // 模块的私有项不能被直接访问，即使它们嵌套在公有模块中：

        // 错误！`private_function` 是私有的
        //my_mod::private_function();
        // TODO ^ 尝试取消此行注释

        // 错误！`private_function` 是私有的
        //my_mod::nested::private_function();
        // TODO ^ 尝试取消此行注释

        // 错误！`private_nested` 是一个私有模块
        //my_mod::private_nested::function();
        // TODO ^ 尝试取消此行注释

        // 错误！`private_nested` 是一个私有模块
        //my_mod::private_nested::restricted_function();
        // TODO ^ 尝试取消此行注释
    }