Tutorial 6~25 MinutenAnfänger

Standard Library

Entdecke die mächtige Standardbibliothek von Velisch – von HTTP über JSON bis hin zu KI und Kryptographie.

Was du lernen wirst

  • Die wichtigsten Module der Standardbibliothek
  • HTTP-Modul für APIs und Middleware
  • JSON-Verarbeitung und Dateisystem-Zugriff
  • KI-Integration und Kryptographie
1

Module im Überblick

Die Velisch Standardbibliothek ist in Module organisiert. Jedes Modul beginnt mitstd: und bietet spezialisierte Funktionalität.

std:http

Web-Server & Routing

std:json

Serialisierung

std:fs

Dateisystem

std:ai

LLM & ML

std:crypto

Verschlüsselung

std:db

ORM & Queries

std:net

Netzwerk

std:process

Prozesse

// Module importieren
import { http, Context } from "std:http";
import { json } from "std:json";
import { fs } from "std:fs";
import { ai } from "std:ai";
import { crypto } from "std:crypto";
2

std:http – Web-Server & APIs

Das HTTP-Modul ist das Herzstück für API-Entwicklung. Es bietet einen dekorator-basierten Ansatz für Routing, Middleware und Request-Handling.

Routing mit Decorators

import { http, Context } from "std:http";

// Einfacher GET-Endpunkt
@GET("/api/status")
fn getStatus(ctx: Context) {
    return ctx.json({ 
        status: "ok", 
        version: "2.0",
        timestamp: now(),
    });
}

// POST mit Body-Parsing
@POST("/api/users")
fn createUser(ctx: Context) {
    let body = ctx.body<CreateUserInput>();
    let user = db.save(User { 
        name: body.name, 
        email: body.email 
    });
    return ctx.status(201).json(user);
}

// URL-Parameter
@GET("/api/users/:id")
fn getUser(ctx: Context) {
    let id = ctx.param("id");
    let user = db.find(User, id);
    return ctx.json(user);
}

Middleware

Middleware verarbeitet Requests vor und nach deinem Handler:

// Middleware definieren
@Middleware
fn logger(ctx: Context, next: Fn) {
    let start = now();
    println("[{ctx.method}] {ctx.path}");
    
    next();  // Handler ausführen
    
    let duration = now() - start;
    println("→ {ctx.status} in {duration}ms");
}

// Middleware anwenden
@POST("/api/data")
@Use(logger)
fn postData(ctx: Context) {
    let body = ctx.body();
    return ctx.status(201).send("Created");
}

// Auth-Middleware
@Middleware
fn requireAuth(ctx: Context, next: Fn) {
    let token = ctx.header("Authorization");
    if (token == null) {
        return ctx.status(401).json({ error: "Unauthorized" });
    }
    ctx.set("user", verifyToken(token));
    next();
}
3

std:json – Datenverarbeitung

Das JSON-Modul bietet blitzschnelle Serialisierung und Deserialisierung – optimiert durch Rusts serde.

import { json } from "std:json";

struct Config {
    host: string,
    port: number,
    debug: boolean,
    tags: List<string>,
}

// JSON → Struct (Deserialisierung)
let raw = '{"host": "localhost", "port": 8080, "debug": true, "tags": ["api", "v2"]}';
let config = json.decode<Config>(raw);

println(config.host);  // → "localhost"
println(config.port);  // → 8080

// Struct → JSON (Serialisierung)
let newConfig = Config {
    host: "0.0.0.0",
    port: 3000,
    debug: false,
    tags: ["prod"],
};

let jsonString = json.encode(newConfig);
// → '{"host":"0.0.0.0","port":3000,"debug":false,"tags":["prod"]}'

// Pretty Print
let pretty = json.encodePretty(newConfig);
4

std:fs – Dateisystem

Sicherer Dateizugriff mit automatischer Ressourcenfreigabe und Fehlerbehandlung.

import { fs } from "std:fs";

fn processFiles() {
    // Datei lesen
    if (fs.exists("./data.txt")) {
        let content = fs.readToString("./data.txt");
        println("Inhalt: {content}");
    }

    // Datei schreiben
    fs.write("./output.log", "Log entry at {now()}");

    // Append (anhängen)
    fs.append("./output.log", "\nNeue Zeile");

    // Verzeichnis lesen
    let files = fs.readDir("./logs");
    for (file in files) {
        println("Datei: {file.name}, Größe: {file.size} bytes");
    }

    // Verzeichnis erstellen
    fs.createDir("./backups");

    // Datei kopieren/verschieben
    fs.copy("./data.txt", "./backups/data.txt");
    fs.rename("./old.txt", "./new.txt");

    // Löschen
    fs.remove("./temp.txt");
}
5

std:ai – Künstliche Intelligenz

Native Abstraktionen für LLM-Provider (OpenAI, Anthropic, lokale Modelle) und Vektor-Embeddings.

import { ai } from "std:ai";

// LLM-Completion
@Async
fn generateResponse(prompt: string): string {
    let model = ai.loadModel("gpt-4o");
    
    let response = await model.complete({
        prompt: prompt,
        temperature: 0.7,
        maxTokens: 500,
        systemPrompt: "Du bist ein hilfreicher Assistent.",
    });
    
    return response.text;
}

// Chat mit History
let chat = ai.createChat("gpt-4o");
chat.addMessage("user", "Was ist Velisch?");
let reply = await chat.send();
chat.addMessage("user", "Zeig mir ein Beispiel");
let reply2 = await chat.send();

// Embeddings für Vektor-Suche
fn computeEmbeddings(texts: List<string>): List<Vector> {
    return texts.map(text => {
        ai.embeddings(text, "text-embedding-3-small")
    });
}

// Sentiment-Analyse
let sentiment = ai.analyze("Das Produkt ist großartig!", "sentiment");
println(sentiment.score);   // → 0.95
println(sentiment.label);   // → "positive"

🤖 Lokale Modelle

Velisch unterstützt auch lokale Modelle via Ollama oder GGUF-Dateien:

let localModel = ai.loadModel("ollama:llama2");
let response = await localModel.complete({ prompt: "Hallo!" });
6

std:crypto – Sicherheit

Kryptographische Operationen nach modernsten Standards – Hashing, Verschlüsselung, sichere Zufallszahlen.

import { crypto } from "std:crypto";

// Passwort-Hashing (Argon2)
fn hashPassword(password: string): string {
    let salt = crypto.randomBytes(16);
    return crypto.argon2(password, salt);
}

// Passwort verifizieren
fn verifyPassword(password: string, hash: string): boolean {
    return crypto.argon2Verify(password, hash);
}

// AES-Verschlüsselung
fn encryptData(data: string, masterKey: string): string {
    let key = crypto.deriveKey(masterKey, "aes-256-gcm");
    return crypto.encrypt(data, key);
}

fn decryptData(encrypted: string, masterKey: string): string {
    let key = crypto.deriveKey(masterKey, "aes-256-gcm");
    return crypto.decrypt(encrypted, key);
}

// Hashing
let sha256 = crypto.hash("Daten", "sha256");
let md5 = crypto.hash("Daten", "md5");  // Nicht für Sicherheit!

// Sichere Zufallszahlen
let randomId = crypto.randomBytes(32).toHex();
let uuid = crypto.uuid();

Zusammenfassung

Was du gelernt hast:

  • std:http für APIs und Middleware
  • std:json für Serialisierung
  • std:fs für Dateisystem-Zugriff
  • std:ai für KI und LLMs
  • std:crypto für Sicherheit

Nächste Schritte:

  • Baue deine erste REST API
  • Lerne Daten-Validierung
← Tutorial 5: Pattern MatchingNächstes: REST APIs