JSON-översättare som bevarar struktur | Gratis i18n-verktyg

Q: Hur exakt är automatisk översättning för tekniskt innehåll?

Det beror på sammanhanget: Generell UI-text: "Spara", "Avbryt", "Skicka" → Vanligtvis exakt Teknisk jargong: "webhook", "OAuth2", "idempotent" → Kan vara felöversatt eller lämnas som det är Domänspecifika termer: "patient record" (medicinsk) vs "patient" (tålamod) → Sammanhang missas ofta För produktionsappar, använd detta som ett första utkast och låt sedan någon granska tekniska och domänspecifika termer.

Vad är en JSON-strukturbevarande översättare?

Har du någonsin försökt kopiera JSON till Google Translate och hamnat med trasiga nycklar, saknade hakparenteser eller förvanskat syntax? Det är exakt det problem som detta verktyg löser.

En JSON-strukturbevarande översättare konverterar strängvärdena inuti dina JSON-objekt till ett annat språk medan allt annat lämnas orört—nycklar förblir desamma, siffror förblir siffror, booleska värden förblir booleska, och din kapslade struktur kollapsar inte.

Här är det som skiljer detta från vanliga översättningsverktyg: när du översätter en typisk i18n-fil med 50+ kapslade nycklar, behöver du att strukturen förblir identisk så att din kod fortfarande kan referera till user.profile.displayName på spanska, franska eller japanska. Bryt den strukturen, och du kommer att felsöka i timmar.

Detta verktyg hanterar den rekursiva traverseringen automatiskt, och identifierar vilka strängar som behöver översättning och vilka element (som API-nycklar, konfigurationsvärden eller numeriska ID:n) som ska förbli exakt som de är.

Hur JSON-strukturbevarande fungerar

Varför strukturbevarande är viktigt

När du arbetar med JSON-översättning, hanterar du vanligtvis något av följande scenarier:

i18n-filer där din app förväntar sig att en.json och fr.json har identiska nycklar
API-svar som behöver konsekvent struktur över språk för klienttolkning
Konfigurationsfiler där nyckelnamnsändring bryter hela din applikation
Databasexporter där relationer är beroende av specifika fältnamn

Utmaningen: JSON är inte bara text. Det är strukturerad data med ett schema som din kod förlitar sig på. Ändra "userName" till "nombreUsuario" under översättningen, och din app kastar ett undefined-fel.

Hur översättningsprocessen fungerar

Här är vad som händer under huven när du översätter JSON:

1. Parsing och validering Verktyget validerar först din JSON-syntax. Om du saknar ett kommatecken eller har en extra hakparentes, får du ett tydligt felmeddelande innan någon översättning börjar—vilket sparar dig från korrupt utdata.

2. Rekursiv traversering Från roten går algoritmen igenom varje nod i ditt JSON-träd. För varje element kontrolleras datatypen:

Sträng? Köa för översättning
Nummer, boolean, null? Hoppa över helt
Objekt eller array? Rekursera in i den

3. Typsäker översättning Endast strängvärden skickas till översättnings-API:et. Din "quantity": 42 förblir 42, inte "fyrtiotvå". Din "isActive": true förblir true, inte "sant".

4. Nyckelbevarande Alla objektnycklar stannar kvar på sitt ursprungliga språk. Detta är kritiskt eftersom translations.header.welcomeMessage måste vara samma sökväg i varje språkfil.

5. Strukturell återuppbyggnad Översatta strängar infogas tillbaka på exakt samma positioner och bibehåller alla kapslingsnivåer, arrayindex och objekthierarkier.

Ett vanligt misstag: Vissa utvecklare försöker JSON.stringify() objektet, översätta hela strängen och sedan parsa tillbaka den. Detta bryter eftersom översättaren ändrar nycklar, hakparenteser och syntax. Den rekursiva metoden undviker detta helt och hållet.

Använda JSON-strukturbevarande översättaren

Steg-för-steg-guide

1. Klistra in din JSON Kopiera ditt JSON-objekt och klistra in det i den vänstra panelen. Verktyget hanterar alla giltiga JSON—oavsett om det är ett enkelt objekt med 5 nycklar eller en djupt kapslad struktur med arrayer och flera nivåer.

2. Välj målspråk Välj från språkdropdownen: Spanska, franska, tyska, italienska, portugisiska, kinesiska, japanska, koreanska, ryska och fler. Om du översätter för ett i18next-projekt, matcha språkkoden som ditt ramverk förväntar sig.

3. Få omedelbar översättning Den översatta utdatan visas automatiskt i den högra panelen. Ingen "Översätt"-knapp behövs—den bearbetas så snart du har giltig JSON och ett valt språk.

4. Kopiera och använd Klicka på "Kopiera"-knappen för att hämta den översatta JSON:en. Den är redo att klistras in direkt i ditt projekt—ingen rensning behövs.

5. Rensa för nästa översättning Tryck på "Rensa allt" när du är redo att översätta en annan fil. Verktyget återställer båda panelerna omedelbart.

Vanliga problem och lösningar

"Ogiltigt JSON-format" Fel Du ser detta när det finns ett syntaxproblem. Vanliga syndare:

Saknad komma mellan nyckel-värde-par
Avslutande komma efter den sista posten (giltigt i JavaScript, inte JSON)
Enkla citattecken istället för dubbla citattecken
Ej undantagna specialtecken i strängar

Snabb lösning: Kör din JSON genom en validator som JSONLint innan du klistrar in.

Översättning misslyckas tyst Om utdatapanelen förblir tom:

Kontrollera din internetanslutning—översättning kräver API-åtkomst
Verifiera att du har valt ett målspråk
Testa med ett mindre JSON-fragment för att isolera problemet

Oväntade resultat i översättningen Maskinöversättning fungerar bra för standardfraser men har svårt med:

Tekniska termer eller domänspecifika termer
Varumärkesnamn (som ofta bör förbli oöversatta)
Platshållarsynta som {{username}} eller %s

För produktionsapplikationer, använd detta verktyg som en första genomgång och låt sedan en modersmålstalare granska domänspecifikt eller kundriktat innehåll.

Pro-tips för bättre resultat

Håll tekniska strängar separerade Om din JSON blandar användarvänlig text med tekniska identifierare, överväg att dela upp dem. Till exempel:

1{
2  "display": {"welcome": "Välkommen tillbaka"},
3  "config": {"apiKey": "abc123", "endpoint": "https://api.example.com"}
4}
5

Översätt display-objektet separat för att undvika att oavsiktligt bearbeta config-värdena.

Använd kontext i dina strängar "Skicka" kan översättas olika beroende på kontext. "Skicka formulär" eller "Skicka betalning" ger översättare (mänskliga eller maskinella) bättre kontext för exakt resultat.

Testa med riktiga data Innan du översätter hela din i18n-fil med 500+ nycklar, testa med ett litet urval som inkluderar alla dina datatyper—strängar, nummer, kapslade objekt, arrayer.

Kodexempel

Översätta JSON med JavaScript

1// Exempel på hur du kan implementera liknande funktionalitet i JavaScript
2function translateJsonStructure(jsonObj, targetLanguage) {
3  // Hjälpfunktion för att översätta en sträng
4  function translateString(str, lang) {
5    // I en riktig implementation skulle detta anropa ett översättnings-API
6    return `[${lang}] ${str}`;
7  }
8  
9  // Rekursiv funktion för att traversera och översätta JSON
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    // Returnera nummer, booleska värden etc. oförändrade
30    return node;
31  }
32  
33  return processNode(jsonObj);
34}
35
36// Exempelanvändning
37const sourceJson = {
38  "product": {
39    "name": "Trådlösa hörlurar",
40    "description": "Högkvalitativa trådlösa hörlurar med brusreducering",
41    "features": ["Bluetooth 5.0", "40 timmars batteritid", "Vikbar design"],
42    "price": 99.99,
43    "inStock": true
44  }
45};
46
47const translatedJson = translateJsonStructure(sourceJson, "es");
48console.log(JSON.stringify(translatedJson, null, 2));
49

Översätta JSON med Python

1import json
2
3def translate_json_structure(json_obj, target_language):
4    """
5    Översätter strängvärden i ett JSON-objekt samtidigt som strukturen bevaras.
6    
7    Args:
8        json_obj: Det parsade JSON-objektet
9        target_language: Målspråkets kod (t.ex. 'es', 'fr')
10        
11    Returns:
12        Översatt JSON-objekt med bevarad struktur
13    """
14    def translate_string(text, lang):
15        # I en riktig implementation skulle detta anropa ett översättnings-API
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        # Returnera nummer, booleska värden etc. oförändrade
35        return node
36    
37    return process_node(json_obj)
38
39# Exempelanvändning
40source_json = {
41    "user": {
42        "name": "Jane Smith",
43        "bio": "Mjukvaruutvecklare och bidragsgivare till öppen källkod",
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

Översätta JSON med PHP

1<?php
2/**
3 * Översätter JSON-struktur samtidigt som den ursprungliga strukturen bevaras
4 * 
5 * @param mixed $jsonObj Det parsade JSON-objektet
6 * @param string $targetLanguage Målspråkets kod
7 * @return mixed Det översatta JSON-objektet
8 */
9function translateJsonStructure($jsonObj, $targetLanguage) {
10    // Hjälpfunktion för att översätta en sträng
11    function translateString($text, $lang) {
12        // I en riktig implementation skulle detta anropa ett översättnings-API
13        return "[$lang] $text";
14    }
15    
16    // Rekursiv funktion för att bearbeta varje nod
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            // Kontrollera om det är en associativ array (objekt) eller indexerad array
28            if (array_keys($node) !== range(0, count($node) - 1)) {
29                // Associativ array (objekt)
30                $result = [];
31                foreach ($node as $key => $value) {
32                    $result[$key] = processNode($value, $lang);
33                }
34                return $result;
35            } else {
36                // Indexerad array
37                return array_map(function($item) use ($lang) {
38                    return processNode($item, $lang);
39                }, $node);
40            }
41        }
42        
43        // Returnera nummer, booleska värden etc. oförändrade
44        return $node;
45    }
46    
47    return processNode($jsonObj, $targetLanguage);
48}
49
50// Exempelanvändning
51$sourceJson = [
52    "company" => [
53        "name" => "Global Tech Solutions",
54        "description" => "Innovativt mjukvaruutvecklingsföretag",
55        "founded" => 2010,
56        "services" => ["Webbutveckling", "Mobilappar", "Molnlösningar"],
57        "active" => true
58    ]
59];
60
61$translatedJson = translateJsonStructure($sourceJson, "de");
62echo json_encode($translatedJson, JSON_PRETTY_PRINT);
63?>
64

Verkliga användningsfall

Lokaliseringsfilter för webbapplikationer

De flesta moderna ramverk som Next.js, React eller Vue lagrar översättningar i JSON-format. När du behöver lägga till ett nytt språk i din app står du inför ett val: manuellt kopiera och översätta varje nyckel (felbenäget), eller använda detta verktyg för att generera ett första utkast på några minuter.

Ett verkligt scenario: Din app har en.json med 200+ översättningsnycklar över kapslade kategorier—navigation, formulär, felmeddelanden, verktygstips. Du behöver franska och tyska versioner till nästa sprint.

Indata (en.json):

1{
2  "common": {
3    "welcome": "Välkommen till vår applikation",
4    "login": "Logga in",
5    "signup": "Registrera dig",
6    "errorMessages": {
7      "required": "Detta fält är obligatoriskt",
8      "invalidEmail": "Ange en giltig e-postadress"
9    }
10  }
11}
12

Översätt till franska, få fr.json med identisk struktur. Din kod fortsätter att referera till t('common.errorMessages.required') utan ändringar.

Det jag har funnit fungerar bra: Generera översättningar med detta verktyg, låt sedan en tvåspråkig teammedlem kontrollera tekniska termer och knappar. Detta fångar fall där "Skicka" kan behöva olika översättningar för "Skicka formulär" kontra "Skicka betalning."

API-svarslokalisering

Bygger du ett API som betjänar flera länder? Du behöver konsekventa svarsstrukturer över språk. Ett notifikations-API kan returnera:

1{
2  "status": "framgång",
3  "notification": {
4    "title": "Beställning skickad",
5    "message": "Din beställning #12345 har skickats",
6    "priority": 1,
7    "timestamp": 1678901234
8  }
9}
10

Din mobilapp tolkar notification.title och notification.message. Om den franska översättningen ändrar nyckelstrukturen, bryts appen för franska användare.

Detta verktyg säkerställer att notification.title förblir notification.title på varje språk, med endast strängvärdena översatta. Din klientkod fungerar identiskt över alla språk.

En begränsning att notera: Automatisk översättning förstår inte din domän. "Skickad" i e-handelssammanhang kan översättas annorlunda än i logistik- eller sjöfartssammanhang. För kundorienterade API:er, granska resultatet innan distribution.

Innehållsöversättning för Headless CMS

Headless CMS-plattformar som Contentful eller Strapi exporterar ofta innehåll som JSON. När du har 50 blogginlägg med strukturerad metadata (författare, taggar, URL:er för featuredbilder, publiceringsdatum), vill du översätta brödtext och titel utan att röra metadatan.

En typisk export inkluderar både innehållssträngar och konfiguration:

Innehåll: artikelbrödtext, rubrik, excerpt
Struktur: författar-ID:n, bildvägar, kategori-slugs, tidsstämplar

Manuell översättning riskerar att ändra en slug från teknologi till tecnología, vilket bryter din routing. Strukturbevarande översättning hanterar endast innehållsfälten.

Konfigurationsfiler för distribution i flera regioner

Distribuerar över regioner? Dina konfigurationsfiler kan behöva lokaliserade strängar medan endpoints, autentiseringsuppgifter och funktionsflaggor förblir identiska:

1{
2  "region": "eu-west",
3  "welcomeMessage": "Välkommen till vår tjänst",
4  "endpoint": "https://api.eu.example.com",
5  "retryAttempts": 3,
6  "features": {"darkMode": true}
7}
8

Översätt welcomeMessage till tyska medan endpoint, retryAttempts och features lämnas orörda.

Jämföra översättningsmetoder

Metod	Bäst för	Hastighet	Noggrannhet	Strukturbevarande	Kostnad
Detta verktyg	Snabb i18n-filgenerering, prototyper, interna verktyg	Omedelbart	Bra för standardinnehåll	100% bevarat	Gratis
Google Translate (kopiera/klistra)	Enskilda fraser, icke-teknisk text	Omedelbart	Varierande	Bryter JSON	Gratis
Professionell översättning	Kundorienterat innehåll, juridiska dokument, marknadsföring	Dagar	Utmärkt	Manuellt arbete krävs	$0.08-0.15/ord
Översättningshanteringssystem (Lokalise, Phrase)	Företagsappar, samarbetsarbetsflöden	Timmar-Dagar	Utmärkt med granskning	Inbyggt JSON-stöd	$$$+

När du ska använda detta verktyg: Projekt i tidigt skede, generera utkast för granskning, interna applikationer där perfekt översättning inte är kritiskt.

När du ska investera i professionell översättning: Kundorienterat innehåll, juridisk/efterlevnadstext, varumärkesmeddelanden eller när kulturell nyans är viktigare än hastighet.

Tekniska överväganden och gränsfallsscenarier

Vad som översätts (och vad som inte översätts)

Verktyget använder typkontroll för att avgöra vad som ska översättas:

✅ Översätts:

Strängvärden: "Welcome" → "Välkommen"
Strängar i arrayer: ["Hello", "World"] → ["Hej", "Världen"]
Strängar på vilken kapslingsnivå som helst

❌ Översätts inte:

Siffror: 42, 3.14, -10 förblir oförändrade
Booleska värden: true och false förblir som de är
Null: null förblir null
Objektnycklar: "userName" som nyckel förblir "userName"
Tomma strängar: "" förblir ""

Hantering av specialtecken

Unicode och Emoji Verktyget hanterar UTF-8 korrekt, så emoji och icke-latinska tecken fungerar bra:

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

Översätts till svenska som:

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

Escape-sekvenser JSON escape-sekvenser (\n, \t, \") bevaras:

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

\n förblir intakt vid översättning.

Platshållare Här är ett potentiellt problem: Om dina strängar innehåller platshållare som {username} eller %s, kan de översättas eller omkastas. I språk som arabiska eller hebreiska med höger-till-vänster-text kan platshållarpositioner förskjutas. Granska dessa noggrant.

Prestanda för stora JSON-filer

Det webbaserade verktyget hanterar typiska i18n-filer (under 500 KB) utan problem. För större datamängder:

500 KB - 2 MB: Fungerar men kan vara långsamt i webbläsaren
Över 2 MB: Överväg att dela upp i logiska delar (t.ex. separata filer per funktion eller avsnitt)

Webbläsarminnet är den begränsande faktorn, inte algoritmen i sig.

Vanliga frågor

Hur skiljer sig detta från att klistra in JSON i Google Translate?

Google Translate behandlar JSON som vanlig text, vilket innebär att den försöker översätta allt—inklusive nycklar, syntaxtecken och numeriska värden. Du får utdata som:

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

Observera hur "username" blev "nom d'utilisateur" och numret 25 blev strängen "vingt-cinq"? Din kod går sönder direkt.

Detta verktyg förstår JSON-strukturen och översätter endast strängvärden, och lämnar nycklar och andra datatyper intakta.

Kommer den att hantera djupt nästlade JSON med arrayer?

Ja. Den rekursiva algoritmen bearbetar varje nivå av nästning:

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

Den översätter alla strängvärden ("John", "Jane", "admin", "editor", "viewer") medan den bibehåller den exakta strukturen.

Vad händer om min JSON har både engelska och redan översatta innehåll?

Verktyget översätter alla strängar som den hittar, även om vissa redan är på målspråket. Om du lägger till nya nycklar i en befintlig översättningsfil, översätt endast den nya sektionen separat och slå sedan ihop resultaten.

Kan jag använda detta för i18next eller react-intl-filer?

Absolut. Utdatastrukturen matchar det som dessa ramverk förväntar sig. En i18next JSON-fil som:

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

Blir:

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

Dina t('translation.welcome') anrop fungerar oförändrade.

Hur exakt är automatisk översättning för tekniskt innehåll?

Det beror på sammanhanget:

Generell UI-text: "Spara", "Avbryt", "Skicka" → Vanligtvis exakt
Teknisk jargong: "webhook", "OAuth2", "idempotent" → Kan vara felöversatt eller lämnas som det är
Domänspecifika termer: "patient record" (medicinsk) vs "patient" (tålamod) → Sammanhang missas ofta

För produktionsappar, använd detta som ett första utkast och låt sedan någon granska tekniska och domänspecifika termer.

Hur är det med språk med olika teckenuppsättningar (kinesiska, arabiska, ryska)?

Verktyget hanterar Unicode korrekt, så alla teckenuppsättningar fungerar. En sak att vara uppmärksam på: Arabiska och hebreiska är höger-till-vänster (RTL), vilket kan påverka hur platshållare visas i översatta strängar. JSON-strukturen förblir korrekt, men granska den översatta texten för läsbarhet.

Kommer den att bevara min formatering (indrag, radbrytningar)?

Utdata är giltig JSON, men formatering (mellanrum, indrag) kan skilja sig från din inmatning. Om du behöver specifik formatering, kör utdata genom en JSON-formaterare med dina önskade inställningar.

Kan jag översätta konfigurationsvärden som URL:er eller API-nycklar?

Verktyget översätter alla strängar, inklusive URL:er och konfigurationsvärden. För att förhindra detta:

Dela upp din JSON i användargränssnittets innehåll och konfiguration
Översätt endast innehållssektionen
Låt konfigurationen vara oöversatt

Ännu bättre, strukturera dina filer för att separera översättbart innehåll från tekniska värden från början.

Är detta gratis? Finns det hastighetsgränser?

Webbverktyget är gratis för typisk användning. Mycket högvolymsöversättning (hundratals filer per minut) kan träffa hastighetsgränser på den underliggande översättningstjänsten. För de flesta utvecklingsarbetsflöden kommer du inte att stöta på några gränser.

Referenser och vidare läsning

För djupare förståelse av JSON-struktur, internationaliseringsstandarder och bästa praxis:

ECMA-404: JSON-dataöverföringsstandarden - Den officiella JSON-specifikationen från Ecma International som definierar standardformatet: ecma-international.org/publications-and-standards/standards/ecma-404/
MDN Web Docs: Arbeta med JSON - Mozillas omfattande guide till JSON-parsing, strängifiering och struktur: developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/JSON
W3C Internationalization (i18n) Aktivitet - Standarder och bästa praxis för webbinternationalisering: w3.org/International/
RFC 8259: JSON-dataöverföringsformatet - IETF-specifikation för JSON-syntax och semantik: datatracker.ietf.org/doc/html/rfc8259

Börja översätta dina JSON-filer

Behöver du snabbt generera översättningsfiler för din flerspråkiga applikation? Klistra in din JSON, välj ett målspråk och få strukturbevarande översättningar direkt. Fungerar med i18next, react-intl, vue-i18n och alla ramverk som förväntar sig konsekvent JSON-struktur mellan språk.

Börja översätta nu: