Bild von Autor | Chatgpt

Die Arbeit mit Daten ist überall, von kleinen Apps bis hin zu riesigen Systemen. Aber Daten schnell und sicher zu handhaben ist nicht immer einfach. Dort kommt Rost ins Spiel. Rost ist eine Programmiersprache für Geschwindigkeit und Sicherheit. Es eignet sich hervorragend zum Aufbau von Instruments, die große Datenmengen bearbeiten müssen, ohne zu verlangsamen oder zu stürzen. In diesem Artikel werden wir untersuchen, wie Rust Ihnen helfen kann, Hochleistungsdaten-Instruments zu erstellen.

# Was ist „Vibe -Codierung“?

Vibe -Codierung Bezieht sich auf die Praxis der Verwendung von großsprachigen Modellen (LLMs), um Code zu erstellen, die auf natürlichen Sprachbeschreibungen basieren. Anstatt jede Codezeile selbst zu tippen, sagen Sie der KI, was Ihr Programm tun sollte, und es schreibt den Code für Sie. Die Vibe -Codierung erleichtert es einfacher und schneller, Software program zu erstellen, insbesondere für Personen, die nicht viel Erfahrung mit der Codierung haben.

Der Vibe -Codierungsprozess umfasst die folgenden Schritte:

1. Natürliche Spracheingabe: Der Entwickler enthält eine Beschreibung der gewünschten Funktionalität in der Klartext.
2. AI -Interpretation: Die AI analysiert die Eingabe und bestimmt die erforderliche Codestruktur und Logik.
3. Codegenerierung: Die KI generiert den Code basierend auf ihrer Interpretation.
4. Ausführung: Der Entwickler führt den generierten Code aus, um festzustellen, ob er wie beabsichtigt funktioniert.
5. Verfeinerung: Wenn etwas stimmt, sagt der Entwickler der KI, was er beheben soll.
6. Iteration: Der iterative Prozess wird fortgesetzt, bis die gewünschte Software program erreicht ist.

# Warum Rost für Datenwerkzeuge?

Rust wird aufgrund mehrerer wichtiger Vorteile zu einer beliebten Wahl für das Erstellen von Datenwerkzeugen:

• Hohe Leistung: Rust liefert die Leistung, die mit C und C ++ vergleichbar ist und schnell große Datensätze behandelt
• Speichersicherheit: Rost hilft dem Speicher sicher ohne Müllsammler, der die Fehler reduziert und die Leistung verbessert
• Parallelität: Die Eigentümerregeln von Rust verhindern Datenrennen, mit denen Sie einen sicheren Parallelcode für Multi-Core-Prozessoren schreiben können
• Reiches Ökosystem: Rust hat ein wachsendes Ökosystem von Bibliotheken, das als Kisten bekannt ist, die es einfach machen, leistungsstarke, plattformübergreifende Werkzeuge aufzubauen

# Stellen Sie Ihre Rostumgebung auf

Der Einstieg ist unkompliziert:

1. Rost einbauen: Verwenden Rostup Rost zu installieren und es auf dem neuesten Stand zu halten
2. IDE -Unterstützung: Beliebte Redakteure mögen Vs Code Und Intellij Rost Machen Sie es einfach, Rostcode zu schreiben
3. Nützliche Kisten: Betrachten Sie für die Datenverarbeitung Kisten wie z. csvAnwesend serdeAnwesend rayonUnd tokio

Mit dieser Fundament können Sie Datenwerkzeuge in Rost erstellen.

# Beispiel 1: CSV -Parser

Eine gemeinsame Aufgabe beim Arbeiten mit Daten ist das Lesen von CSV -Dateien. CSV -Dateien speichern Daten in einem Tabellenformat wie einer Tabelle. Lassen Sie uns ein einfaches Werkzeug in Rost bauen, um genau das zu tun.

// Schritt 1: Hinzufügen von Abhängigkeiten

In Rost verwenden wir Kisten um uns zu helfen. Fügen Sie diese zu diesem Beispiel zu Ihrem Projekt hinzu Cargo.toml Datei:

(dependencies)
csv = "1.1"
serde = { model = "1.0", options = ("derive") }
rayon = "1.7"

• csv Hilft uns, CSV -Dateien zu lesen
• serde Lassen Sie uns CSV -Zeilen in Rost -Datentypen umwandeln
• rayon Lassen Sie uns Daten parallel verarbeiten

// Schritt 2: Definieren einer Datensatzstruktur

Wir müssen Rost sagen, welche Artwork von Daten jede Zeile enthält. Wenn beispielsweise jede Zeile einen ID, einen Namen und einen Wert hat, schreiben wir:

use serde::Deserialize;

#(derive(Debug, Deserialize))
struct Document {
    id: u32,
    title: String,
    worth: f64,
}

Dies erleichtert es Rost, CSV -Zeilen in die Zeile zu verwandeln Document Strukturen.

// Schritt 3: Rayon zur Parallelität verwenden

Lassen Sie uns nun eine Funktion schreiben, die die CSV -Datei liest und Datensätze filtert, bei denen der Wert größer als 100 ist.

use csv::ReaderBuilder;
use rayon::prelude::*;
use std::error::Error;

// Document struct from the earlier step must be in scope
use serde::Deserialize;

#(derive(Debug, Deserialize, Clone))
struct Document {
    id: u32,
    title: String,
    worth: f64,
}

fn process_csv(path: &str) -> End result<(), Field> {
    let mut rdr = ReaderBuilder::new()
        .has_headers(true)
        .from_path(path)?;

    // Accumulate data right into a vector
    let data: Vec = rdr.deserialize()
        .filter_map(End result::okay)
        .accumulate();

    // Course of data in parallel: filter the place worth > 100.0
    let filtered: Vec<_> = data.par_iter()
        .filter(|r| r.worth > 100.0)
        .cloned()
        .accumulate();

    // Print filtered data
    for rec in filtered {
        println!("{:?}", rec);
    }
    Okay(())
}

fn foremost() {
    if let Err(err) = process_csv("information.csv") {
        eprintln!("Error processing CSV: {}", err);
    }
}

# Beispiel 2: Asynchroner Streaming -Datenprozessor

In vielen Datenszenarien – wie Protokollen, Sensordaten oder finanziellen Zecken – müssen Sie Datenströme asynchron verarbeiten, ohne das Programm zu blockieren. Das Async -Ökosystem von Rust erleichtert das Erstellen von Streaming -Datenwerkzeugen.

// Schritt 1: Hinzufügen asynchroner Abhängigkeiten

Fügen Sie diese Kisten zu Ihrem hinzu Cargo.toml Um mit asynchronen Aufgaben und JSON -Daten zu helfen:

(dependencies)
tokio = { model = "1", options = ("full") }
async-stream = "0.3"
serde_json = "1.0"
tokio-stream = "0.1"
futures-core = "0.3"

• tokio ist die asynchronische Laufzeit, die unsere Aufgaben ausführt
• async-stream hilft uns, Daten von Daten asynchron zu erstellen
• serde_json Parsen JSON -Daten in Roststrukturen

// Schritt 2: Erstellen eines asynchronen Datenstroms

Hier ist ein Beispiel, das Simulate, die JSON -Ereignisse nacheinander empfangen, mit einer Verzögerung von Simulaten erhalten. Wir definieren eine Occasion Struktur und erstellen Sie dann einen Stream, der diese Ereignisse asynchron erzeugt:

use async_stream::stream;
use futures_core::stream::Stream;
use serde::Deserialize;
use tokio::time::{sleep, Period};
use tokio_stream::StreamExt;

#(derive(Debug, Deserialize))
struct Occasion {
    event_type: String,
    payload: String,
}

fn event_stream() -> impl Stream {
    stream! {
        for i in 1..=5 {
            let occasion = Occasion {
                event_type: "replace".into(),
                payload: format!("information {}", i),
            };
            yield occasion;
            sleep(Period::from_millis(500)).await;
        }
    }
}

#(tokio::foremost)
async fn foremost() {
    let mut stream = event_stream();

    whereas let Some(occasion) = stream.subsequent().await {
        println!("Obtained occasion: {:?}", occasion);
        // Right here you possibly can filter, remodel, or retailer the occasion
    }
}

# Tipps zur Maximierung der Leistung

• Profilieren Sie Ihren Code mit Instruments wie cargo bench oder perf Engpässe erkennen
• Bevorzugen Sie Null-Kosten-Abstraktionen wie Iteratoren und Merkmale, um sauberen und schnellen Code zu schreiben
• Verwenden Sie asynchrische E/O mit tokio Beim Umgang mit Netzwerk- oder Festplatten -Streaming
• Halten Sie das Eigentümermodell von Rust vorne und im Zentrum, um unnötige Zuteilungen oder Klone zu vermeiden
• Im Freigabemodus erstellen (cargo construct --release) Um Compiler -Optimierungen zu aktivieren
• Verwenden Sie spezialisierte Kisten wie ndarray oder einzelne Anweisungen, mehrere Daten (SIMD) Bibliotheken für schwere numerische Workloads

# Einpacken

Mit der Vibe -Codierung können Sie Software program erstellen, indem Sie beschreiben, was Sie wollen, und die KI macht Ihre Ideen in Arbeitscode. Dieser Prozess spart Zeit und senkt die Eintrittsbarriere. Rost ist perfekt für Datenwerkzeuge und bietet Ihnen Geschwindigkeit, Sicherheit und Kontrolle ohne Müllsammler. Außerdem hilft Ihnen der Compiler von Rust, gängige Fehler zu vermeiden.

Wir haben gezeigt, wie man einen CSV -Prozessor erstellt, der Daten parallel liest, filtert und verarbeitet. Wir haben auch einen asynchronen Stream -Prozessor erstellt, um Dwell -Daten mithilfe zu verarbeiten tokio. Verwenden Sie KI, um Ideen und Rost zu erkunden, um sie zum Leben zu erwecken. Gemeinsam helfen sie Ihnen, Hochleistungswerkzeuge aufzubauen.

Jayita Gulati ist ein Fanatic und technische Schriftsteller für maschinelles Lernen, der von ihrer Leidenschaft für den Aufbau maschineller Lernmodelle angetrieben wird. Sie hat einen Grasp -Abschluss in Informatik an der Universität von Liverpool.

Eine beliebte Programmiersprache in den letzten Jahren, da sie Sicherheit und hohe Leistung kombiniert und in vielen Anwendungen verwendet werden kann. Es kombiniert die positiven Eigenschaften von C und C ++ mit der modernen Syntax und Einfachheit anderer Programmiersprachen wie Python. In diesem Artikel werden wir einen Schritt-für-Schritt-Blick auf die Set up von Rost auf verschiedenen Betriebssystemen werfen und eine einfache Befehlszeilenschnittstelle einrichten, um die Struktur und Funktionalität von Rust zu verstehen.

Rost installieren – Schritt für Schritt

Unabhängig vom Betriebssystem ist es dank des offiziellen Installationsprogramms recht einfach, Rost zu installieren rustupwas kostenlos auf der verfügbar ist Rost Webseite. Dies bedeutet, dass die Set up nur wenige Schritte dauert und sich nur für die verschiedenen Betriebssysteme nur geringfügig unterscheidet.

Rost unter Home windows installieren

In Home windows steuert der Installationsprogramm die Set up vollständig und Sie können die folgenden Schritte ausführen:

1. Gehen Sie zum Unterabschnitt „Set up“ auf der offiziellen Rust -Web site (https://www.rust-lang.org/instruments/set up) und laden Sie die herunter rustup-init.exe Datei dort. Die Web site erkennt das zugrunde liegende Betriebssystem so an, dass die entsprechenden Vorschläge für das verwendete System direkt gemacht werden.
2. Sobald der Obtain abgeschlossen ist, ist der rustup-init.exe Datei kann ausgeführt werden. Eine Befehlszeile mit verschiedenen Installationsanweisungen wird dann geöffnet.
3. Drücken Sie die Eingabetaste, um die Standardinstallation auszuführen, um Rost zu installieren. Dies schließt auch die folgenden Instruments ein:
   • rustc ist der Compiler, der den Code und die Überprüfung von Fehlern vor der Ausführung überprüft.
   • cargo Ist Rust’s Construct- und Paketmanagement -Software.
   • rustup ist der Versionsleiter.

Nach erfolgreicher Set up sollte Rost automatisch in Ihrem verfügbar sein PATH. Dies kann leicht in PowerShell oder CMD unter Verwendung der folgenden Befehle überprüft werden:

rustc --version cargo --version

Wenn „Rustc“ und „Fracht“ in der Ausgabe mit den jeweiligen Versionsnummern angezeigt werden, battle die Set up erfolgreich. Wenn der Befehl jedoch nicht gefunden wird, kann dies auf die Umgebungsvariablen zurückzuführen sein. Um diese zu überprüfen, können Sie den Pfad „Dieser PC -> Eigenschaften -> erweiterte Systemeinstellungen -> Umgebungsvariablen“ befolgen. Dort dort sollten Sie sicherstellen PATH Variable.

Installieren von Rost unter Ubuntu/Linux

In Linux kann Rost über das Terminal vollständig installiert werden, ohne etwas von der Rust -Web site herunterladen zu müssen. Um Rost zu installieren, müssen die folgenden Schritte durchgeführt werden:

1. Öffnen Sie beispielsweise das Terminal mit der Schlüsselkombination Strg + Alt + T.
2. Um Rost zu installieren, wird der folgende Befehl ausgeführt:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

3. Sie werden dann gefragt, ob die Set up gestartet werden soll. Dies kann bestätigt werden, indem beispielsweise „1“ (Normal) eingegeben wird. Alle erforderlichen Pakete werden dann heruntergeladen und die Umgebung ist eingerichtet.
4. Möglicherweise müssen Sie den Pfad manuell einstellen. In diesem Fall können Sie diesen Befehl zum Beispiel verwenden:

supply $HOME/.cargo/env

Nach Abschluss der Set up können Sie überprüfen, ob alles richtig funktioniert hat. Dazu können Sie die Versionen von RustC und Fracht explizit anzeigen:

rustc --version cargo --version

Installieren von Rost unter MacOS

Es gibt verschiedene Möglichkeiten, Rost auf MacOS zu installieren. Wenn Sie Homebrew installiert haben, können Sie dies einfach verwenden, um Rust zu installieren, indem Sie den folgenden Befehl ausführen:

brew set up rustup rustup-init

Alternativ können Sie Rost auch direkt mit diesem Skript installieren:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Während der Set up werden Sie gefragt, ob Sie die Standardinstallation ausführen möchten. Sie können dies einfach bestätigen, indem Sie die Eingabetaste drücken. Unabhängig von der ausgewählten Variante können Sie die Set up überprüfen, indem Sie die Model von Rust anzeigen, um sicherzustellen, dass alles funktioniert hat:

rustc --version 
cargo --version

Erstellen eines Rust -Projekts mit Fracht

Während der Set up von Rost sind Sie wahrscheinlich bereits auf die gestoßen cargo Programm. Dies ist der offizielle Paketmanager und das Construct -Rostsystem und vergleichbar mit pip in Python. cargo führt unter anderem die folgenden Aufgaben aus:

• Initialisierung eines Projekts
• Verwaltung von Abhängigkeiten
• Kompilieren des Codes
• Ausführung von Assessments
• Optimierung von Builds

Auf diese Weise können Sie vollständige Projekte in Rost verwalten, ohne sich mit komplizierten Construct -Skripten befassen zu müssen. Es hilft Ihnen auch, schnell und einfach neue Projekte einzurichten, die dann mit dem Leben gefüllt werden können.

Für unser Beispiel werden wir ein neues Projekt erstellen. Dazu gehen wir zum Terminal und navigieren zu einem Ordner, in dem wir ihn speichern möchten. Anschließend führen wir den folgenden Befehl aus, um ein neues Rust -Projekt zu erstellen:

cargo new json_viewer --bin

Wir nennen dieses Projekt json_viewer Weil wir ein CLI -Software erstellen, mit dem wir zum Öffnen und Verfahren verwendet werden können JSON Dateien. Der --bin Die Possibility gibt an, dass wir ein ausführbares Programm und keine Bibliothek erstellen möchten. Sie sollten nun in der Lage sein, die folgende Ordnerstruktur in Ihrem Verzeichnis zu sehen, nachdem Sie den Befehl ausgeführt haben:

json_viewer/ 
├── Cargo.toml # Undertaking configuration 
└── src 
     └── most important.rs # File for Rust Code

Jedes neue Projekt hat diese Struktur. Cargo.toml Enthält alle Abhängigkeiten und Metadaten Ihres Projekts, wie den Namen, die verwendeten Bibliotheken oder die Model. Der src/most important.rsAndererseits enthält später den tatsächlichen Rostcode, der dann die Schritte definiert, die beim Starten des Programms ausgeführt werden.

Zunächst können wir hier eine einfache Funktion definieren, die eine Ausgabe im Terminal erzeugt:

fn most important() { 
     println!("Hey, Rust CLI-Software!"); 
}

Das Programm kann leicht vom Terminal mithilfe von Verwendung aufgerufen werden cargo:

cargo run

Damit dieser Aufruf zur Arbeit ist, muss sichergestellt werden, dass Sie sich im Hauptverzeichnis des Projekts befinden, dh wo die Cargo.toml Datei wird gespeichert. Wenn alles korrekt eingerichtet und ausgeführt wurde, erhalten Sie diese Ausgabe:

Hey, Rust CLI-Software!

Mit diesen wenigen Schritten haben Sie gerade Ihr erstes erfolgreiches Rust -Projekt erstellt, auf dem wir im nächsten Abschnitt aufbauen können.

Erstellen eines CLI -Werkzeugs: Einfacher JSON -Parser

Jetzt füllen wir das Projekt mit dem Leben aus und erstellen ein Programm, mit dem JSON -Dateien gelesen und ihre Inhalte auf strukturierte Weise im Terminal ausgeben können.

Der erste Schritt besteht darin, die Abhängigkeiten zu definieren, dh die Bibliotheken, die wir im Verlauf des Projekts verwenden werden. Diese werden in der gespeichert Cargo.toml Datei. In Rost sind die sogenannten Kisten mit Bibliotheken oder Modulen vergleichbar, die bestimmte vordefinierte Funktionen bieten. Zum Beispiel können sie aus wiederverwendbarem Code bestehen, das von anderen Entwicklern verfasst wurde.

Wir brauchen die folgenden Kisten für unser Projekt:

• serde ermöglicht die Serialisierung und Deserialisierung von Datenformaten wie z. JSON oder Yaml.
• serde_jsonAndererseits ist eine Erweiterung, die speziell für die Arbeit mit JSON -Dateien entwickelt wurde.

Damit Ihr Projekt auf diese Kisten zugreifen kann, müssen sie in der gespeichert werden Cargo.toml Datei. Dies sieht unmittelbar nach dem Erstellen des Projekts so aus:

(package deal) 
identify = "json_viewer" 
model = "0.1.0" 
version = "2021" 

(dependencies)

Wir können jetzt die erforderlichen Kisten in die hinzufügen (dependencies) Abschnitt. Hier definieren wir auch die zu verwendende Model:

(dependencies) 
serde = "1.0" 
serde_json = "1.0"

Um sicherzustellen, dass die zusätzlichen Abhängigkeiten im Projekt verfügbar sind, müssen sie zunächst heruntergeladen und erstellt werden. Dazu kann der folgende Terminalbefehl im Hauptverzeichnis ausgeführt werden:

cargo construct

Während der Ausführung, cargo Sucht nach den Abhängigkeiten und den angegebenen Versionen, um sie herunterzuladen. Diese Kisten werden dann zusammen mit dem Code zusammengestellt und zwischengespeichert, damit sie für den nächsten Construct nicht erneut heruntergeladen werden müssen.

Wenn diese Schritte funktioniert haben, sind wir jetzt bereit, den tatsächlichen Rostcode zu schreiben, der die JSON -Datei öffnet und verarbeitet. Dazu können Sie die öffnen src/most important.rs Datei und ersetzen Sie den vorhandenen Inhalt durch diesen Code:

use std::fs;
use serde_json::Worth;
use std::env;

fn most important() {
    // Test arguments
    let args: Vec<String> = env::args().acquire();
    if args.len() < 2 {
        println!(“Please specify the trail to your file.”);
        return;
    }

    // Learn in File
    let file_path = &args(1);
    let file_content = fs::read_to_string(file_path)
        .count on(“File couldn't be learn.”);

    // Parse JSON
    let json_data: Worth = serde_json::from_str(&file_content)
        .count on(“Invalid JSON format.”);

    // Print JSON
    println!(" JSON-content:n{}”, json_data);
}

Der Code folgt folgende Schritte:

1. Argumente überprüfen:
   • Wir lesen die Argumente aus der Befehlszeile über env::args().
   • Der Benutzer muss den Pfad zur JSON -Datei beim Begin angeben.
2. Lesen Sie die Datei:
   • Mit Hilfe von fs::read_to_string()Der Inhalt der Datei wird in eine Zeichenfolge gelesen.
3. JSON analysieren:
   • Die Kiste serde_json Konvertiert die Zeichenfolge in ein Rust -Objekt mit dem Typwert.
4. Formatausgabe:
   • Der Inhalt wird in der Konsole lesbar ausgegeben.

Um das Software zu testen, können Sie beispielsweise eine Testdatei im Projektverzeichnis unter dem Namen erstellen examples.json:

{
  "identify": "Alice",
  "age": 30,
  "abilities": ("Rust", "Python", "Machine Studying")
}

Das Programm wird dann mithilfe der Ausführung cargo run und der Pfad zur JSON -Datei ist ebenfalls definiert:

cargo run ./instance.json

Dies bringt uns zum Ende unseres ersten Projekts in Rust und wir haben erfolgreich ein einfaches CLI -Software erstellt, mit dem JSON -Dateien gelesen und an der Befehlszeile ausgegeben werden können.

Das sollten Sie mitnehmen

• Die Set up von Rost ist in vielen Betriebssystemen schnell und einfach. Die anderen benötigten Komponenten sind bereits installiert.
• Mit Hilfe von cargoein leeres Projekt kann direkt erstellt werden, das die erforderlichen Dateien enthält und in denen Sie mit dem Schreiben von Rostcode beginnen können
• Bevor Sie anfangen ProgrammierungSie sollten die Abhängigkeiten eingeben und sie mit dem Befehl Construct herunterladen.
• Nachdem alles eingerichtet ist, können Sie mit der tatsächlichen Programmierung beginnen.