---
title: Sektionen und Spalten
description: Mehrspaltige Layouts mit dem SectionBlock-Container in Templatical.
---

# Sektionen und Spalten

Der `SectionBlock` ist das Layout-Primitiv in Templatical. Jedes mehrspaltige Layout wird erstellt, indem eine Sektion angelegt und Blöcke in deren Spalten platziert werden.

## Spaltenlayouts

::: tip E-Mail-Best-Practice
Bleiben Sie für die meisten E-Mails bei 1-2 Spalten. Dreispaltige Layouts werden auf Mobilgeräten beim vertikalen Stapeln der Spalten beengt, und einige E-Mail-Clients behandeln 3-spaltige Layouts inkonsistent. Vier Spalten sind noch enger.
:::

Die Eigenschaft `columns` akzeptiert eines dieser Layout-Presets:

| Wert | Beschreibung | Spaltenbreiten |
|-------|-------------|---------------|
| `'1'` | Einzelne Spalte | 100% |
| `'2'` | Zwei gleiche Spalten | 50% / 50% |
| `'3'` | Drei gleiche Spalten | 33% / 33% / 33% |
| `'4'` | Vier gleiche Spalten | 25% / 25% / 25% / 25% |
| `'2-1'` | Zwei Drittel / ein Drittel | 66% / 33% |
| `'1-2'` | Ein Drittel / zwei Drittel | 33% / 66% |
| `'3-1'` | Drei Viertel / ein Viertel | 75% / 25% |
| `'1-3'` | Ein Viertel / drei Viertel | 25% / 75% |
| `'1-2-1'` | Ein Viertel / Hälfte / ein Viertel | 25% / 50% / 25% |

```ts
type ColumnLayout = '1' | '2' | '3' | '4' | '2-1' | '1-2' | '3-1' | '1-3' | '1-2-1';
```

## Benutzerdefinierte Spaltenbreiten {#custom-column-widths}

`columnWidths` überschreibt die Aufteilung des Presets. Es ist eine Zahl pro Spalte von `columns`. Die Anteile werden auf 100 in Hundertsteln skaliert. Jede Spalte wird abgerundet und dann auf mindestens 0.01 angehoben, und jedes übrige Hundertstel geht an den größten Nachkommarest. Bei Gleichstand erhält die frühere Spalte das Hundertstel. `[1, 1, 2]` ist 25% / 25% / 50%. `[1, 1, 1]` ist 33.34% / 33.33% / 33.33%. `[6, 2, 2, 2]` ist 50% / 16.67% / 16.67% / 16.66%. Die Zeile ergibt 100. `columns` setzt weiter die Spaltenzahl. Preset-Zeilen bleiben die Literale in `COLUMN_LAYOUT_PERCENTS`.

```ts
import { createSectionBlock } from '@templatical/types';

const row = createSectionBlock({
  columns: '3',
  columnWidths: [1, 1, 2],
  children: [[], [], []],
});
```

Fehlt `columnWidths`, gilt das Preset. Der Renderer schreibt jeden Anteil als `width` auf `mj-column`, zum Beispiel `width="25%"`, `width="25%"` und `width="50%"`. `stackOnMobile: false` packt diese Spalten in `<mj-group>`, wie bei einem Preset.

`columnWidths` wird ignoriert, wenn seine Länge von der Spaltenzahl des Layouts abweicht oder ein Wert keine endliche Zahl über 0 ist. Die Aufteilung des Presets wird dargestellt, und `structure.column-widths-ignored` nennt den Grund, `count` oder `value`.

Im Editor zeigt ein Abschnitt mit zwei oder mehr Spalten unter Spalten die Zeile Spaltenbreiten. Jedes Feld ist der Anteil dieser Spalte. Wenn Sie eine Spalte ändern, erhält die rechte Spalte die Differenz, und wenn Sie die letzte Spalte ändern, erhält die linke Spalte sie. Eine Änderung lässt beiden Spalten mindestens 5 %, oder die Hälfte ihres gemeinsamen Anteils, wenn das Paar schmaler als 10 % ist (ein importiertes `[1, 1, 98]` behält 1 % / 1 %). Spalten zeigt den Eintrag Benutzerdefiniert, solange eine verwendbare Überschreibung gespeichert ist, auch bei 50 % / 50 % in einem zweispaltigen Abschnitt. Wenn Sie ein Preset wählen, werden die eigenen Breiten entfernt.

`COLUMN_LAYOUT_PERCENTS` ist die Preset-Tabelle, die der Renderer ausgibt: `"1"` ist `[100]`, `"2"` ist `[50, 50]`, `"3"` ist `[33.33, 33.33, 33.34]`, `"4"` ist `[25, 25, 25, 25]`, `"1-2"` ist `[33.33, 66.67]`, `"2-1"` ist `[66.67, 33.33]`, `"1-3"` ist `[25, 75]`, `"3-1"` ist `[75, 25]`, `"1-2-1"` ist `[25, 50, 25]`. `sectionColumnPercents` liefert diese Zeile oder die skalierte Überschreibung. `columnWidthsIssue` liefert `"count"`, `"value"` oder `null`.

## Sektionen erstellen

Verwenden Sie `createSectionBlock` aus `@templatical/types`:

```ts
import {
  createSectionBlock,
  createTitleBlock,
  createParagraphBlock,
  createImageBlock,
} from '@templatical/types';

// Leere zweispaltige Sektion
const section = createSectionBlock({ columns: '2' });

// Sektion mit vorbefüllten Spalten
const hero = createSectionBlock({
  columns: '1-2',
  children: [
    [createImageBlock({ src: 'https://cdn.example.com/logo.png', width: 120 })],
    [
      createTitleBlock({ content: '<h1>Welcome</h1>', level: 1 }),
      createParagraphBlock({ content: '<p>Get started in minutes.</p>' }),
    ],
  ],
});
```

## Das children-Array

`children` ist ein `Block[][]` -- ein Array von Arrays. Jedes innere Array repräsentiert die Blöcke innerhalb einer Spalte, geordnet von links nach rechts.

```ts
// Für ein '2'-Layout:
section.children = [
  [blockA, blockB],  // Linke Spalte
  [blockC],          // Rechte Spalte
];

// Für ein '3'-Layout:
section.children = [
  [blockA],  // Links
  [blockB],  // Mitte
  [blockC],  // Rechts
];
```

Die Länge von `children` muss mit der Anzahl der Spalten im gewählten Layout übereinstimmen. Wenn Sie `columns` ändern, passt der Editor `children` automatisch an -- überschüssige Spalten werden in die letzte Spalte zusammengeführt oder leere Arrays werden für neue Spalten hinzugefügt.

## Blöcke zu Spalten hinzufügen

Um einen Block programmatisch zu einer bestimmten Spalte hinzuzufügen:

```ts
// Eine Schaltfläche zur zweiten Spalte hinzufügen (Index 1)
section.children[1].push(
  createButtonBlock({
    text: 'Learn More',
    url: 'https://example.com/docs',
  }),
);
```

## Verschachtelung

Sektionen können nicht innerhalb anderer Sektionen verschachtelt werden. Jede Sektion befindet sich auf der obersten Ebene der Block-Liste des Templates. Innerhalb einer Spalte können Sie jeden Nicht-Sektion-Blocktyp platzieren: Titel, Absätze, Bilder, Schaltflächen, Tabellen, benutzerdefinierte Blöcke usw.

## Responsives Verhalten

Auf dem Desktop werden Spalten nebeneinander in ihren definierten Breiten gerendert. Auf kleineren Bildschirmen stapeln sie sich vertikal in der Quellreihenfolge (linke Spalte oben) — MJML-Standard.

`stackOnMobile` schaltet das ab. Weglassen oder `true` behält das Stapeln. `false` packt die Spalten in `<mj-group>`, damit sie auf Mobilgeräten nebeneinander bleiben. Die Sektions-Toolbar zeigt den Schalter bei mehrspaltigen Sektionen. Eine einspaltige Sektion erzeugt nie ein `mj-group`.

```ts
const row = createSectionBlock({ columns: '2', stackOnMobile: false });
```

Sie können die Eigenschaft `visibility` für einzelne Blöcke innerhalb von Spalten verwenden, um Inhalte pro Breakpoint anzuzeigen oder auszublenden:

```ts
const block = createParagraphBlock({
  content: '<p>Desktop only sidebar content</p>',
});

block.visibility = {
  desktop: true,
  mobile: false,
};
```

Siehe [Styling](/de/guide/styling) für weitere Informationen zur Blocksichtbarkeit.

## Stile auf Sektionsebene

Sektionen unterstützen die gleichen `BlockStyles` wie andere Blöcke. Häufige Anwendungsfälle sind das Festlegen einer Hintergrundfarbe oder eines Paddings für die gesamte Zeile:

```ts
const section = createSectionBlock({ columns: '1' });

section.styles = {
  backgroundColor: '#f8fafc',
  padding: { top: 32, right: 24, bottom: 32, left: 24 },
};
```

Sektionen akzeptieren außerdem einen `borderRadius` (in px, eine sektionsspezifische Eigenschaft) für abgerundete Ecken — nützlich für eine kartenartige Sektion auf einem kontrastierenden Hintergrund:

```ts
const card = createSectionBlock({ columns: '1', borderRadius: 12 });

card.styles.backgroundColor = '#ffffff';
```

### Hintergrundbild

Das `backgroundImage` einer Sektion legt ein Bild hinter ihre Spalten. Setzen Sie zusätzlich `styles.backgroundColor` als Fallback, solange das Bild lädt und in Clients, die keine Hintergrundbilder anzeigen. Im **Hintergrund**-Panel des Editors wählen Sie außerdem die Größe (Füllen, Einpassen oder Original), eine Position auf einem Neun-Punkte-Raster und ob sich das Bild wiederholt. Die Hinweise zu E-Mail-Clients finden Sie beim [Sektionsblock](/de/guide/blocks#section).

### Hero

Eine einspaltige Sektion mit Hintergrundbild kann als Hero dargestellt werden – als `mj-hero`, bei dem das Bild die Box füllt und der Inhalt darauf liegt. Setzen Sie dazu `hero`:

```ts
const banner = createSectionBlock({
  columns: '1',
  backgroundImage: {
    ...createBackgroundImage('https://cdn.example.com/hero.jpg'),
    naturalWidth: 1200,
    naturalHeight: 800,
  },
  hero: { height: 'image', verticalAlign: 'middle' },
});
banner.styles.backgroundColor = '#1f2937';
```

`height: 'image'` macht die Box so hoch wie das Bild, das über ihre Desktop-Breite gezeichnet wird; dafür braucht es die Größe der Bilddatei in `backgroundImage.naturalWidth` / `naturalHeight`. Auf Smartphones bleibt diese Höhe, und das Bild wird seitlich beschnitten, um die schmalere Box zu füllen. Eine Auswahl aus der Mediathek, die die Größe kennt (`width` / `height` am Asset oder am `onRequestMedia`-Ergebnis), speichert sie mit der URL; andernfalls misst der Editor das Bild. Eine Zahl ist eine feste Höhe in px, Innenabstand eingeschlossen. Im Editor wechselt **Höhe** im Panel **Hintergrund** zwischen **Wie Inhalt** (kein Hero), **Wie Bild** und **Fest**, und **Position des Inhalts** platziert den Inhalt. Die Verknüpfung **Hero** in der Palette fügt einen Hero zum Ausfüllen ein: eine Sektion im Hero-Modus mit Titel, Absatz und Button auf dunkler Füllung. Die Hinweise zu E-Mail-Clients stehen beim [Sektionsblock](/de/guide/blocks#section).

### Äußerer Rahmen (Wrapper)

Um eine Sektion in einem farbigen Band zu rahmen — z. B. eine weiße Karte auf blauem Hintergrund — setzen Sie `wrapper`. Es rendert ein `mj-wrapper` um die Sektion, mit eigenem Hintergrund, Padding und Eckenradius. Das Band ist so breit wie der E-Mail-Körper (`settings.width`), es sei denn, Sie setzen `fullWidth`. `fullWidth: true` ist MJMLs `full-width="full-width"`: Hintergrundfarbe und Hintergrundbild des Bands reichen über das Fenster des Empfängers, die Sektion bleibt bei `settings.width`. Ein Eckenradius gilt nicht, solange `fullWidth` an ist — ein fensterbreites Band hat keine sichtbaren Ecken — und der gespeicherte Radius gilt wieder, wenn `fullWidth` aus ist:

```ts
const card = createSectionBlock({ columns: '1', borderRadius: 12 });
card.styles.backgroundColor = '#ffffff';

card.wrapper = {
  backgroundColor: '#1e3a8a',
  padding: { top: 24, right: 24, bottom: 24, left: 24 },
  borderRadius: 16,
};
```

Das Padding des Wrappers sorgt dafür, dass das Band um die Sektion herum sichtbar wird. Aktivieren Sie es im Editor über das **Wrapper**-Panel in der Sektions-Symbolleiste. **Hintergrund über die volle Breite** im Panel **Hintergrund** setzt `fullWidth`. Gibt es noch keinen Wrapper, verschiebt das Einschalten die eigene Hintergrundfarbe und das Hintergrundbild der Sektion auf einen neuen Wrapper und löscht sie an der Sektion, sodass der Inhalt transparent über dem Band liegt. Solange der Schalter an ist, bearbeiten Farbe und Bild in diesem Panel das Band (`wrapper.backgroundColor` und `wrapper.backgroundImage`), und **Hintergrund des Inhalts** darunter setzt die Füllung der Sektion (`styles.backgroundColor`; leer lässt den Inhalt transparent über dem Band). Das Wrapper-Panel zeigt dieselbe Bandfarbe und dasselbe Bild. Solange der Schalter aus ist, bearbeiten Farbe und Bild die Füllung der Sektion, und **Hintergrund des Inhalts** bleibt ausgeblendet. Schalten Sie ihn aus, wird `fullWidth` gelöscht. Ein Wrapper, der nur dieses Band trägt, wird entfernt, und seine aktuelle Farbe und sein aktuelles Bild kehren auf die Sektion zurück. Hat die Sektion bereits eine Inhaltsfüllung, bleibt der Wrapper mit gelöschtem `fullWidth`, sodass keine der beiden Farben verworfen wird. Der Wrapper ist eine Stilebene, kein Container — Sektionen können weiterhin nicht verschachtelt werden. Eine vom Host vorgegebene Karte um die Autorensektionen ist ein [Layout](/de/guide/layout)-Overlay.
