JSON-vertaler die structuur behoudt | Gratis i18n-hulpmiddel

Q: Hoe nauwkeurig is geautomatiseerde vertaling voor technische inhoud?

Het hangt af van de context: Algemene UI-tekst: "Opslaan", "Annuleren", "Verzenden" → Meestal nauwkeurig Technische jargon: "webhook", "OAuth2", "idempotent" → Kunnen verkeerd worden vertaald of ongewijzigd blijven Domeinspecifieke termen: "patient record" (medisch) vs "patient" (geduld) → Context wordt vaak gemist Voor productie-apps, gebruik dit als eerste stap, laat vervolgens iemand technische en domeinspecifieke termen controleren.

Wat is een JSON-structuur Behoudende Vertaler?

Heb je ooit geprobeerd JSON te kopiëren naar Google Translate en eindigde met gebroken sleutels, ontbrekende haakjes of verminkte syntaxis? Dat is precies het probleem dat deze tool oplost.

Een JSON-structuur behoudende vertaler converteert de string waarden binnen je JSON-objecten naar een andere taal terwijl alles verder ongewijzigd blijft—sleutels blijven hetzelfde, getallen blijven getallen, booleaanse waarden blijven booleaans, en je geneste structuur stort niet in.

Hier is wat dit anders maakt dan reguliere vertaalhulpmiddelen: wanneer je een typische i18n-bestand met 50+ geneste sleutels vertaalt, moet de structuur identiek blijven zodat je code nog steeds user.profile.displayName kan refereren in het Spaans, Frans of Japans. Breek die structuur, en je bent uren aan het debuggen.

Deze tool behandelt de recursieve traversatie automatisch, waarbij geïdentificeerd wordt welke strings vertaald moeten worden en welke elementen (zoals API-sleutels, configuratiewaarden of numerieke ID's) precies moeten blijven zoals ze zijn.

Hoe JSON-structuurbehoud werkt

Waarom structuurbehoud belangrijk is

Wanneer je werkt met JSON-vertaling, heb je meestal te maken met een van deze scenario's:

i18n-bestanden waarbij je app verwacht dat en.json en fr.json identieke sleutels hebben
API-reacties die consistente structuur over talen heen nodig hebben voor client-parsing
Configuratiebestanden waarbij het wijzigen van een sleutelnaam je hele applicatie breekt
Database-exports waarbij relaties afhangen van specifieke veldnamen

De uitdaging: JSON is geen gewone tekst. Het is gestructureerde data met een schema waarop je code vertrouwt. Verander "userName" naar "nombreUsuario" tijdens vertaling, en je app gooit een undefined-fout.

Hoe het vertaalproces werkt

Hier gebeurt wat zich onder de motorkap afspeelt bij het vertalen van JSON:

1. Parseren en Valideren De tool valideert eerst je JSON-syntaxis. Als je een komma mist of een extra haakje hebt, krijg je een duidelijk foutbericht voordat de vertaling begint—wat je bewaart voor beschadigde uitvoer.

2. Recursieve Traversatie Beginnend bij de root, loopt het algoritme door elke node in je JSON-boom. Voor elk element controleert het het gegevenstype:

String? Zet het in de wachtrij voor vertaling
Getal, boolean, null? Sla het volledig over
Object of array? Recursief erin duiken

3. Type-Veilige Vertaling Alleen string-waarden worden naar de vertaal-API gestuurd. Je "quantity": 42 blijft 42, niet "tweeënveertig". Je "isActive": true blijft true, niet "waar".

4. Sleutelbehoud Alle objectsleutels blijven in hun oorspronkelijke taal. Dit is cruciaal omdat translations.header.welcomeMessage hetzelfde pad moet zijn in elk taalbestand.

5. Structuur Herbouwen Vertaalde strings worden teruggezet op exact dezelfde posities, waarbij alle nestingsniveaus, array-indices en object-hiërarchieën behouden blijven.

Een veelvoorkomende valkuil: Sommige ontwikkelaars proberen JSON.stringify() van het object, de hele string vertalen en vervolgens terugparsen. Dit breekt omdat de vertaler sleutels, haakjes en syntaxis wijzigt. De recursieve aanpak voorkomt dit volledig.

Het JSON-structuur-behoudende vertaalhulpmiddel

Stapsgewijze handleiding

1. Plak Uw JSON Kopieer uw JSON-object en plak het in het linker paneel. Het hulpmiddel verwerkt elk geldig JSON—of het nu een eenvoudig object met 5 sleutels is of een diep geneste structuur met arrays en meerdere niveaus.

2. Selecteer Doeltaal Kies uit de taaldropdown: Spaans, Frans, Duits, Italiaans, Portugees, Chinees, Japans, Koreaans, Russisch, en meer. Als u voor een i18next-project vertaalt, gebruik dan de taalcode die uw framework verwacht.

3. Ontvang Directe Vertaling De vertaalde uitvoer verschijnt automatisch in het rechter paneel. Geen "Vertaal"-knop nodig—het wordt verwerkt zodra u geldige JSON en een geselecteerde taal hebt.

4. Kopiëren en Gebruiken Klik op de "Kopiëren"-knop om de vertaalde JSON over te nemen. Het is direct klaar om in uw project te plakken—geen opschoning nodig.

5. Wissen voor Volgende Vertaling Druk op "Alles Wissen" wanneer u klaar bent om een ander bestand te vertalen. Het hulpmiddel reset beide panelen direct.

Veelvoorkomende Problemen en Oplossingen

"Ongeldig JSON-formaat" Fout U ziet dit wanneer er een syntaxprobleem is. Gebruikelijke verdachten:

Ontbrekende komma tussen sleutel-waardeparen
Afsluitende komma na het laatste item (geldig in JavaScript, niet in JSON)
Enkele aanhalingstekens in plaats van dubbele aanhalingstekens
Niet-ontsnapte speciale tekens in strings

Snelle oplossing: Voer uw JSON door een validator zoals JSONLint voordat u plakt.

Vertaling Mislukt Stilzwijgend Als het uitvoerpaneel leeg blijft:

Controleer uw internetverbinding—vertaling vereist API-toegang
Verifieer of u een doeltaal hebt geselecteerd
Probeer met een kleinere JSON-snippet om het probleem te isoleren

Onverwachte Resultaten bij Vertaling Machinevertalingen werken goed voor standaardzinnen maar worstelen met:

Technische vaktermen of domeinspecifieke termen
Merknamen (die vaak onvertaald moeten blijven)
Plaatsaanduidingssyntax zoals {{username}} of %s

Voor productietoepassingen gebruikt u dit hulpmiddel als eerste stap, waarna een moedertaalspreker domeinspecifieke of klantgerichte inhoud controleert.

Pro Tips voor Betere Resultaten

Houd Technische Strings Gescheiden Als uw JSON gebruikerstekst en technische identificators mengt, overweeg dan om ze te scheiden. Bijvoorbeeld:

1{
2  "display": {"welcome": "Welkom terug"},
3  "config": {"apiKey": "abc123", "endpoint": "https://api.example.com"}
4}
5

Vertaal het display-object apart om te voorkomen dat de config-waarden per ongeluk worden verwerkt.

Gebruik Context in Uw Strings "Verzenden" kan afhankelijk van de context anders worden vertaald. "Formulier verzenden" of "Betaling verzenden" geeft vertalers (mens of machine) betere context voor nauwkeurige resultaten.

Test met Echte Gegevens Voordat u uw volledige i18n-bestand met 500+ sleutels vertaalt, test u met een kleine steekproef die alle gegevenstypen bevat—strings, getallen, geneste objecten, arrays.

Codevoorbeelden

JSON vertalen met JavaScript

1// Voorbeeld van hoe je vergelijkbare functionaliteit kunt implementeren in JavaScript
2function translateJsonStructure(jsonObj, targetLanguage) {
3  // Hulpfunctie om een string te vertalen
4  function translateString(str, lang) {
5    // In een werkelijke implementatie zou dit een vertaal-API aanroepen
6    return `[${lang}] ${str}`;
7  }
8  
9  // Recursieve functie om JSON te doorzoeken en te vertalen
10  function processNode(node) {
11    if (node === null) return null;
12    
13    if (typeof node === 'string') {
14      return translateString(node, targetLanguage);
15    }
16    
17    if (Array.isArray(node)) {
18      return node.map(item => processNode(item));
19    }
20    
21    if (typeof node === 'object') {
22      const result = {};
23      for (const key in node) {
24        result[key] = processNode(node[key]);
25      }
26      return result;
27    }
28    
29    // Getallen, booleans, etc. ongewijzigd laten
30    return node;
31  }
32  
33  return processNode(jsonObj);
34}
35
36// Voorbeeldgebruik
37const sourceJson = {
38  "product": {
39    "name": "Draadloze Koptelefoon",
40    "description": "Hoogwaardige draadloze koptelefoon met ruisonderdrukking",
41    "features": ["Bluetooth 5.0", "40 uur batterijduur", "Opvouwbaar ontwerp"],
42    "price": 99.99,
43    "inStock": true
44  }
45};
46
47const translatedJson = translateJsonStructure(sourceJson, "es");
48console.log(JSON.stringify(translatedJson, null, 2));
49

JSON vertalen met Python

1import json
2
3def translate_json_structure(json_obj, target_language):
4    """
5    Vertaalt string-waarden in een JSON-object terwijl de structuur behouden blijft.
6    
7    Args:
8        json_obj: Het geparseerde JSON-object
9        target_language: Doeltaalcode (bijv. 'es', 'fr')
10        
11    Returns:
12        Vertaald JSON-object met behouden structuur
13    """
14    def translate_string(text, lang):
15        # In een werkelijke implementatie zou dit een vertaal-API aanroepen
16        return f"[{lang}] {text}"
17    
18    def process_node(node):
19        if node is None:
20            return None
21        
22        if isinstance(node, str):
23            return translate_string(node, target_language)
24        
25        if isinstance(node, list):
26            return [process_node(item) for item in node]
27        
28        if isinstance(node, dict):
29            result = {}
30            for key, value in node.items():
31                result[key] = process_node(value)
32            return result
33        
34        # Getallen, booleans, etc. ongewijzigd laten
35        return node
36    
37    return process_node(json_obj)
38
39# Voorbeeldgebruik
40source_json = {
41    "user": {
42        "name": "Jane Smith",
43        "bio": "Softwareontwikkelaar en open source-bijdrager",
44        "skills": ["JavaScript", "Python", "React"],
45        "active": True,
46        "followers": 245
47    }
48}
49
50translated_json = translate_json_structure(source_json, "fr")
51print(json.dumps(translated_json, indent=2))
52

JSON vertalen met PHP

1<?php
2/**
3 * Vertaalt JSON-structuur terwijl de oorspronkelijke structuur behouden blijft
4 * 
5 * @param mixed $jsonObj Het geparseerde JSON-object
6 * @param string $targetLanguage De doeltaalcode
7 * @return mixed Het vertaalde JSON-object
8 */
9function translateJsonStructure($jsonObj, $targetLanguage) {
10    // Hulpfunctie om een string te vertalen
11    function translateString($text, $lang) {
12        // In een werkelijke implementatie zou dit een vertaal-API aanroepen
13        return "[$lang] $text";
14    }
15    
16    // Recursieve functie om elk knooppunt te verwerken
17    function processNode($node, $lang) {
18        if ($node === null) {
19            return null;
20        }
21        
22        if (is_string($node)) {
23            return translateString($node, $lang);
24        }
25        
26        if (is_array($node)) {
27            // Controleren of het een associatieve array (object) of geïndexeerde array is
28            if (array_keys($node) !== range(0, count($node) - 1)) {
29                // Associatieve array (object)
30                $result = [];
31                foreach ($node as $key => $value) {
32                    $result[$key] = processNode($value, $lang);
33                }
34                return $result;
35            } else {
36                // Geïndexeerde array
37                return array_map(function($item) use ($lang) {
38                    return processNode($item, $lang);
39                }, $node);
40            }
41        }
42        
43        // Getallen, booleans, etc. ongewijzigd laten
44        return $node;
45    }
46    
47    return processNode($jsonObj, $targetLanguage);
48}
49
50// Voorbeeldgebruik
51$sourceJson = [
52    "company" => [
53        "name" => "Global Tech Solutions",
54        "description" => "Innovatief softwareontwikkelingsbedrijf",
55        "founded" => 2010,
56        "services" => ["Webontwikkeling", "Mobiele Apps", "Cloud-oplossingen"],
57        "active" => true
58    ]
59];
60
61$translatedJson = translateJsonStructure($sourceJson, "de");
62echo json_encode($translatedJson, JSON_PRETTY_PRINT);
63?>
64

Praktische Toepassingen in de Praktijk

i18n-bestanden voor Webapplicaties

De meeste moderne frameworks zoals Next.js, React of Vue slaan vertalingen op in JSON-formaat. Wanneer je een nieuwe taal aan je app wilt toevoegen, sta je voor een keuze: handmatig kopiëren en plakken en elke sleutel vertalen (foutgevoelig), of deze tool gebruiken om in enkele minuten een eerste concept te genereren.

Een praktijkscenario: Je app heeft en.json met 200+ vertaalsleutels in geneste categorieën—navigatie, formulieren, foutberichten, tooltips. Je hebt Franse en Duitse versies nodig voor de volgende sprint.

Invoer (en.json):

1{
2  "common": {
3    "welcome": "Welcome to our application",
4    "login": "Log in",
5    "signup": "Sign up",
6    "errorMessages": {
7      "required": "This field is required",
8      "invalidEmail": "Please enter a valid email address"
9    }
10  }
11}
12

Vertaal naar Frans, krijg fr.json met identieke structuur. Je code verwijst nog steeds naar t('common.errorMessages.required') zonder wijzigingen.

Wat ik goed heb gevonden werkt: Genereer vertalingen met deze tool, laat vervolgens een tweetalig teamlid de technische termen en knoplabels controleren. Zo worden gevallen onderschept waarbij "Verzenden" verschillende vertalingen kan hebben voor "Formulier verzenden" versus "Betaling verzenden."

API-reactie Lokalisatie

Een API bouwen die meerdere landen bedient? Je hebt consistente responsstructuren nodig in verschillende talen. Een meldingen-API kan bijvoorbeeld retourneren:

1{
2  "status": "success",
3  "notification": {
4    "title": "Order Shipped",
5    "message": "Your order #12345 has been shipped",
6    "priority": 1,
7    "timestamp": 1678901234
8  }
9}
10

Je mobiele app parseert notification.title en notification.message. Als de Franse vertaling de sleutelstructuur wijzigt, werkt de app niet voor Franse gebruikers.

Deze tool zorgt ervoor dat notification.title notification.title blijft in elke taal, met alleen de tekenreekswaarden vertaald. Je clientcode werkt identiek in alle locales.

Één beperking om op te merken: Geautomatiseerde vertaling begrijpt uw domein niet. "Verzonden" in een e-commerce-context kan anders vertaald worden dan in een logistieke of maritieme context. Controleer voor klantgerichte API's de uitvoer voordat deze wordt geïmplementeerd.

Headless CMS-inhoud Vertalen

Headless CMS-platforms zoals Contentful of Strapi exporteren vaak inhoud als JSON. Wanneer je 50 blogberichten hebt met gestructureerde metadata (auteur, tags, URL's van uitgelichte afbeeldingen, publicatiedatums), wil je de body en titel vertalen zonder de metadata aan te raken.

Een typische export bevat zowel inhoudsreeksen als configuratie:

Inhoud: artikelbody, kop, uittreksel
Structuur: auteur-ID's, afbeeldingspaden, categorie-slugs, tijdstempels

Handmatige vertaling riskeert het wijzigen van een slug van technologie naar tecnología, waardoor de routing wordt verbroken. Structuur-behoudende vertaling behandelt alleen de inhoudsgebieden.

Configuratiebestanden voor Multi-Regio Implementaties

Implementeren over regio's heen? Je configuratiebestanden hebben mogelijk gelokaliseerde tekenreeksen nodig terwijl eindpunten, referenties en functievlaggen identiek blijven:

1{
2  "region": "eu-west",
3  "welcomeMessage": "Welcome to our service",
4  "endpoint": "https://api.eu.example.com",
5  "retryAttempts": 3,
6  "features": {"darkMode": true}
7}
8

Vertaal welcomeMessage naar Duits terwijl endpoint, retryAttempts en features ongewijzigd blijven.

Vergelijken van Vertaalmethoden

Methode	Geschikt voor	Snelheid	Nauwkeurigheid	Structuurbehoud	Kosten
Deze Tool	Snelle i18n-bestandsgeneratie, prototypes, interne tools	Direct	Goed voor standaardinhoud	100% behouden	Gratis
Google Translate (kopiëren/plakken)	Enkele zinnen, niet-technische tekst	Direct	Varieert	Breekt JSON	Gratis
Professionele Vertaling	Klantgerichte content, juridische documenten, marketing	Dagen	Excellent	Handmatig werk vereist	€0,08-0,15/woord
Vertaalbeheerssystemen (Lokalise, Phrase)	Enterprise-apps, samenwerkingsworkflows	Uren-Dagen	Excellent met review	Ingebouwde JSON-ondersteuning	$$$+

Wanneer deze tool te gebruiken: Projecten in beginfase, conceptvertalingen genereren, interne toepassingen waarbij perfecte vertaling niet kritisch is.

Wanneer investeren in professionele vertaling: Klantgerichte content, juridische/compliance-tekst, merkboodschappen, of wanneer culturele nuance belangrijker is dan snelheid.

Technische overwegingen en randgevallen

Wat wordt vertaald (en wat niet)

De tool gebruikt type-controle om te bepalen wat er vertaald wordt:

✅ Vertaald:

String-waarden: "Welcome" → "Welkom"
Strings in arrays: ["Hello", "World"] → ["Hallo", "Wereld"]
Strings op elk nestingsniveau

❌ Niet vertaald:

Getallen: 42, 3.14, -10 blijven ongewijzigd
Booleans: true en false blijven zoals ze zijn
Null: null blijft null
Object-sleutels: "userName" als sleutel blijft "userName"
Lege strings: "" blijft ""

Omgaan met speciale tekens

Unicode en Emoji De tool behandelt UTF-8 correct, dus emoji en niet-Latijnse tekens werken prima:

1{"greeting": "👋 Hello"}
2

Vertaalt naar het Nederlands als:

1{"greeting": "👋 Hallo"}
2

Escape-sequenties JSON escape-sequenties (\n, \t, \") blijven behouden:

1{"message": "Line 1\nLine 2"}
2

De \n blijft intact bij vertaling.

Placeholders Hier is een mogelijke uitdaging: Als uw strings placeholders bevatten zoals {username} of %s, kunnen deze mogelijk worden vertaald of herschikt. In talen met rechts-naar-links tekst kunnen placeholder-posities verschuiven. Controleer deze zorgvuldig.

Prestaties van grote JSON-bestanden

De webgebaseerde tool verwerkt typische i18n-bestanden (onder 500KB) zonder problemen. Voor grotere datasets:

500KB - 2MB: Werkt, maar kan traag zijn in de browser
Meer dan 2MB: Overweeg om te splitsen in logische stukken (bijv. aparte bestanden per functie of sectie)

Browsermemory is de beperkende factor, niet het algoritme zelf.

Veelgestelde vragen

Hoe verschilt dit van het plakken van JSON in Google Translate?

Google Translate behandelt JSON als platte tekst, wat betekent dat het alles probeert te vertalen - inclusief sleutels, syntaxkarakters en numerieke waarden. Je krijgt uitvoer zoals:

1{ "nom d'utilisateur": "Jean Dupont", "âge": "vingt-cinq" }
2

Merk op hoe "username" werd "nom d'utilisateur" en het getal 25 werd de string "vingt-cinq"? Je code valt direct uit elkaar.

Deze tool begrijpt de JSON-structuur en vertaalt alleen string-waarden, waarbij sleutels en andere gegevenstypen intact blijven.

Kan het diep geneste JSON met arrays aan?

Ja. Het recursieve algoritme verwerkt elk nestingsniveau:

1{
2  "users": [
3    {"name": "John", "roles": ["admin", "editor"]},
4    {"name": "Jane", "roles": ["viewer"]}
5  ]
6}
7

Het vertaalt alle string-waarden ("John", "Jane", "admin", "editor", "viewer") terwijl de exacte structuur behouden blijft.

Wat als mijn JSON zowel Engels als al vertaalde inhoud heeft?

De tool vertaalt elke string die het vindt, zelfs als sommige al in de doeltaal zijn. Als je nieuwe sleutels toevoegt aan een bestaand vertalingsbestand, vertaal dan alleen de nieuwe sectie apart en voeg de resultaten vervolgens samen.

Kan ik dit gebruiken voor i18next of react-intl bestanden?

Absoluut. De uitvoerstructuur komt overeen met wat deze frameworks verwachten. Een i18next JSON-bestand zoals:

1{"translation": {"welcome": "Hello", "goodbye": "Goodbye"}}
2

Wordt:

1{"translation": {"welcome": "Hola", "goodbye": "Adiós"}}
2

Je t('translation.welcome') aanroepen blijven ongewijzigd.

Hoe nauwkeurig is geautomatiseerde vertaling voor technische inhoud?

Het hangt af van de context:

Algemene UI-tekst: "Opslaan", "Annuleren", "Verzenden" → Meestal nauwkeurig
Technische jargon: "webhook", "OAuth2", "idempotent" → Kunnen verkeerd worden vertaald of ongewijzigd blijven
Domeinspecifieke termen: "patient record" (medisch) vs "patient" (geduld) → Context wordt vaak gemist

Voor productie-apps, gebruik dit als eerste stap, laat vervolgens iemand technische en domeinspecifieke termen controleren.

Hoe zit het met talen met verschillende tekensets (Chinees, Arabisch, Russisch)?

De tool behandelt Unicode correct, dus alle tekensets werken. Let op één ding: Arabisch en Hebreeuws zijn rechts-naar-links (RTL), wat kan invloed hebben op hoe tijdelijke aanduidingen verschijnen in vertaalde strings. De JSON-structuur blijft correct, maar controleer de vertaalde tekst op leesbaarheid.

Behoudt het mijn opmaak (inspringen, regelovergangen)?

De uitvoer is geldige JSON, maar opmaak (witruimte, inspringen) kan afwijken van je invoer. Als je specifieke opmaak nodig hebt, run de uitvoer dan door een JSON-formatter met je voorkeuurinstellingen.

Kan ik configuratiewaarden zoals URL's of API-sleutels vertalen?

De tool vertaalt alle strings, inclusief URL's en configuratiewaarden. Om dit te voorkomen:

Splits je JSON in gebruikersvriendelijke inhoud en configuratie
Vertaal alleen de inhoudsectie
Laat configuratie onvertaald

Nog beter, structureer je bestanden van meet af aan om vertaalbare inhoud te scheiden van technische waarden.

Is dit gratis? Zijn er limieten?

De webgebaseerde tool is gratis voor normaal gebruik. Zeer grootschalige vertaling (honderden bestanden per minuut) kan limieten tegenkomen op de onderliggende vertaalservice. Voor de meeste ontwikkelworkflows zul je geen limieten tegenkomen.

Referenties en Verdere Lectuur

Voor een dieper begrip van JSON-structuur, internationalisatiestandaarden en best practices:

ECMA-404: De JSON Data Interchange Syntax - De officiële JSON-specificatie door Ecma International die de standaardindeling definieert: ecma-international.org/publications-and-standards/standards/ecma-404/
MDN Web Docs: Werken met JSON - Mozilla's uitgebreide gids voor JSON-parsing, stringificatie en structuur: developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/JSON
W3C Internationalization (i18n) Activiteit - Standaarden en best practices voor web internationalisatie: w3.org/International/
RFC 8259: Het JSON Data Interchange Formaat - IETF-specificatie voor JSON-syntaxis en semantiek: datatracker.ietf.org/doc/html/rfc8259

Begin met het vertalen van uw JSON-bestanden

Wilt u snel vertalingsbestanden genereren voor uw meertalige applicatie? Plak uw JSON, selecteer een doeltaal en ontvang direct vertalingen die de structuur behouden. Werkt met i18next, react-intl, vue-i18n en elk framework dat consistente JSON-structuur tussen talen verwacht.

Begin met vertalen: