Learn Rust Coding · Lektion

pub und Sichtbarkeit

Zugriff steuern

pub und Sichtbarkeit ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Standardmäßig privat

In Rust ist alles innerhalb eines Moduls standardmäßig privat. Andere Module können darauf nicht zugreifen, es sei denn, Sie geben es mit pub ausdrücklich frei.

Diese sichere Voreinstellung hält Implementierungsdetails verborgen, bis Sie sie bewusst sichtbar machen.

<code>pub</code>-Funktionen

Wenn Sie eine Funktion mit pub kennzeichnen, kann sie von außerhalb ihres Moduls aufgerufen werden. Ohne diese Kennzeichnung schlägt die Kompilierung des Aufrufs fehl.

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

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

Private Hilfsfunktionen bleiben verborgen

Sie können interne Hilfsfunktionen privat halten und gleichzeitig eine öffentliche API bereitstellen. Die öffentliche Funktion darf die private Funktion aufrufen, Außenstehende jedoch nicht.

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

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

<code>pub</code>-Structs verbergen Felder

Wenn Sie ein Struct mit pub versehen, wird der Typ sichtbar. Seine Felder bleiben jedoch privat, sofern nicht jedes einzelne ebenfalls mit pub gekennzeichnet ist.

So können Sie kontrollieren, wie das Struct erstellt und geändert wird.

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());
}

Warum Felder verbergen?

Private Felder erzwingen Invarianten. Aufrufer müssen Ihren Konstruktor und Ihre Methoden verwenden, sodass Sie Eingaben validieren und die interne Struktur später ändern können, ohne Nutzer zu beeinträchtigen.

<code>pub</code>-Enums machen alles sichtbar

Anders als bei Structs macht ein pub-Enum automatisch alle seine Varianten öffentlich. Varianten haben keine eigene Sichtbarkeit.

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);
}

<code>pub(crate)</code>: im gesamten Crate

pub(crate) macht ein Element überall im selben Crate sichtbar, nicht jedoch für externe Crates, die von Ihrem Crate abhängen.

Das eignet sich ideal für interne APIs, die von mehreren Modulen gemeinsam verwendet werden.

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

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

<code>pub(super)</code>: nur für das übergeordnete Modul

pub(super) macht ein Element nur für das übergeordnete Modul sichtbar. Das ist eine engere Freigabe als das vollständige pub.

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

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

Mit <code>pub use</code> erneut exportieren

pub use exportiert ein Element erneut, sodass Aufrufer über einen kürzeren oder bequemeren Pfad darauf zugreifen können. So gestalten Sie eine übersichtliche öffentliche API.

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

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

Eine öffentliche API entwerfen

Geben Sie nur die kleinste Oberfläche frei, die ihre Aufgabe erfüllt. Halten Sie Hilfsfunktionen privat, verbergen Sie Struct-Felder hinter Methoden und verwenden Sie pub(crate) für die interne gemeinsame Nutzung.

Eine schlanke API lässt sich leichter weiterentwickeln, ohne Nutzer zu beeinträchtigen.

Zusammenfassung der Sichtbarkeitsstufen

Von der restriktivsten bis zur am wenigsten restriktiven Stufe:

Standard (privat für das Modul)
pub(super) — für das übergeordnete Modul sichtbar
pub(crate) — im gesamten Crate sichtbar
pub — überall sichtbar

Kurze Überprüfung

Testen Sie Ihr Verständnis der Sichtbarkeit.

Zusammenfassung

Sie haben gelernt, Zugriffe zu steuern:

Elemente sind standardmäßig privat; pub macht sie sichtbar
pub-Structs halten Felder privat, sofern nicht jedes Feld mit pub versehen ist
pub-Enums machen alle Varianten sichtbar
pub(crate) und pub(super) ermöglichen eine feinere Kontrolle
pub use exportiert Elemente erneut, um eine übersichtliche API zu gestalten

Häufig gestellte Fragen

Ist die Lektion „pub und Sichtbarkeit“ kostenlos?

Ja — der vollständige Text von „pub und Sichtbarkeit“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „pub und Sichtbarkeit“?

Zugriff steuern Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „pub und Sichtbarkeit“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding