Files
uni/slides/dhbw/02_css_extended.md
T
libretech 4053185e74 dhbw phase 4: alle 8 kapitel slide-MD komplett (4176 zeilen → ~1100 zeilen, ~210 slides total)
kap1 web_eng (104 → 57 slides): kurs-intro + prüfungsleistung-übersicht, internet-timeline (4 milestones), URL→pixel-7-schritte, HTTP, onboarding (node 24 LTS via fnm, brew/winget paket-manager, VS Code/Chromium/Hoppscotch, git setup mit SSH-key, projekt-skeleton), HTML (anatomie, self-closing, grundgerüst, semantik-tabelle, native elemente details/dialog/input-types), A11y volle tiefe (BFSG+EAA 28.06.2025, WCAG-POUR, Perceivable/Operable/Understandable/Robust einzeln mit code, testen mit lighthouse/axe/manuell), CSS-vorschau (anatomie/selektoren/spezifizität/box-model/farben/einheiten/pseudos), JS-vorschau (ECMAScript-timeline/grundlagen/DOM/fetch), frameworks-übersicht (react/vue/svelte/astro counter-vergleich), build-tools/rendering-modi, selbstlernen erste-eigene-seite

kap2 css_extended (13 → 28 slides): box-model + box-sizing global, flexbox basics+achsen+item-properties+typische-patterns, grid basics+areas+auto-layout, flexbox-vs-grid tabelle, mobile-first media queries, viewport-meta, fluid sizing mit clamp(), transitions (was performant), keyframe-animationen, prefers-reduced-motion pflicht, CSS-variablen + dark-mode-pattern, CSS functions (calc/clamp/gradient/oklch/filter), CSS-frameworks tabelle + tailwind pro/contra, selbstlernen flexboxfroggy+cssgridgarden

kap3 nodejs_basics (~22 → 20 slides): was-ist-node + warum-node-tabelle, fnm versions-manager + node 24 LTS + .nvmrc, npm init + package.json (mit type:module), ESM modern + CJS legacy, built-in modules (node: prefix), HTTP-server eingebaut + express, REST mit express (GET/POST/PUT/DELETE-pattern), alternative frameworks tabelle (fastify/hono/koa), routing-pattern mit Router, fetch global ab node 18, error-handling res.ok, environment variables mit dotenv + niemals committen, selbstlernen mini-API

kap4 nodejs_advanced (~24 → 22 slides): synchron-vs-asynchron, promise then-vs-async/await, sequenziell-vs-parallel + Promise.all, promise-methoden tabelle (all/allSettled/race/any), fs/promises lesen+schreiben, streams pipeline für große dateien, DB-übersicht SQLite/Postgres/MongoDB/Redis, better-sqlite3 prepared statements, ORM-übersicht (drizzle/prisma/knex), CRUD-pattern express+sqlite, auth-strategien tabelle, bcrypt für passwörter, JWT-pattern mit httpOnly+secure cookie, try/catch + error-klassen, globaler express-error-handler, selbstlernen REST+DB+auth

kap5 testing (~23 → 23 slides): test-pyramide 70%/20%/10%, vitest setup + describe/it/expect, AAA-pattern, matchers tabelle, TDD red-green-refactor mit konkretem beispiel, supertest für API-integration, test-DB :memory: + lifecycle hooks, mocking mit vi.spyOn (sparsam), playwright E2E mit role-based-locators, E2E-vs-unit tradeoffs, coverage realistisch (80% gut), CI mit github-actions, selbstlernen tests-schreiben

kap6 typescript (~30 → 19 slides): was-ist-TS + warum-tabelle, setup mit tsx + tsconfig.json + strict:true, basis-typen + any vermeiden, object-typen + interfaces + type-aliases, function-typen (Promise<T>), union + discriminated union + intersection, generics + constraints, built-in generics (Partial/Omit/Record), typ-inference (nicht über-annotieren), typen für REST-API mit express, zod runtime-validation + z.infer, any-vs-unknown-vs-never, best practices, selbstlernen API-zu-TS-migration

kap7 docker (~24 → 24 slides): auf-meinem-rechner-läufts problem, container-vs-VM tabelle, docker basics (image/container/dockerfile/registry), dockerfile hallo-welt, schichten + cache-optimierung, multi-stage build, base-image-größen tabelle (alpine ~180MB vs node ~1.1GB), .dockerignore, compose.yml beispiel, compose-commands, networking (service-namen als hostnamen), volumes (named vs bind), env+secrets, github-actions docker-build, registry-übersicht, health-checks, best-practices, selbstlernen app-dockerizen

kap8 best_practices (~30 → 28 slides): sinnvolle commits + conventional commits format, .gitignore template, branches+PRs workflow, README-template mit 6 sektionen, SOLID 5 prinzipien tabelle, S-single-responsibility + D-dependency-inversion mit code, 12-factor wichtigste (codebase/deps/config/processes/disposability), factor 3 config-in-env, factor 6 stateless-processes, SemVer MAJOR.MINOR.PATCH, package.json caret/tilde/exakt, code-reviews geben+nehmen + checkliste, doku-quellen tabelle (MDN/nodejs/npm/tc39/caniuse), stack-overflow gut-nutzen, AI-assistenten pro/contra (verstehen-nicht-kopieren), selbstlernen projekt-hygiene-check

build geht durch alle 8 kapitel-html+pdf
render-spot-check: cover-slide-dark-mode-invert, git-setup code-syntax-highlight, css-anatomie code-blocks — alle sauber

kein deploy, nur build+verify
2026-05-14 17:14:02 +02:00

9.6 KiB
Raw Blame History

marp, theme, paginate, backgroundColor, header, footer
marp theme paginate backgroundColor header footer
true gaia true Web Engineering – DHBW Stuttgart Michael Czechowski – SoSe 2026
<style> :root { --color-foreground: #1a1a2e; --color-highlight: #d63384; --color-dimmed: #4a4a6a; } section.invert { --color-foreground: #fff; } section { font-size: 1.4rem; } h1 { color: #a02060; } section.invert h1 { color: #fff; } h2 { color: #1f2937; } section.invert h2 { color: #f48fb1; } pre { background: #0f0f23; color: #f48fb1; border-radius: 8px; border-left: 3px solid #d63384; } pre code { background: transparent; color: inherit; } code { background: #1a1a2e; color: #f48fb1; padding: 0.15em 0.4em; border-radius: 4px; } a { color: var(--color-highlight); } </style>

Kapitel 2 — CSS Extended

Box-Model · Flexbox · Grid · Responsive · Animations


Recap Kap 1

Bereich Was wir kennen
Anatomie selector { property: value }
Selektoren element, .class, #id, :hover
Spezifizität inline > id > class > element
Farben hex, rgb, hsl, oklch
Einheiten px, rem, em, %, vw, vh

Heute: Layout + Animation in Tiefe.


Box-Model — die Erinnerung

┌──────────────────┐
│      margin      │
│  ┌────────────┐  │
│  │   border   │  │
│  │ ┌────────┐ │  │
│  │ │padding │ │  │
│  │ │content │ │  │
│  │ └────────┘ │  │
│  └────────────┘  │
└──────────────────┘

box-sizing: border-box global setzen.


Box-Model in Code

* { box-sizing: border-box; }

.card {
  width: 320px;        /* inkl. padding + border */
  padding: 1.5rem;
  border: 2px solid #ccc;
  border-radius: 0.75rem;
  margin: 1rem auto;   /* Außen + horizontal zentriert */
}

Inspector im DevTools zeigt das Box-Model live an.


Flexbox

1D-Layout (Reihe ODER Spalte)


Flexbox — Basics

.container {
  display: flex;
  gap: 1rem;                   /* Abstand zwischen Items */
  flex-direction: row;         /* row | column */
  justify-content: space-between; /* Haupt-Achse */
  align-items: center;         /* Quer-Achse */
  flex-wrap: wrap;             /* umbruchen erlaubt */
}
<div class="container">
  <div>1</div>
  <div>2</div>
  <div>3</div>
</div>

Flexbox — Achsen

flex-direction: row (default): Haupt-Achse horizontal.

┌─────────────────────────────────────┐
│ ◄── justify-content ──►             │
│ ▲                                   │
│ │                                   │
│ align-items                         │
│ │                                   │
│ ▼                                   │
└─────────────────────────────────────┘

column: Achsen drehen sich 90°.


Flexbox — Item-Properties

.item {
  flex: 1;        /* nimm gleiche Anteile vom verfügbaren Raum */
  flex: 0 0 200px; /* fest 200px, kein wachsen, kein schrumpfen */
  flex-grow: 2;   /* doppelte Anteile */
  order: -1;      /* visuell zuerst, im DOM hinten */
  align-self: end; /* override align-items für DIESES Item */
}

Shorthand: flex: <grow> <shrink> <basis>.


Typische Flex-Patterns

/* Navigation: Logo links, Items rechts */
.nav { display: flex; justify-content: space-between; }

/* Karte: Bild + Text nebeneinander */
.card { display: flex; gap: 1rem; align-items: center; }

/* Button-Gruppe: alle gleich groß */
.btn-group { display: flex; gap: 0.5rem; }
.btn-group button { flex: 1; }

/* Footer: gleichmäßig verteilt */
.footer { display: flex; justify-content: space-around; }

Grid

2D-Layout (Reihe UND Spalte)


Grid — Basics

.container {
  display: grid;
  grid-template-columns: 1fr 2fr 1fr;  /* 3 Spalten, Verhältnis 1:2:1 */
  grid-template-rows: auto 1fr auto;   /* Header, Body, Footer */
  gap: 1rem;
}

fr = Fraction Unit — verbleibender Raum aufgeteilt.


Grid — Areas (named layout)

.layout {
  display: grid;
  grid-template-areas:
    "header header"
    "nav    main"
    "footer footer";
  grid-template-columns: 200px 1fr;
}

.layout header { grid-area: header; }
.layout nav    { grid-area: nav; }
.layout main   { grid-area: main; }
.layout footer { grid-area: footer; }

Lesbarer als Spalten-/Zeilen-Nummern.


Grid — Auto-Layout

/* So viele Spalten wie reinpassen, jede min. 200px */
.gallery {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
  gap: 1rem;
}

Mobile: 1 Spalte. Tablet: 2-3. Desktop: 4-5. Ohne Media Queries.


Flexbox vs. Grid

Flexbox Grid
Dimension 1D 2D
Use-Case Navigation, Karten-Reihe, Button-Gruppe Seiten-Layout, komplexes Raster
Item-Größe flexibel meist fest
Direction row/column rows + columns

Beide in einem Layout möglich: Grid für Seite, Flexbox in Komponenten.


Responsive Design


Mobile-First mit Media Queries

/* Default: Mobile */
.sidebar { display: none; }
.content { padding: 1rem; }

/* Tablet aufwärts */
@media (min-width: 768px) {
  .sidebar { display: block; width: 240px; }
  .content { padding: 2rem; }
}

/* Desktop */
@media (min-width: 1280px) {
  .sidebar { width: 320px; }
}

Mobile-First: kleinste Größe als Default, dann größer.


Viewport-Meta

<meta name="viewport" content="width=device-width, initial-scale=1">

Pflicht im <head>. Ohne dieses Meta zoomt iPhone & Android alles auf 980 px Breite.


Fluid Sizing — ohne Media Queries

/* Font: skaliert zwischen 14px und 22px */
h1 { font-size: clamp(1.4rem, 2.5vw + 1rem, 2.5rem); }

/* Padding: skaliert mit Viewport */
.card { padding: clamp(1rem, 3vw, 3rem); }

/* Breite: nie mehr als 70 Zeichen für Lesetext */
.prose { max-width: 70ch; margin: auto; }

clamp(min, ideal, max) ist modernes Allzweck-Werkzeug.


Animationen


Transitions — sanfter Wechsel

button {
  background: hotpink;
  transition: background 0.2s ease, transform 0.15s;
}

button:hover {
  background: deeppink;
  transform: translateY(-2px);
}

Was animiert performant: transform, opacity. Was nicht: width, height, top/left.


Keyframe-Animationen

@keyframes pulse {
  0%   { transform: scale(1); opacity: 1; }
  50%  { transform: scale(1.1); opacity: 0.7; }
  100% { transform: scale(1); opacity: 1; }
}

.notification {
  animation: pulse 1.5s ease infinite;
}

animation: <name> <duration> <timing> <iteration>.


Reduced Motion — Pflicht

Nicht alle wollen Animationen. (Vestibuläre Probleme, ADHS, Migräne.)

@media (prefers-reduced-motion: reduce) {
  *, *::before, *::after {
    animation-duration: 0.01ms !important;
    transition-duration: 0.01ms !important;
  }
}

Standard-Bestandteil jeder Seite — ein User-Setting respektieren.


CSS-Variablen + Modern


Custom Properties (CSS Variables)

:root {
  --primary: hotpink;
  --gap: 1rem;
  --radius: 0.75rem;
}

button {
  background: var(--primary);
  padding: var(--gap);
  border-radius: var(--radius);
}

/* Dark Mode: nur Variablen umsetzen */
@media (prefers-color-scheme: dark) {
  :root { --primary: deeppink; }
}

CSS Functions

.box {
  width: calc(100% - 2rem);             /* Mathe */
  font-size: clamp(1rem, 2vw, 2rem);    /* min, ideal, max */
  background: linear-gradient(45deg, hotpink, deeppink);
  color: oklch(0.7 0.2 30);             /* moderner Farbraum */
  filter: blur(2px) brightness(1.2);    /* Bildeffekte */
}

CSS-Frameworks

Framework Stil
Tailwind CSS Utility-Klassen direkt im HTML
Bootstrap Komponenten-Bibliothek (klassisch)
Pico klassen-frei, semantisches HTML reicht
Open Props CSS-Variablen-Set
<!-- Tailwind: alle Styles als Klassen -->
<button class="bg-pink-500 hover:bg-pink-600 px-4 py-2 rounded-md">
  Klick
</button>

Tailwind — Argumente dafür/dagegen

Pro:

  • Schnell, weniger Context-Switch (HTML + CSS in einer Datei)
  • Konsistent (Design-System eingebaut)
  • Tree-Shaking → kleines Bundle

Contra:

  • HTML voller Klassen — schwerer zu lesen
  • Lernkurve eigene
  • Versions-Lock-in mit Setup

Faustregel: für neue Projekte ausprobieren, vorhandene Projekte nicht zwanghaft migrieren.


Selbstlernen — Layout-Übung

  1. Flexbox-Spiel: flexboxfroggy.com — alle 24 Level durch.
  2. Grid-Spiel: cssgridgarden.com — 28 Level durch.
  3. Eigene Karten-Galerie: repeat(auto-fit, minmax(...)) Pattern anwenden.

Bonus: Dark-Mode mit CSS-Variablen + prefers-color-scheme.


Zusammenfassung

Heute gelernt:

  • Box-Model + box-sizing: border-box global
  • Flexbox für 1D-Layouts (Navigation, Karten-Reihen)
  • Grid für 2D-Layouts (Seiten-Layout, Galerien)
  • Mobile-First Media Queries + clamp() für fluid
  • Transitions + Keyframes — prefers-reduced-motion respektieren
  • CSS-Variablen für Theming
  • Tailwind & Co. als moderner Framework-Stil

Nächste Stunde: Node.js — JavaScript außerhalb des Browsers.