# Convertor PRO — Beispiele

> Konkrete Durchläufe mit Convertor PRO: JSON zu YAML, YAML zu TOML, Text zu Hex und Unicode, HTML-Entities dekodieren, XML lesbar machen.

Source: https://www.jpkc.com/db/tools/convertor/examples/

Zurück zur Übersicht: [Convertor PRO](https://www.jpkc.com/db/tools/convertor/) · Tool live öffnen: [www.jpkc.com/tools/convertor/](https://www.jpkc.com/tools/convertor/)

Das [Manual](https://www.jpkc.com/db/tools/convertor/manual/) beschreibt jedes Feld und jeden Modus im Detail. Diese Seite ergänzt das um **konkrete Durchläufe**: typische Aufgaben, Schritt für Schritt, mit dem Fokus darauf, was du eingibst und was herauskommt. Die Oberfläche des Tools ist auf Englisch — Tab- und Knopf-Namen stehen deshalb im Original, bei Bedarf mit deutscher Erläuterung.

## Beispiel 1: JSON zu YAML

Du hast eine kompakte JSON-Konfiguration und willst sie als lesbares YAML — etwa für eine CI-Pipeline oder eine `docker-compose`-ähnliche Datei.

1. Öffne den [Convertor PRO](https://www.jpkc.com/tools/convertor/) und wechsle in den **Data Formats**-Tab.
2. Setze **Source** auf `JSON`, **Output** auf `YAML`.
3. Füge links deine JSON-Daten ein, z. B.:

```json
{ "service": "web", "port": 8080, "tags": ["a", "b"], "debug": true }
```

4. Klick **Convert**. Rechts erscheint:

```yaml
service: web
port: 8080
tags:
  - a
  - b
debug: true
```

YAML notiert Strings ohne Anführungszeichen, Zahlen und Booleans bleiben typisiert, Arrays werden zu Listen. Mit **Copy** holst du das Ergebnis in die Zwischenablage oder lädst es per **Save** als `.yaml`-Datei herunter.

## Beispiel 2: YAML zu TOML

Aus derselben Familie, andere Richtung: Du willst eine YAML-Konfiguration als TOML, etwa für ein Rust- oder Python-Tool, das `pyproject.toml`-artige Dateien erwartet.

1. Im **Data Formats**-Tab: **Source** auf `YAML`, **Output** auf `TOML`.
2. Wenn die Ausgabe aus Beispiel 1 noch rechts steht, klick einfach **Swap** — die YAML-Ausgabe rutscht nach links und wird zur neuen Eingabe.
3. Füge sonst dein YAML ein:

```yaml
title: My Project
owner:
  name: Jane
  active: true
```

4. **Convert** liefert:

```toml
title = "My Project"

[owner]
name = "Jane"
active = true
```

Verschachtelte Objekte werden zu `[table]`-Blöcken. Achte darauf, dass **Kommentare aus dem YAML nicht mitkommen** — die Konvertierung läuft über eine reine Daten-Zwischenstufe (siehe [Grenzen und Sonderfälle](https://www.jpkc.com/db/tools/convertor/manual/#grenzen-und-sonderfaelle)).

## Beispiel 3: Text zu Hex und Unicode

Du baust ein Emoji oder einen Sonderbuchstaben in HTML, CSS oder einen JavaScript-String ein und brauchst die korrekte Escape-Schreibweise.

1. Wechsle in den **Encoding**-Tab.
2. Tippe in das Feld **Characters** das Zeichen ein, etwa `😀` oder `café`.
3. Klick den **Convert**-Knopf direkt bei *Characters*.
4. Alle anderen Felder füllen sich gleichzeitig. Für `😀` liest du z. B. ab:
   - *Hexadecimal NCRs*: `😀` (für HTML/XML)
   - *Unicode U+hex*: `U+1F600`
   - *UTF-8 code units*: die UTF-8-Byte-Sequenz
   - *CSS escapes* und *JavaScript escapes*: die jeweils gültige Schreibweise für CSS bzw. JS-Strings
5. Mit dem Kopier-Knopf neben dem passenden Feld holst du genau die Notation, die du brauchst.

Tipp: Willst du nur die Sonderzeichen escapen und ASCII-Buchstaben lesbar lassen, lass die **ASCII**-Checkbox an (Standard) — dann bleibt `cafe` stehen und nur das `é` wird umgesetzt.

## Beispiel 4: HTML-Entities dekodieren

Du hast Text aus einer Quelle, in dem Entities wie `&`, `ü` oder `—` stehen, und willst den Klartext.

1. **Encoding**-Tab.
2. Füge den Text in das Feld **HTML/XML** ein, z. B. `R&D über alles — gut`.
3. Klick den **Convert**-Knopf bei *HTML/XML*.
4. Im Feld **Characters** steht jetzt der Klartext: `R&D über alles — gut`. Das Feld versteht **benannte** Entities (`&`, `ü`, …) genauso wie numerische (`—`).

Geht es um wild gemischte Escapes aus mehreren Notationen gleichzeitig, nimm stattdessen das Feld **Mixed input** und seinen **Convert**-Knopf — es löst verschiedene Escape-Arten in einem Rutsch auf.

## Beispiel 5: XML lesbar als JSON

Eine API hat dir XML zurückgegeben, und du willst die Struktur schnell als JSON überblicken.

1. **Data Formats**-Tab. Füge das XML einfach mit **Paste** ein — die Format-Erkennung erkennt das führende `<` und stellt **Source** automatisch auf `XML`.
2. Setze **Output** auf `JSON` und klick **Convert**. Aus

```xml
<book id="42"><title>Faust</title><year>1808</year></book>
```

   wird

```json
{
  "@id": "42",
  "title": "Faust",
  "year": 1808
}
```

3. Beachte die Konventionen: Attribute bekommen ein `@`-Präfix (`@id`), und reine Text-Werte werden, wo möglich, automatisch typisiert (`1808` wird zur Zahl). Wiederholte gleichnamige Elemente würden zu einem Array. Beachte außerdem: Der Name des **Wurzelelements** (`book`) geht beim XML→Objekt-Schritt verloren — gespiegelt zur „Objekt → XML"-Richtung, wo das Tool umgekehrt einen Wurzelnamen erfinden muss.

## Beispiel 6: INI zu JSON — und warum nicht jeder Weg zurück führt

INI eignet sich zum Einlesen alter Konfigurationen.

1. **Data Formats**-Tab. **Source** auf `INI`, **Output** auf `JSON`. Eingabe:

```ini
debug = true
[database]
host = localhost
port = 5432
```

2. **Convert** liefert verschachteltes JSON mit `debug` auf Wurzelebene und einem `database`-Objekt. Unquotierte Werte werden auto-typisiert: `true` wird Boolean, `5432` wird Zahl.
3. **Umgekehrt** gilt die INI-Grenze: Tief verschachtelte Objekte werden beim Schreiben nach INI mit Punkt-Notation flachgeklopft, und ein **Array auf Wurzelebene** lässt sich gar nicht als INI ausgeben — dann meldet das Tool, dass INI oben ein Objekt braucht. Für strukturreiche Daten ist JSON, YAML oder TOML das bessere Ziel.

Weitere Kniffe — verlustarme Round-Trips, Format-Erkennung gezielt nutzen, Kombination mit anderen Tools — stehen in den [Tipps & Tricks](https://www.jpkc.com/db/tools/convertor/tips/).