Tutorial 1~15 MinutenAnfänger

Velisch Grundlagen

In diesem Tutorial lernst du die fundamentalen Konzepte von Velisch – von Variablen über Funktionen bis hin zu deiner ersten API.

Was du lernen wirst

Variablen deklarieren und Typen verstehen
Funktionen schreiben und aufrufen
Structs für Datenmodelle nutzen
Kontrollstrukturen anwenden

Variablen & Typen

Variablen sind Container für Daten. In Velisch deklarierst du sie mit let. Das Besondere: Velisch erkennt automatisch den Typ deiner Daten – du musst ihn nicht explizit angeben.

Type Inference (Automatische Typerkennung)

Velisch analysiert den zugewiesenen Wert und leitet den Typ automatisch ab:

// Der Compiler erkennt den Typ automatisch
let name = "Anna";        // → string
let age = 25;             // → number
let isActive = true;      // → boolean
let price = 19.99;        // → number (Dezimalzahlen)

Explizite Typangabe

Wenn du den Typ explizit angeben möchtest (z.B. für bessere Lesbarkeit), nutze einen Doppelpunkt:

// Explizite Typen für mehr Klarheit
let email: string = "anna@example.com";
let score: number = 95.5;
let isAdmin: boolean = false;

Tipp: Mutability

Standardmäßig sind Variablen in Velisch unveränderlich. Um eine Variable später ändern zu können, nutze let mut:

// Unveränderliche Variable (Standard)
let name = "Anna";
// name = "Max";  // ❌ Fehler! Variable ist immutable

// Veränderliche Variable mit 'mut'
let mut counter = 0;
counter = counter + 1;  // ✅ Funktioniert!
counter = 10;           // ✅ Auch mehrfach änderbar

💡 Warum Immutability als Standard?

Unveränderliche Variablen verhindern versehentliche Änderungen und machen deinen Code sicherer. In der KI- und API-Entwicklung ist das besonders wichtig, da Daten oft durch mehrere Verarbeitungsschritte fließen.

Funktionen

Funktionen sind wiederverwendbare Code-Blöcke. In Velisch definierst du sie mit dem Keyword fn. Jede Funktion hat einen Namen, optionale Parameter und einen Rückgabetyp.

Grundlegende Syntax

// Einfache Funktion ohne Parameter
fn getVersion(): string {
    return "2.0.0";
}

// Funktion mit einem Parameter
fn greet(name: string): string {
    return "Hallo, " + name + "!";
}

// Funktion mit mehreren Parametern
fn add(a: number, b: number): number {
    return a + b;
}

// Aufruf der Funktionen
let version = getVersion();      // → "2.0.0"
let greeting = greet("Anna");    // → "Hallo, Anna!"
let sum = add(5, 3);             // → 8

Aufbau einer Funktion

fn – Keyword für Funktionsdefinition
name – Name der Funktion
(params) – Parameter in Klammern
: Type – Rückgabetyp nach Doppelpunkt
{ ... } – Funktionskörper

Best Practices

✅ Beschreibende Namen verwenden
✅ Eine Funktion = Eine Aufgabe
✅ Typen immer explizit angeben
✅ Kurze, fokussierte Funktionen

Structs (Datenstrukturen)

Structs sind benutzerdefinierte Datentypen, die zusammengehörige Daten gruppieren. Sie sind das Fundament für Datenmodelle in deinen APIs – jeder User, jedes Produkt, jede Bestellung wird als Struct definiert.

Ein Struct definieren

// Definition eines User-Structs
struct User {
    id: string,
    name: string,
    email: string,
    age: number,
    isActive: boolean,
}

// Eine Instanz erstellen
let user = User {
    id: "user_123",
    name: "Anna Schmidt",
    email: "anna@example.com",
    age: 28,
    isActive: true,
};

// Auf Felder zugreifen
print(user.name);   // → "Anna Schmidt"
print(user.email);  // → "anna@example.com"

Praxisbeispiel: API Response

Structs werden automatisch zu JSON serialisiert, wenn du sie als API-Response zurückgibst:

@GET("/api/users/:id")
fn getUser(id: string): User {
    return User {
        id: id,
        name: "Anna Schmidt",
        email: "anna@example.com",
        age: 28,
        isActive: true,
    };
}

// API Response (automatisch als JSON):
// {
//   "id": "user_123",
//   "name": "Anna Schmidt",
//   "email": "anna@example.com",
//   "age": 28,
//   "isActive": true
// }

Kontrollstrukturen

Mit Kontrollstrukturen steuerst du den Ablauf deines Programms. Velisch bietet die klassischen Konstrukte plus das mächtige match für Pattern Matching.

If/Else – Bedingte Ausführung

fn checkAge(age: number): string {
    if (age >= 18) {
        return "Volljährig";
    } else if (age >= 16) {
        return "Fast volljährig";
    } else {
        return "Minderjährig";
    }
}

let status = checkAge(17);  // → "Fast volljährig"

For-Schleifen – Iteration

// Über eine Liste iterieren
let users = ["Anna", "Max", "Lisa"];

for (user in users) {
    print("Hallo, " + user);
}
// Ausgabe:
// Hallo, Anna
// Hallo, Max
// Hallo, Lisa

// Mit Index
for (i, user in users) {
    print(i + ": " + user);
}
// Ausgabe:
// 0: Anna
// 1: Max
// 2: Lisa

Match – Pattern Matching

match ist deutlich mächtiger als switch/case und ein Kernfeature von Velisch:

fn getStatusMessage(status: string): string {
    return match (status) {
        "pending" => "Wird bearbeitet...",
        "success" => "Erfolgreich abgeschlossen!",
        "error" => "Ein Fehler ist aufgetreten.",
        _ => "Unbekannter Status",  // Default-Fall
    };
}

let msg = getStatusMessage("success");
// → "Erfolgreich abgeschlossen!"

Zusammenfassung

Was du gelernt hast:

Variablen mit let und let mut
Funktionen mit fn und Typsignaturen
Structs für Datenmodelle
Kontrollstrukturen mit if/else, for und match

Nächste Schritte:

Lerne das erweiterte Typsystem kennen
Arbeite mit Collections (Lists, Maps)
Baue deine erste REST API

← Zur Übersicht Nächstes Tutorial: Syntax & Typen