sim/apps/docs/content/docs/de/blocks/loop.mdx

---
title: Loop
---

import { Callout } from 'fumadocs-ui/components/callout'
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
import { Image } from '@/components/ui/image'

Der Schleifenblock ist ein Container, der Blöcke wiederholt ausführt. Iteriere über Sammlungen, wiederhole Operationen eine festgelegte Anzahl von Malen oder fahre fort, solange eine Bedingung erfüllt ist.

<Callout type="info">
  Schleifenblöcke sind Container-Knoten, die andere Blöcke in sich enthalten. Die enthaltenen Blöcke werden mehrfach ausgeführt, basierend auf deiner Konfiguration.
</Callout>

## Konfigurationsoptionen

### Schleifentyp

Wähle zwischen vier Arten von Schleifen:

<Tabs items={['For-Schleife', 'ForEach-Schleife', 'While-Schleife', 'Do-While-Schleife']}>
  <Tab>
    **For-Schleife (Iterationen)** - Eine numerische Schleife, die eine festgelegte Anzahl von Malen ausgeführt wird:
    
    <div className="flex justify-center">
      <Image
        src="/static/blocks/loop-1.png"
        alt="For-Schleife mit Iterationen"
        width={500}
        height={400}
        className="my-6"
      />
    </div>
    
    Verwende diese, wenn du eine Operation eine bestimmte Anzahl von Malen wiederholen musst.
    

    ```
    Example: Run 5 times
    - Iteration 1
    - Iteration 2
    - Iteration 3
    - Iteration 4
    - Iteration 5
    ```

  </Tab>
  <Tab>
    **ForEach-Schleife (Sammlung)** - Eine sammlungsbasierte Schleife, die über jedes Element in einem Array oder Objekt iteriert:
    
    <div className="flex justify-center">
      <Image
        src="/static/blocks/loop-2.png"
        alt="ForEach-Schleife mit Sammlung"
        width={500}
        height={400}
        className="my-6"
      />
    </div>
    
    Verwende diese, wenn du eine Sammlung von Elementen verarbeiten musst.
    

    ```
    Example: Process ["apple", "banana", "orange"]
    - Iteration 1: Process "apple"
    - Iteration 2: Process "banana"
    - Iteration 3: Process "orange"
    ```

  </Tab>
  <Tab>
    **While-Schleife (Bedingungsbasiert)** - Wird ausgeführt, solange eine Bedingung als wahr ausgewertet wird:
    
    <div className="flex justify-center">
      <Image
        src="/static/blocks/loop-3.png"
        alt="While-Schleife mit Bedingung"
        width={500}
        height={400}
        className="my-6"
      />
    </div>
    
    Verwende diese, wenn du eine Schleife benötigst, die läuft, bis eine bestimmte Bedingung erfüllt ist. Die Bedingung wird **vor** jeder Iteration überprüft.

    ```
    Example: While {"<variable.i>"} < 10
    - Check condition → Execute if true
    - Inside loop: Increment {"<variable.i>"}
    - Inside loop: Variables assigns i = {"<variable.i>"} + 1
    - Check condition → Execute if true
    - Check condition → Exit if false
    ```

  </Tab>
  <Tab>
    **Do-While-Schleife (Bedingungsbasiert)** - Wird mindestens einmal ausgeführt und dann fortgesetzt, solange eine Bedingung wahr ist:
    
    <div className="flex justify-center">
      <Image
        src="/static/blocks/loop-4.png"
        alt="Do-While-Schleife mit Bedingung"
        width={500}
        height={400}
        className="my-6"
      />
    </div>
    
    Verwende diese, wenn du eine Operation mindestens einmal ausführen musst und dann die Schleife fortsetzen willst, bis eine Bedingung erfüllt ist. Die Bedingung wird **nach** jeder Iteration überprüft.

    ```
    Example: Do-while {"<variable.i>"} < 10
    - Execute blocks
    - Inside loop: Increment {"<variable.i>"}
    - Inside loop: Variables assigns i = {"<variable.i>"} + 1
    - Check condition → Continue if true
    - Check condition → Exit if false
    ```

  </Tab>
</Tabs>

## Wie man Schleifen verwendet

### Eine Schleife erstellen

1. Ziehe einen Schleifenblock aus der Werkzeugleiste auf deine Leinwand
2. Konfiguriere den Schleifentyp und die Parameter
3. Ziehe andere Blöcke in den Schleifencontainer
4. Verbinde die Blöcke nach Bedarf

### Auf Ergebnisse zugreifen

Nach Abschluss einer Schleife kannst du auf aggregierte Ergebnisse zugreifen:

- **loop.results**: Array mit Ergebnissen aller Schleifendurchläufe

## Beispielanwendungsfälle

**Verarbeitung von API-Ergebnissen** - ForEach-Schleife verarbeitet Kundendatensätze aus einer API

```javascript
// Beispiel: ForEach-Schleife für API-Ergebnisse
const customers = await api.getCustomers();

loop.forEach(customers, (customer) => {
  // Verarbeite jeden Kunden
  if (customer.status === 'active') {
    sendEmail(customer.email, 'Sonderangebot');
  }
});
```

**Iterative Inhaltsgenerierung** - For-Schleife generiert mehrere Inhaltsvariationen

```javascript
// Beispiel: For-Schleife für Inhaltsgenerierung
const variations = [];

loop.for(5, (i) => {
  // Generiere 5 verschiedene Variationen
  const content = ai.generateContent({
    prompt: `Variation ${i+1} für Produktbeschreibung`,
    temperature: 0.7 + (i * 0.1)
  });
  variations.push(content);
});
```

**Zähler mit While-Schleife** - While-Schleife verarbeitet Elemente mit Zähler

```javascript
// Beispiel: While-Schleife mit Zähler
let counter = 0;
let processedItems = 0;

loop.while(() => counter < items.length, () => {
  if (items[counter].isValid) {
    processItem(items[counter]);
    processedItems++;
  }
  counter++;
});

console.log(`${processedItems} gültige Elemente verarbeitet`);
```

## Erweiterte Funktionen

### Einschränkungen

<Callout type="warning">
  Container-Blöcke (Schleifen und Parallele) können nicht ineinander verschachtelt werden. Das bedeutet:
  - Du kannst keinen Schleifenblock in einen anderen Schleifenblock platzieren
  - Du kannst keinen Parallel-Block in einen Schleifenblock platzieren
  - Du kannst keinen Container-Block in einen anderen Container-Block platzieren
  
  Wenn du mehrdimensionale Iterationen benötigst, erwäge eine Umstrukturierung deines Workflows, um sequentielle Schleifen zu verwenden oder Daten in Stufen zu verarbeiten.
</Callout>

<Callout type="info">
  Schleifen werden sequentiell ausgeführt, nicht parallel. Wenn du eine gleichzeitige Ausführung benötigst, verwende stattdessen den Parallel-Block.
</Callout>

## Eingaben und Ausgaben

<Tabs items={['Configuration', 'Variables', 'Results']}>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>Schleifentyp</strong>: Wähle zwischen 'for', 'forEach', 'while' oder 'doWhile'
      </li>
      <li>
        <strong>Iterationen</strong>: Anzahl der Ausführungen (für for-Schleifen)
      </li>
      <li>
        <strong>Sammlung</strong>: Array oder Objekt zum Durchlaufen (für forEach-Schleifen)
      </li>
      <li>
        <strong>Bedingung</strong>: Boolescher Ausdruck zur Auswertung (für while/do-while-Schleifen)
      </li>
    </ul>
  </Tab>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>loop.currentItem</strong>: Aktuell verarbeitetes Element
      </li>
      <li>
        <strong>loop.index</strong>: Aktuelle Iterationsnummer (0-basiert)
      </li>
      <li>
        <strong>loop.items</strong>: Vollständige Sammlung (für forEach-Schleifen)
      </li>
    </ul>
  </Tab>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>loop.results</strong>: Array aller Iterationsergebnisse
      </li>
      <li>
        <strong>Struktur</strong>: Ergebnisse behalten die Iterationsreihenfolge bei
      </li>
      <li>
        <strong>Zugriff</strong>: Verfügbar in Blöcken nach der Schleife
      </li>
    </ul>
  </Tab>
</Tabs>

## Bewährte Praktiken

- **Setzen Sie vernünftige Grenzen**: Halten Sie die Anzahl der Iterationen in einem vernünftigen Rahmen, um lange Ausführungszeiten zu vermeiden
- **Verwenden Sie ForEach für Sammlungen**: Verwenden Sie beim Verarbeiten von Arrays oder Objekten ForEach anstelle von For-Schleifen
- **Behandeln Sie Fehler elegant**: Erwägen Sie, Fehlerbehandlung innerhalb von Schleifen hinzuzufügen, um robuste Workflows zu gewährleisten