Learn Rust Coding · Aula

pub e visibilidade

Controle o acesso

pub e visibilidade é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Privado por padrão

No Rust, tudo dentro de um módulo é privado por padrão. Outros módulos não podem vê-lo, a menos que você permita isso com pub.

Esse padrão seguro mantém os detalhes de implementação ocultos até que você decida expô-los.

Funções pub

Marcar uma função como pub permite chamá-la de fora do módulo. Sem isso, a chamada falha na compilação.

mod math {
    pub fn square(x: i32) -> i32 {
        x * x
    }
}

fn main() {
    println!("{}", math::square(5));
}

Auxiliares privados permanecem ocultos

Você pode manter auxiliares internos privados e, ao mesmo tempo, expor uma API pública. A função pública pode chamar a privada, mas quem está de fora não pode.

mod math {
    fn double(x: i32) -> i32 { x * 2 }
    pub fn quadruple(x: i32) -> i32 { double(double(x)) }
}

fn main() {
    println!("{}", math::quadruple(3));
}

Estruturas pub ocultam campos

Tornar uma estrutura pub expõe o tipo, mas seus campos permanecem privados, a menos que cada um também seja marcado como pub.

Isso permite controlar como a estrutura é criada e modificada.

mod model {
    pub struct User {
        pub name: String,
        age: u32,
    }
    impl User {
        pub fn new(name: String, age: u32) -> User {
            User { name, age }
        }
        pub fn age(&self) -> u32 { self.age }
    }
}

fn main() {
    let u = model::User::new(String::from("Sam"), 28);
    println!("{} is {}", u.name, u.age());
}

Por que ocultar campos?

Campos privados impõem invariantes. Os chamadores precisam usar seu construtor e seus métodos, permitindo validar entradas e alterar o layout interno posteriormente sem quebrar o código dos usuários.

Enumerações pub expõem tudo

Ao contrário das estruturas, uma enumeração pub torna automaticamente públicas todas as suas variantes. As variantes não têm visibilidade separada.

mod traffic {
    pub enum Light {
        Red,
        Yellow,
        Green,
    }
}

fn main() {
    let l = traffic::Light::Green;
    let go = matches!(l, traffic::Light::Green);
    println!("go = {}", go);
}

pub(crate): em todo o crate

pub(crate) torna um item visível em todo o mesmo crate, mas não para crates externos que dependam do seu.

É perfeito para APIs internas compartilhadas entre módulos.

mod config {
    pub(crate) fn default_port() -> u16 {
        8080
    }
}

fn main() {
    println!("{}", config::default_port());
}

pub(super): somente para o pai

pub(super) expõe um item apenas ao módulo pai. É uma permissão mais restrita do que pub completo.

mod outer {
    pub fn run() {
        inner::helper();
    }
    mod inner {
        pub(super) fn helper() {
            println!("visible to parent only");
        }
    }
}

fn main() {
    outer::run();
}

Reexportando com pub use

pub use reexporta um item, permitindo que os chamadores o acessem por um caminho mais curto ou conveniente. Isso ajuda a criar uma API pública organizada.

mod deep {
    pub mod nested {
        pub fn ping() {
            println!("pong");
        }
    }
    pub use nested::ping;
}

fn main() {
    deep::ping();
}

Projetando uma API pública

Exponha a menor superfície capaz de realizar o trabalho. Mantenha os auxiliares privados, oculte os campos das estruturas por trás de métodos e use pub(crate) para o compartilhamento interno.

Uma API enxuta é mais fácil de evoluir sem quebrar o código dos usuários.

Resumo dos níveis de visibilidade

Do mais ao menos restritivo:

padrão (privado para o módulo)
pub(super) — visível para o pai
pub(crate) — visível em todo o crate
pub — visível em todos os lugares

Verificação rápida

Teste sua compreensão sobre visibilidade.

Recapitulação

Você aprendeu a controlar o acesso:

Os itens são privados por padrão; pub os expõe
As estruturas pub mantêm os campos privados, a menos que cada um seja pub
As enumerações pub expõem todas as variantes
pub(crate) e pub(super) oferecem um controle mais preciso
pub use reexporta itens para criar uma API organizada

Perguntas Frequentes

A aula “pub e visibilidade” é grátis?

Sim — o texto completo de “pub e visibilidade” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “pub e visibilidade”?

Controle o acesso Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “pub e visibilidade”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding