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
9.6 KiB
marp, theme, paginate, backgroundColor, header, footer
| marp | theme | paginate | backgroundColor | header | footer |
|---|---|---|---|---|---|
| true | gaia | true | Web Engineering – DHBW Stuttgart | Michael Czechowski – SoSe 2026 |
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
- Flexbox-Spiel: flexboxfroggy.com — alle 24 Level durch.
- Grid-Spiel: cssgridgarden.com — 28 Level durch.
- 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-boxglobal - 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-motionrespektieren - CSS-Variablen für Theming
- Tailwind & Co. als moderner Framework-Stil
Nächste Stunde: Node.js — JavaScript außerhalb des Browsers.