Einleitung

TypeScript ist 2026 der Standard fuer professionelle JavaScript-Entwicklung. Ueber 90% aller neuen React-, Node.js- und Next.js-Projekte nutzen TypeScript. Und das aus gutem Grund: TypeScript findet Fehler bevor dein Code laeuft.

In diesem Tutorial lernst du TypeScript von Grund auf – mit vielen praktischen Beispielen.

Inhaltsverzeichnis

1. Was ist TypeScript?
2. Setup & Installation
3. Grundtypen
4. Interfaces & Type Aliases
5. Funktionen typisieren
6. Generics
7. Union Types & Literal Types
8. Utility Types
9. TypeScript mit React
10. Best Practices

1. Was ist TypeScript?

Vor allem für den praktischen Einsatz sind diese Informationen wertvoll.

TypeScript ist JavaScript mit Typen. Es wird von Microsoft entwickelt und zu normalem JavaScript kompiliert. Die Vorteile:

• Fehler frueh erkennen: Type-Checker findet Bugs beim Schreiben, nicht zur Laufzeit
• Bessere IDE-Unterstuetzung: Ferner autovervollstaendigung, Refactoring, Go-to-Definition
• Selbstdokumentierend: Ebenso typen sind lebende Dokumentation
• Sicheres Refactoring: Aenderungen propagieren sich durch die ganze Codebasis
• Ecosystem: Alle grossen Libraries haben TypeScript-Typen

// JavaScript – Fehler erst zur Laufzeit
function addiere(a, b) {
  return a + b;
}
addiere("5", 3); // "53" – kein Fehler, aber falsch!

// TypeScript – Fehler SOFORT im Editor
function addiere(a: number, b: number): number {
  return a + b;
}
addiere("5", 3); // ❌ Fehler: Argument of type 'string' is not assignable

Weiterhin ist es ratsam, die Ergebnisse immer kritisch zu prüfen.

2. Setup & Installation

Folglich profitierst du von einem besseren Verständnis dieser Konzepte.

# TypeScript global installieren
npm install -g typescript

# Version pruefen
tsc --version

# Neues Projekt erstellen
mkdir mein-ts-projekt
cd mein-ts-projekt
npm init -y
npm install typescript --save-dev

# tsconfig.json erstellen
npx tsc --init

Natürlich solltest du den generierten Code vor dem Einsatz testen.

tsconfig.json (empfohlene Einstellungen)

Zusammenfassend lässt sich sagen, dass dies ein zentraler Aspekt ist.

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "declaration": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Deshalb empfiehlt es sich, den Prompt schrittweise zu verfeinern.

# Kompilieren und ausfuehren
npx tsc                    # Kompiliert alle .ts Dateien
node dist/index.js         # Ausfuehren

# Oder mit ts-node (direkt ausfuehren)
npm install -D ts-node
npx ts-node src/index.ts

3. Grundtypen

Deshalb lohnt es sich, dieses Thema genauer zu betrachten.

// Primitive Typen
let name: string = "Metin";
let alter: number = 30;
let istEntwickler: boolean = true;
let nichts: null = null;
let unbestimmt: undefined = undefined;

// Arrays
let sprachen: string[] = ["TypeScript", "Python", "Go"];
let zahlen: number[] = [1, 2, 3];
let gemischt: (string | number)[] = ["text", 42];

// Tuple (feste Laenge und Typen)
let person: [string, number] = ["Metin", 30];

// Enum
enum Rolle {
  Admin = "ADMIN",
  User = "USER",
  Gast = "GAST"
}
let meineRolle: Rolle = Rolle.Admin;

// Any (Vorsicht! Deaktiviert Type-Checking)
let dynamisch: any = "text";
dynamisch = 42;  // Kein Fehler – aber das ist der Sinn von TS verloren

// Unknown (sichere Alternative zu any)
let eingabe: unknown = "text";
if (typeof eingabe === "string") {
  console.log(eingabe.toUpperCase());  // Nur nach Type-Check erlaubt
}

Dementsprechend ist eine manuelle Überprüfung empfehlenswert.

4. Interfaces & Type Aliases

Natürlich gibt es dabei verschiedene Herangehensweisen.

// Interface – beschreibt die Form eines Objekts
interface User {
  id: number;
  name: string;
  email: string;
  alter?: number;           // Optional (?)
  readonly erstelltAm: Date; // Nur lesbar
}

const user: User = {
  id: 1,
  name: "Metin",
  email: "metin@example.de",
  erstelltAm: new Date()
};

// Type Alias
type ID = string | number;

type Produkt = {
  id: ID;
  name: string;
  preis: number;
  kategorien: string[];
};

// Interface Extension (Vererbung)
interface Admin extends User {
  berechtigungen: string[];
  superAdmin: boolean;
}

const admin: Admin = {
  id: 1,
  name: "Metin",
  email: "metin@example.de",
  erstelltAm: new Date(),
  berechtigungen: ["users.manage", "posts.delete"],
  superAdmin: true
};

// Intersection Types
type MitTimestamp = {
  erstelltAm: Date;
  aktualisiertAm: Date;
};

type Artikel = Produkt & MitTimestamp;

Tatsächlich lässt sich dieser Code direkt in dein Projekt übernehmen.

5. Funktionen typisieren

Ebenfalls relevant sind die praktischen Anwendungsbeispiele.

// Grundlegende Funktion mit Typen
function addiere(a: number, b: number): number {
  return a + b;
}

// Arrow Function
const multipliziere = (a: number, b: number): number => a * b;

// Optional und Default Parameter
function begruessung(name: string, titel?: string): string {
  return titel ? `${titel} ${name}` : `Hallo ${name}`;
}

function berechneRabatt(preis: number, rabatt: number = 10): number {
  return preis * (1 - rabatt / 100);
}

// Rest Parameter
function summe(...zahlen: number[]): number {
  return zahlen.reduce((acc, z) => acc + z, 0);
}

// Function Overloads
function formatiere(wert: string): string;
function formatiere(wert: number): string;
function formatiere(wert: string | number): string {
  if (typeof wert === "string") return wert.trim();
  return wert.toFixed(2);
}

// Callback-Typen
function fetchDaten(
  url: string,
  callback: (daten: unknown, fehler?: Error) => void
): void {
  // ...
}

Grundsätzlich kannst du diesen Prompt an deine Bedürfnisse anpassen.

6. Generics

Weiterhin ist es wichtig, die Grundlagen zu verstehen.

Generics machen deinen Code wiederverwendbar und trotzdem typsicher:

// Ohne Generics – unflexibel
function erstesElement(arr: number[]): number {
  return arr[0];
}

// Mit Generics – funktioniert mit jedem Typ
function erstesElement<T>(arr: T[]): T | undefined {
  return arr[0];
}

erstesElement([1, 2, 3]);       // Typ: number
erstesElement(["a", "b"]);      // Typ: string

// Generisches Interface
interface ApiResponse<T> {
  data: T;
  status: number;
  message: string;
}

const userResponse: ApiResponse<User> = {
  data: { id: 1, name: "Metin", email: "m@x.de", erstelltAm: new Date() },
  status: 200,
  message: "OK"
};

// Generic Constraints
interface MitId {
  id: number;
}

function findeById<T extends MitId>(items: T[], id: number): T | undefined {
  return items.find(item => item.id === id);
}

// Generic Class
class Speicher<T> {
  private items: T[] = [];

  hinzufuegen(item: T): void { this.items.push(item); }
  alle(): T[] { return [...this.items]; }
  anzahl(): number { return this.items.length; }
}

7. Union Types & Literal Types

Außerdem gibt es hilfreiche Tools, die dich dabei unterstützen.

// Union Type
type Ergebnis = string | number | null;
type Status = "aktiv" | "inaktiv" | "geloescht";

// Literal Types – exakte Werte
type HttpMethode = "GET" | "POST" | "PUT" | "DELETE";
type Richtung = "links" | "rechts" | "oben" | "unten";

function httpAnfrage(url: string, methode: HttpMethode): void {
  // methode kann nur GET, POST, PUT oder DELETE sein
}

// Discriminated Unions – maechtig!
interface Kreis {
  art: "kreis";
  radius: number;
}

interface Rechteck {
  art: "rechteck";
  breite: number;
  hoehe: number;
}

type Form = Kreis | Rechteck;

function flaeche(form: Form): number {
  switch (form.art) {
    case "kreis":
      return Math.PI * form.radius ** 2;
    case "rechteck":
      return form.breite * form.hoehe;
  }
}

// Type Narrowing
function verarbeite(wert: string | number): string {
  if (typeof wert === "string") {
    return wert.toUpperCase();  // TS weiss: wert ist string
  }
  return wert.toFixed(2);       // TS weiss: wert ist number
}

Darüber hinaus lässt sich das Beispiel leicht erweitern.

8. Utility Types

Allerdings gibt es einige wichtige Unterschiede zu beachten.

TypeScript bietet eingebaute Utility Types die das Leben leichter machen:

interface User {
  id: number;
  name: string;
  email: string;
  passwort: string;
}

// Partial – alle Felder optional
type UserUpdate = Partial<User>;
// { id?: number; name?: string; email?: string; passwort?: string; }

// Required – alle Felder pflicht
type StrikterUser = Required<User>;

// Pick – nur bestimmte Felder
type UserPreview = Pick<User, "id" | "name">;
// { id: number; name: string; }

// Omit – Felder ausschliessen
type OeffentlicherUser = Omit<User, "passwort">;
// { id: number; name: string; email: string; }

// Record – Key-Value Map
type UserRollen = Record<string, string[]>;
const rollen: UserRollen = {
  admin: ["alles"],
  editor: ["posts.edit", "posts.create"],
  viewer: ["posts.read"]
};

// Readonly
type UnveraenderlicherUser = Readonly<User>;

// ReturnType
function erstelleUser() {
  return { id: 1, name: "Metin" };
}
type NeuerUser = ReturnType<typeof erstelleUser>;
// { id: number; name: string; }

Somit sparst du Zeit und erhältst qualitativ hochwertigeren Output.

9. TypeScript mit React

Dabei spielen mehrere Faktoren eine wichtige Rolle.

// Component Props typisieren
interface ButtonProps {
  label: string;
  onClick: () => void;
  variante?: "primary" | "secondary" | "danger";
  disabled?: boolean;
  kinder?: React.ReactNode;
}

const Button: React.FC<ButtonProps> = ({
  label,
  onClick,
  variante = "primary",
  disabled = false
}) => {
  return (
    <button
      className={`btn btn-${variante}`}
      onClick={onClick}
      disabled={disabled}
    >
      {label}
    </button>
  );
};

// useState mit Typen
const [user, setUser] = useState<User | null>(null);
const [items, setItems] = useState<string[]>([]);
const [count, setCount] = useState<number>(0);

// Event Handler
const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
  setName(e.target.value);
};

const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
  e.preventDefault();
  // ...
};

// Custom Hook mit Typen
function useFetch<T>(url: string): {
  data: T | null;
  loading: boolean;
  error: Error | null;
} {
  const [data, setData] = useState<T | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<Error | null>(null);

  useEffect(() => {
    fetch(url)
      .then(res => res.json())
      .then(setData)
      .catch(setError)
      .finally(() => setLoading(false));
  }, [url]);

  return { data, loading, error };
}

Dabei zeigt dieses Beispiel den grundlegenden Ansatz.

10. Best Practices

Im Folgenden findest du alle wichtigen Details dazu.

• Strict Mode aktivieren: "strict": true in tsconfig.json
• Kein any: Nutze unknown stattdessen
• Interface fuer Objekte: Zusätzlich type Alias fuer Unions und Primitives
• Generics nutzen: Ferner fuer wiederverwendbare Funktionen und Klassen
• Utility Types: Ebenfalls partial, Pick, Omit statt neue Interfaces
• Type Narrowing: typeof, instanceof, Discriminated Unions
• AI nutzen: GitHub Copilot generiert TypeScript-Typen automatisch

Naechste Schritte

Dennoch solltest du einige Besonderheiten beachten.

• Praxiskurs: Nimm einen TypeScript-Kurs auf Udemy
• React + TypeScript: Ebenso lerne React mit TypeScript im React-Kurs
• AI fuer TypeScript: Lies unseren Guide zu AI fuer TypeScript-Entwicklung
• REST APIs: Bau typsichere APIs mit unserem REST API Tutorial

Tipp: GitHub Copilot ist besonders stark mit TypeScript – es versteht deine Typen und generiert passenden Code. Zusammen mit VS Code hast du die beste TypeScript-Entwicklungsumgebung.

Der Beitrag TypeScript Tutorial fuer Anfaenger 2026 – Von JS zu TS erschien zuerst auf MetinCelik.de.

Einleitung

Docker hat die Art wie wir Software entwickeln und deployen revolutioniert. Container machen deine App ueberall lauffaehig – egal ob auf deinem Laptop, im CI/CD-System oder in der Cloud.

In diesem Tutorial lernst du Docker von Grund auf: Was sind Container? Wie schreibst du ein Dockerfile? Wie nutzt du Docker Compose fuer Multi-Container-Apps? Alles mit praktischen Beispielen.

Inhaltsverzeichnis

1. Was ist Docker?
2. Installation
3. Erste Container starten
4. Dockerfile schreiben
5. Images bauen und verwalten
6. Volumes & Persistenz
7. Docker Networking
8. Docker Compose
9. Best Practices
10. Naechste Schritte

1. Was ist Docker?

Somit kannst du direkt mit der Umsetzung beginnen.

Docker packt deine Anwendung zusammen mit allen Abhaengigkeiten in einen Container. Dieser Container laeuft ueberall identisch – kein „Works on my machine“ mehr.

• Image: Die Vorlage (Bauplan) fuer einen Container
• Container: Eine laufende Instanz eines Images
• Dockerfile: Das Rezept zum Bauen eines Images
• Registry: Speicherort fuer Images (Docker Hub, GitHub Container Registry)

Docker vs. Virtuelle Maschinen

Folglich profitierst du von einem besseren Verständnis dieser Konzepte.

2. Docker installieren

Windows & macOS

Im Grunde vereinfacht dieser Ansatz den gesamten Workflow erheblich.

Installiere Docker Desktop von docker.com. Enthaelt Docker Engine, CLI und Docker Compose.

Linux (Ubuntu)

Tatsächlich ist dieser Bereich besonders wichtig für Entwickler.

# Docker installieren
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Docker ohne sudo nutzen
sudo usermod -aG docker $USER

# Version pruefen
docker --version
docker compose version

Dementsprechend ist eine manuelle Überprüfung empfehlenswert.

3. Erste Container starten

Allerdings gibt es einige wichtige Unterschiede zu beachten.

# Hello World – teste ob Docker funktioniert
docker run hello-world

# Nginx Webserver starten
docker run -d -p 8080:80 --name mein-nginx nginx
# Oeffne http://localhost:8080 im Browser

# Laufende Container anzeigen
docker ps

# Alle Container anzeigen (auch gestoppte)
docker ps -a

# Container stoppen und entfernen
docker stop mein-nginx
docker rm mein-nginx

# In einen Container "reingehen"
docker run -it ubuntu bash
# Du bist jetzt in einem Ubuntu-Container!
# exit zum Verlassen

Folglich erhältst du mit diesem Ansatz deutlich bessere Resultate.

Wichtige Docker-Befehle

Natürlich gibt es dabei verschiedene Herangehensweisen.

# Images auflisten
docker images

# Image herunterladen
docker pull python:3.12

# Container-Logs anzeigen
docker logs mein-nginx

# Container-Details
docker inspect mein-nginx

# Alle gestoppten Container entfernen
docker container prune

# Alle ungenutzten Images entfernen
docker image prune -a

Natürlich solltest du den generierten Code vor dem Einsatz testen.

4. Dockerfile schreiben

Grundsätzlich gibt es dabei einige Punkte zu beachten.

Ein Dockerfile definiert wie dein Image gebaut wird. Hier ein Beispiel fuer eine Python Flask App:

# Dockerfile
FROM python:3.12-slim

# Arbeitsverzeichnis setzen
WORKDIR /app

# Dependencies zuerst kopieren (Docker Layer Caching)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# App-Code kopieren
COPY . .

# Port freigeben
EXPOSE 5000

# App starten
CMD ["python", "app.py"]

Und fuer eine Node.js Express App:

# Dockerfile
FROM node:20-alpine

WORKDIR /app

# Package Files zuerst (Caching!)
COPY package*.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 3000

# Non-Root User (Security!)
USER node

CMD ["node", "server.js"]

Grundsätzlich kannst du diesen Prompt an deine Bedürfnisse anpassen.

Image bauen und starten

Dennoch solltest du einige Besonderheiten beachten.

# Image bauen
docker build -t meine-app:1.0 .

# Container starten
docker run -d -p 3000:3000 --name app meine-app:1.0

# Image taggen und pushen
docker tag meine-app:1.0 username/meine-app:1.0
docker push username/meine-app:1.0

Außerdem kannst du den Prompt für verschiedene Programmiersprachen anpassen.

5. Volumes – Daten persistent speichern

Darüber hinaus bietet dieser Abschnitt konkrete Beispiele und Tipps.

Container sind ephemeral – wenn du sie loeschst, sind die Daten weg. Volumes speichern Daten ausserhalb des Containers:

# Named Volume erstellen
docker volume create app-daten

# Container mit Volume starten
docker run -d \
  -v app-daten:/data \
  --name db \
  postgres:16

# Bind Mount (lokaler Ordner)
docker run -d \
  -v $(pwd)/src:/app/src \
  -p 3000:3000 \
  meine-app:1.0

# Volumes auflisten
docker volume ls

Dabei zeigt dieses Beispiel den grundlegenden Ansatz.

6. Docker Networking

Weiterhin ist es wichtig, die Grundlagen zu verstehen.

# Netzwerk erstellen
docker network create mein-netzwerk

# Container im gleichen Netzwerk
docker run -d --network mein-netzwerk --name api meine-api
docker run -d --network mein-netzwerk --name db postgres:16

# Container "api" kann jetzt "db" per Hostname erreichen:
# postgres://db:5432/mydb

7. Docker Compose – Multi-Container-Apps

Insbesondere für den Einstieg sind die folgenden Informationen hilfreich.

Docker Compose definiert Multi-Container-Apps in einer YAML-Datei. Hier ein komplettes Beispiel:

# docker-compose.yml
version: '3.8'

services:
  # Frontend (React)
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    depends_on:
      - api
    environment:
      - REACT_APP_API_URL=http://localhost:5000

  # Backend API (Python Flask)
  api:
    build: ./backend
    ports:
      - "5000:5000"
    depends_on:
      - db
      - redis
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
      - REDIS_URL=redis://redis:6379
    volumes:
      - ./backend:/app  # Hot Reload fuer Development

  # Datenbank
  db:
    image: postgres:16
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - postgres-data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  # Cache
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres-data:

Weiterhin ist es ratsam, die Ergebnisse immer kritisch zu prüfen.

Docker Compose Befehle

Ebenfalls relevant sind die praktischen Anwendungsbeispiele.

# Alle Services starten
docker compose up -d

# Logs anzeigen
docker compose logs -f

# Status anzeigen
docker compose ps

# Alle Services stoppen
docker compose down

# Stoppen und Volumes loeschen
docker compose down -v

# Nur einen Service neustarten
docker compose restart api

# Images neu bauen
docker compose build

Somit sparst du Zeit und erhältst qualitativ hochwertigeren Output.

8. Docker Best Practices

Ebenso wichtig ist es, die Best Practices zu kennen.

• Kleine Base Images: Nutze -alpine oder -slim Varianten
• Multi-Stage Builds: Zusätzlich trenne Build- und Runtime-Umgebung
• Non-Root User: Ebenfalls fuehre Container nie als Root aus
• Layer Caching: Besonders cOPY package.json VOR dem App-Code
• .dockerignore: Schliesse node_modules, .git, .env aus
• Health Checks: Definiere HEALTHCHECK im Dockerfile
• Keine Secrets im Image: Nutze Environment Variables oder Docker Secrets

Multi-Stage Build Beispiel

Außerdem gibt es hilfreiche Tools, die dich dabei unterstützen.

# Stage 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Deshalb empfiehlt es sich, den Prompt schrittweise zu verfeinern.

Ergebnis: Ein winziges Nginx-Image mit nur den statischen Build-Dateien statt eines grossen Node.js-Images.

9. Naechste Schritte

Deshalb lohnt es sich, dieses Thema genauer zu betrachten.

• Kubernetes lernen: Nimm einen Docker/Kubernetes Kurs
• CI/CD: Ebenfalls nutze Docker in CI/CD Pipelines mit GitHub Actions
• Cloud Deployment: Deploye auf AWS ECS, Google Cloud Run oder AWS
• AI-Tools: Lass ChatGPT oder GitHub Copilot Dockerfiles fuer dich generieren

Profi-Tipp: Nutze AI-Tools wie ChatGPT Plus um Dockerfiles und docker-compose.yml Dateien zu generieren. Beschreibe einfach deinen Tech-Stack und du bekommst eine optimierte Konfiguration.

Der Beitrag Docker Tutorial fuer Anfaenger 2026 – Container verstehen erschien zuerst auf MetinCelik.de.

Einleitung

Git ist das wichtigste Werkzeug fuer jeden Entwickler. Egal ob du alleine oder im Team arbeitest – ohne Versionskontrolle geht nichts. In diesem Tutorial lernst du Git von der Installation bis zum professionellen Workflow mit Branches, Merges und Pull Requests.

Inhaltsverzeichnis

1. Was ist Git?
2. Installation
3. Grundbefehle
4. Branches
5. GitHub & Remote Repos
6. Professioneller Workflow
7. Merge-Konflikte loesen
8. Profi-Tipps
9. Git Cheat Sheet

1. Was ist Git?

Grundsätzlich gibt es dabei einige Punkte zu beachten.

Git ist ein verteiltes Versionskontrollsystem. Es speichert jeden Aenderungsstand deines Codes als „Commit“ – du kannst jederzeit zu einem frueheren Stand zurueckkehren, parallel an Features arbeiten und mit anderen Entwicklern zusammenarbeiten.

• Versionskontrolle: Jede Aenderung wird gespeichert
• Branches: Darüber hinaus parallel an verschiedenen Features arbeiten
• Zusammenarbeit: Mit Teams ueber GitHub, GitLab, Bitbucket
• Backup: Dein Code ist sicher in der Cloud
• Standard: 95%+ aller Software-Projekte nutzen Git

2. Installation

Windows

Vor allem für den praktischen Einsatz sind diese Informationen wertvoll.

# Git for Windows herunterladen
# https://git-scm.com/download/win
# Oder mit winget:
winget install Git.Git

Insbesondere die Struktur des Prompts ist dabei entscheidend für gute Ergebnisse.

macOS

Dementsprechend solltest du die folgenden Aspekte kennen.

brew install git

Außerdem kannst du den Prompt für verschiedene Programmiersprachen anpassen.

Linux

Weiterhin ist es wichtig, die Grundlagen zu verstehen.

sudo apt install git

Weiterhin ist es ratsam, die Ergebnisse immer kritisch zu prüfen.

Konfiguration

Insbesondere für den Einstieg sind die folgenden Informationen hilfreich.

# Name und E-Mail setzen (wird in Commits angezeigt)
git config --global user.name "Dein Name"
git config --global user.email "deine@email.de"

# Default Branch auf "main" setzen
git config --global init.defaultBranch main

# Konfiguration pruefen
git config --list

3. Grundbefehle

Repository erstellen

Natürlich gibt es dabei verschiedene Herangehensweisen.

# Neues Git-Repository erstellen
mkdir mein-projekt
cd mein-projekt
git init

# Oder bestehendes Repository klonen
git clone https://github.com/user/repo.git

Dementsprechend ist eine manuelle Überprüfung empfehlenswert.

Dateien tracken und committen

Dabei spielen mehrere Faktoren eine wichtige Rolle.

# Status anzeigen
git status

# Datei zum Staging hinzufuegen
git add index.html
git add .              # Alle Dateien hinzufuegen

# Commit erstellen
git commit -m "Erste Version der Webseite"

# Commit-History anzeigen
git log
git log --oneline      # Kompakte Ansicht
git log --graph        # Mit Branch-Grafik

Folglich erhältst du mit diesem Ansatz deutlich bessere Resultate.

Aenderungen rueckgaengig machen

Folglich profitierst du von einem besseren Verständnis dieser Konzepte.

# Unstaged Aenderungen verwerfen
git checkout -- datei.txt
git restore datei.txt          # Neue Syntax

# Staging rueckgaengig (Datei bleibt geaendert)
git reset HEAD datei.txt
git restore --staged datei.txt # Neue Syntax

# Letzten Commit aendern
git commit --amend -m "Korrigierte Nachricht"

# Commit rueckgaengig (neuer Revert-Commit)
git revert abc1234

Natürlich solltest du den generierten Code vor dem Einsatz testen.

4. Branches – Parallel arbeiten

Im Grunde vereinfacht dieser Ansatz den gesamten Workflow erheblich.

Branches sind das maechtigste Feature von Git. Damit arbeitest du an Features, ohne den Hauptcode zu beruehren:

# Alle Branches anzeigen
git branch

# Neuen Branch erstellen und wechseln
git checkout -b feature/login
# Oder neue Syntax:
git switch -c feature/login

# Zwischen Branches wechseln
git switch main
git switch feature/login

# Branch mergen
git switch main
git merge feature/login

# Branch loeschen
git branch -d feature/login

Branch-Namenskonventionen

Im Folgenden findest du alle wichtigen Details dazu.

5. GitHub & Remote Repositories

Ebenfalls relevant sind die praktischen Anwendungsbeispiele.

# Remote hinzufuegen
git remote add origin https://github.com/user/repo.git

# Zum Remote pushen
git push -u origin main        # Erster Push
git push                        # Danach reicht das

# Aenderungen vom Remote holen
git pull                        # Fetch + Merge
git fetch                       # Nur holen, nicht mergen

# Remote Branches anzeigen
git branch -r

Somit sparst du Zeit und erhältst qualitativ hochwertigeren Output.

SSH-Key einrichten (empfohlen)

Allerdings gibt es einige wichtige Unterschiede zu beachten.

# SSH-Key generieren
ssh-keygen -t ed25519 -C "deine@email.de"

# Public Key anzeigen und auf GitHub einfuegen
cat ~/.ssh/id_ed25519.pub
# -> GitHub Settings -> SSH and GPG Keys -> New SSH Key

Dabei zeigt dieses Beispiel den grundlegenden Ansatz.

6. Professioneller Git-Workflow

Darüber hinaus bietet dieser Abschnitt konkrete Beispiele und Tipps.

So arbeiten professionelle Teams mit Git:

1. Branch erstellen: git switch -c feature/neues-feature
2. Code schreiben: Aenderungen machen und testen
3. Commits machen: Kleine, logische Commits mit guten Messages
4. Pushen: git push -u origin feature/neues-feature
5. Pull Request erstellen: Auf GitHub/GitLab einen PR oeffnen
6. Code Review: Team-Mitglieder pruefen den Code
7. Merge: Nach Approval wird der PR gemerged
8. Branch loeschen: Feature-Branch aufraenmen

Gute Commit-Messages

Ebenso wichtig ist es, die Best Practices zu kennen.

# SCHLECHT ❌
git commit -m "fix"
git commit -m "update"
git commit -m "stuff"

# GUT ✅
git commit -m "feat: Login-Formular mit Validierung hinzugefuegt"
git commit -m "fix: Passwort-Reset Email wird jetzt korrekt gesendet"
git commit -m "docs: README mit Setup-Anleitung aktualisiert"
git commit -m "refactor: User-Service in eigenes Modul ausgelagert"

Grundsätzlich kannst du diesen Prompt an deine Bedürfnisse anpassen.

Folge der Conventional Commits Konvention: type: beschreibung

7. Merge-Konflikte loesen

Somit kannst du direkt mit der Umsetzung beginnen.

Merge-Konflikte entstehen wenn zwei Branches die gleiche Stelle aendern:

# Konflikt sieht so aus:
<<<<<<< HEAD
const titel = "Alt";
=======
const titel = "Neu";
>>>>>>> feature/neuer-titel

# Loesung:
# 1. Datei oeffnen
# 2. Konflikt-Markierungen entfernen
# 3. Gewuenschten Code behalten
# 4. Datei speichern
# 5. git add und git commit

const titel = "Neu";  # Entscheidung treffen

git add datei.js
git commit -m "fix: Merge-Konflikt in titel geloest"

Tipp: Nutze AI-Tools um Merge-Konflikte zu verstehen und zu loesen. GitHub Copilot kann Konflikte direkt in VS Code analysieren.

8. Profi-Tipps

.gitignore einrichten

Tatsächlich ist dieser Bereich besonders wichtig für Entwickler.

# .gitignore
node_modules/
.env
*.log
dist/
.DS_Store
__pycache__/
.vscode/settings.json

Vor allem die detaillierten Anweisungen sorgen für präzisere Ergebnisse.

Git Stash – Aenderungen zwischenspeichern

Deshalb lohnt es sich, dieses Thema genauer zu betrachten.

# Aenderungen zwischenspeichern
git stash

# Zwischengespeichertes wiederherstellen
git stash pop

# Stash-Liste anzeigen
git stash list

Tatsächlich lässt sich dieser Code direkt in dein Projekt übernehmen.

Git Aliases

Dennoch solltest du einige Besonderheiten beachten.

git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.st status
git config --global alias.lg "log --oneline --graph --all"

# Jetzt: git st statt git status

Darüber hinaus lässt sich das Beispiel leicht erweitern.

9. Git Cheat Sheet

Zusammenfassend lässt sich sagen, dass dies ein zentraler Aspekt ist.

Naechste Schritte

Außerdem gibt es hilfreiche Tools, die dich dabei unterstützen.

• Git-Workflow vertiefen: Lies unseren Artikel Git Workflow mit AI
• GitHub Actions: Insbesondere automatisiere Tests und Deployments mit CI/CD und AI
• AI-Tools: Nutze GitHub Copilot fuer bessere Commit-Messages und Branch-Management

Der Beitrag Git Tutorial fuer Anfaenger 2026 – Alle wichtigen Befehle erschien zuerst auf MetinCelik.de.

Einleitung

Du willst Python lernen? Gute Entscheidung! Python ist die vielseitigste und einsteigerfreundlichste Programmiersprache 2026. In diesem Tutorial lernst du Python von der Installation bis zum ersten eigenen Projekt – Schritt fuer Schritt.

Dieses Tutorial richtet sich an absolute Anfaenger. Du brauchst keinerlei Programmiererfahrung.

Inhaltsverzeichnis

1. Python installieren
2. Erste Schritte & Hello World
3. Variablen und Datentypen
4. If-Else und Schleifen
5. Funktionen
6. Listen, Dictionaries & Tuples
7. Objektorientierte Programmierung
8. Dateien lesen und schreiben
9. Pakete und pip
10. Dein erstes Projekt
11. Naechste Schritte

1. Python installieren

Windows

Vor allem für den praktischen Einsatz sind diese Informationen wertvoll.

1. Gehe zu python.org/downloads
2. Lade die neueste Version herunter (Python 3.12+)
3. Wichtig: Setze den Haken bei „Add Python to PATH“
4. Klicke „Install Now“

macOS

Insbesondere für den Einstieg sind die folgenden Informationen hilfreich.

# Mit Homebrew (empfohlen)
brew install python

# Version pruefen
python3 --version

Vor allem die detaillierten Anweisungen sorgen für präzisere Ergebnisse.

Linux (Ubuntu/Debian)

Dabei spielen mehrere Faktoren eine wichtige Rolle.

sudo apt update
sudo apt install python3 python3-pip python3-venv

Dabei zeigt dieses Beispiel den grundlegenden Ansatz.

Editor einrichten

Folglich profitierst du von einem besseren Verständnis dieser Konzepte.

Installiere Visual Studio Code als Editor:

1. Lade VS Code herunter
2. Installiere die Python Extension (von Microsoft)
3. Optional: GitHub Copilot fuer AI-Unterstuetzung beim Coden

2. Erste Schritte: Hello World

Im Folgenden findest du alle wichtigen Details dazu.

Erstelle eine neue Datei hello.py und schreibe:

# Dein erstes Python-Programm
print("Hallo Welt!")
print("Ich lerne Python 🐍")

# Einfache Berechnung
ergebnis = 42 + 8
print(f"42 + 8 = {ergebnis}")

Somit sparst du Zeit und erhältst qualitativ hochwertigeren Output.

Fuehre es aus mit:

python hello.py

Ausgabe:

Hallo Welt!
Ich lerne Python 🐍
42 + 8 = 50

Grundsätzlich kannst du diesen Prompt an deine Bedürfnisse anpassen.

3. Variablen und Datentypen

Dennoch solltest du einige Besonderheiten beachten.

Python erkennt den Datentyp automatisch – du musst ihn nicht angeben:

# Strings (Text)
name = "Metin"
beruf = 'Entwickler'

# Zahlen
alter = 30           # Integer (Ganzzahl)
gehalt = 75000.50    # Float (Kommazahl)

# Boolean (Wahr/Falsch)
ist_entwickler = True
hat_erfahrung = False

# None (kein Wert)
projekt = None

# Typ pruefen
print(type(name))      # <class 'str'>
print(type(alter))     # <class 'int'>
print(type(gehalt))    # <class 'float'>
print(type(ist_entwickler))  # <class 'bool'>

Dementsprechend ist eine manuelle Überprüfung empfehlenswert.

String-Operationen

Zusammenfassend lässt sich sagen, dass dies ein zentraler Aspekt ist.

# f-Strings (Python 3.6+)
print(f"Hallo, ich bin {name} und {alter} Jahre alt.")

# String-Methoden
text = "Python ist toll"
print(text.upper())        # PYTHON IST TOLL
print(text.lower())        # python ist toll
print(text.replace("toll", "super"))  # Python ist super
print(len(text))           # 15
print(text.split(" "))     # ['Python', 'ist', 'toll']

Im Grunde funktioniert dieser Ansatz mit allen gängigen AI-Tools.

4. If-Else und Schleifen

If-Else Bedingungen

Grundsätzlich gibt es dabei einige Punkte zu beachten.

alter = 25

if alter < 18:
    print("Minderjaehrig")
elif alter < 65:
    print("Erwachsen")
else:
    print("Rentner")

# Kurzform
status = "Senior" if alter >= 60 else "Junior"

For-Schleife

Tatsächlich ist dieser Bereich besonders wichtig für Entwickler.

# Ueber Liste iterieren
sprachen = ["Python", "JavaScript", "TypeScript"]
for sprache in sprachen:
    print(f"Ich lerne {sprache}")

# Mit Index
for i, sprache in enumerate(sprachen):
    print(f"{i+1}. {sprache}")

# Range
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4

for i in range(1, 11):
    print(f"{i} x 7 = {i * 7}")

Darüber hinaus lässt sich das Beispiel leicht erweitern.

While-Schleife

Ebenso wichtig ist es, die Best Practices zu kennen.

zaehler = 0
while zaehler < 5:
    print(f"Durchlauf {zaehler}")
    zaehler += 1

Insbesondere die Struktur des Prompts ist dabei entscheidend für gute Ergebnisse.

5. Funktionen

Somit kannst du direkt mit der Umsetzung beginnen.

# Einfache Funktion
def begruessung(name):
    return f"Hallo {name}!"

print(begruessung("Metin"))  # Hallo Metin!

# Funktion mit Default-Parameter
def berechne_rabatt(preis, rabatt=10):
    return preis * (1 - rabatt / 100)

print(berechne_rabatt(100))       # 90.0
print(berechne_rabatt(100, 25))   # 75.0

# Mehrere Rueckgabewerte
def statistiken(zahlen):
    return min(zahlen), max(zahlen), sum(zahlen) / len(zahlen)

minimum, maximum, durchschnitt = statistiken([10, 20, 30, 40])
print(f"Min: {minimum}, Max: {maximum}, Avg: {durchschnitt}")

# Lambda-Funktionen
quadrat = lambda x: x ** 2
print(quadrat(5))  # 25

Folglich erhältst du mit diesem Ansatz deutlich bessere Resultate.

6. Listen, Dictionaries & Tuples

Listen

Im Grunde vereinfacht dieser Ansatz den gesamten Workflow erheblich.

# Listen erstellen
tools = ["VS Code", "GitHub Copilot", "Docker", "Git"]

# Zugriff
print(tools[0])     # VS Code
print(tools[-1])    # Git
print(tools[1:3])   # ['GitHub Copilot', 'Docker']

# Aendern
tools.append("Cursor IDE")
tools.insert(0, "PyCharm")
tools.remove("Git")

# List Comprehension
zahlen = [1, 2, 3, 4, 5]
quadrate = [x**2 for x in zahlen]
gerade = [x for x in zahlen if x % 2 == 0]
print(quadrate)  # [1, 4, 9, 16, 25]
print(gerade)    # [2, 4]

Dictionaries

Deshalb lohnt es sich, dieses Thema genauer zu betrachten.

# Dictionary erstellen
entwickler = {
    "name": "Metin",
    "sprachen": ["Python", "JavaScript", "TypeScript"],
    "erfahrung_jahre": 5,
    "freelancer": True
}

# Zugriff
print(entwickler["name"])           # Metin
print(entwickler.get("gehalt", 0))  # 0 (Default)

# Aendern und hinzufuegen
entwickler["stadt"] = "Berlin"
entwickler["erfahrung_jahre"] = 6

# Iterieren
for key, value in entwickler.items():
    print(f"{key}: {value}")

Natürlich solltest du den generierten Code vor dem Einsatz testen.

7. Objektorientierte Programmierung

Weiterhin ist es wichtig, die Grundlagen zu verstehen.

class Entwickler:
    def __init__(self, name, sprache, erfahrung=0):
        self.name = name
        self.sprache = sprache
        self.erfahrung = erfahrung
        self.projekte = []

    def neues_projekt(self, projekt_name):
        self.projekte.append(projekt_name)
        print(f"{self.name} arbeitet jetzt an: {projekt_name}")

    def profil(self):
        return (f"{self.name} | {self.sprache} | "
                f"{self.erfahrung} Jahre | "
                f"{len(self.projekte)} Projekte")

    def __str__(self):
        return self.profil()


# Vererbung
class FullStackEntwickler(Entwickler):
    def __init__(self, name, frontend, backend, erfahrung=0):
        super().__init__(name, f"{frontend} + {backend}", erfahrung)
        self.frontend = frontend
        self.backend = backend


# Objekte erstellen
dev = Entwickler("Metin", "Python", 5)
dev.neues_projekt("AI Chatbot")
dev.neues_projekt("REST API")
print(dev)

fullstack = FullStackEntwickler("Anna", "React", "Node.js", 3)
print(fullstack)

Tatsächlich lässt sich dieser Code direkt in dein Projekt übernehmen.

8. Dateien lesen und schreiben

Allerdings gibt es einige wichtige Unterschiede zu beachten.

# Datei schreiben
with open("notizen.txt", "w") as f:
    f.write("Python Tutorial\n")
    f.write("Heute gelernt: Variablen, Listen, Funktionen\n")

# Datei lesen
with open("notizen.txt", "r") as f:
    inhalt = f.read()
    print(inhalt)

# JSON lesen und schreiben
import json

daten = {
    "name": "Metin",
    "skills": ["Python", "JavaScript"],
    "level": "Fortgeschritten"
}

# JSON schreiben
with open("profil.json", "w") as f:
    json.dump(daten, f, indent=2)

# JSON lesen
with open("profil.json", "r") as f:
    geladen = json.load(f)
    print(geladen["name"])  # Metin

Deshalb empfiehlt es sich, den Prompt schrittweise zu verfeinern.

9. Pakete mit pip installieren

Darüber hinaus bietet dieser Abschnitt konkrete Beispiele und Tipps.

# Virtual Environment erstellen (Best Practice!)
python -m venv mein_projekt
source mein_projekt/bin/activate  # Linux/Mac
# mein_projekt\Scripts\activate   # Windows

# Pakete installieren
pip install requests
pip install flask
pip install pandas

# Installierte Pakete anzeigen
pip list

# Requirements speichern
pip freeze > requirements.txt

# Requirements installieren (anderer Rechner)
pip install -r requirements.txt

Die wichtigsten Python-Pakete:

10. Dein erstes Projekt: Wetter-App

Außerdem gibt es hilfreiche Tools, die dich dabei unterstützen.

Lass uns eine einfache Wetter-App bauen, die das aktuelle Wetter fuer eine Stadt anzeigt:

import requests
import json

def wetter_abfragen(stadt):
    """Wetter fuer eine Stadt abfragen (OpenWeatherMap API)"""
    api_key = "DEIN_API_KEY"  # kostenlos auf openweathermap.org
    url = f"http://api.openweathermap.org/data/2.5/weather"
    params = {
        "q": stadt,
        "appid": api_key,
        "units": "metric",
        "lang": "de"
    }

    response = requests.get(url, params=params)

    if response.status_code == 200:
        daten = response.json()
        return {
            "stadt": daten["name"],
            "temperatur": daten["main"]["temp"],
            "beschreibung": daten["weather"][0]["description"],
            "luftfeuchtigkeit": daten["main"]["humidity"],
            "wind": daten["wind"]["speed"]
        }
    else:
        return None

def main():
    print("🌤  Python Wetter-App")
    print("=" * 30)

    stadt = input("Stadt eingeben: ")
    wetter = wetter_abfragen(stadt)

    if wetter:
        print(f"\n📍 {wetter['stadt']}")
        print(f"🌡  {wetter['temperatur']}°C")
        print(f"☁  {wetter['beschreibung']}")
        print(f"💧 Luftfeuchtigkeit: {wetter['luftfeuchtigkeit']}%")
        print(f"💨 Wind: {wetter['wind']} m/s")
    else:
        print("Stadt nicht gefunden!")

if __name__ == "__main__":
    main()

Außerdem kannst du den Prompt für verschiedene Programmiersprachen anpassen.

11. Naechste Schritte

Dementsprechend solltest du die folgenden Aspekte kennen.

Du hast die Python-Grundlagen gelernt! So geht es weiter:

• Vertiefung: Nimm einen Python-Kurs auf Udemy fuer strukturiertes Lernen
• Web-Development: Lerne Flask oder FastAPI fuer Backend-Entwicklung
• Data Science: Lerne Pandas und NumPy fuer Datenanalyse
• Automatisierung: Automatisiere langweilige Aufgaben mit Python Scripts
• AI-Tools nutzen: Verwende GitHub Copilot und ChatGPT beim Programmieren
• Projekte: Bau eigene Projekte – das ist der beste Weg zum Lernen

Tipp: Nutze GitHub Copilot in VS Code waehrend du lernst. Der AI-Assistent schlaegt Code vor und erklaert Konzepte. Zusammen mit einem strukturierten Udemy-Kurs lernst du am schnellsten.

Zusammenfassung: Python Cheat Sheet

Ebenfalls relevant sind die praktischen Anwendungsbeispiele.

Der Beitrag Python Tutorial fuer Anfaenger 2026 – Schritt fuer Schritt erschien zuerst auf MetinCelik.de.

heute fange ich mit einen „HTML Tutorial für Anfänger“ zu schreiben. Mit HTML kann man eigene Webseiten erstellen. Diese Tutorial wird einiges über HTML beibringen. HTML ist einfach zu erlernen. In jedem Kapitel werde ich euch einige Beispiele präsentieren, damit ihr selb per Copy&Paste die Codebeispiele kopieren und in eurem HTML Editor testen und bearbeiten könnt.

< !DOCTYPE html>
<html>
<body>
<h1>Überschrift</h1>
<p>Absetz</p>
</body>
</html>

Also viel Spass damit!
1. HTML Einführung

Der Beitrag HTML Tutorial für Anfänger erschien zuerst auf MetinCelik.de.