JSON Vertėjas, Išsaugantis Struktūrą | Nemokamas i18n Įrankis

Q: Koks tikslumas automatiškai verčiant techninį turinį?

Priklauso nuo konteksto: Bendras UI tekstas: „Išsaugoti", „Atšaukti", „Pateikti" → Paprastai tikslūs Techninis žargonas: „webhook", „OAuth2", „idempotent" → Gali būti neteisingai išversti arba palikti originalo kalba Specifinės srities terminai: „paciento įrašas" (medicinos) vs „pacientas" (kantrybė) → Kontekstas dažnai praleidžiamas Gamybinėms programėlėms naudokite tai kaip pirminį variantą, tada tegul kas nors peržiūri techninius ir specifinės srities terminus.

Kas yra JSON struktūrą išsaugantis vertėjas?

Ar kada nors bandėte nukopijuoti JSON į „Google Translate" ir gavote sugadintus raktus, trūkstančius skliaustus ar iškreiptą sintaksę? Būtent šią problemą sprendžia šis įrankis.

JSON struktūrą išsaugantis vertėjas konvertuoja eilučių reikšmes jūsų JSON objektuose į kitą kalbą, tuo pačiu paliekant viską kitą nepakeista — raktai išlieka tie patys, skaičiai išlieka skaičiais, loginės reikšmės išlieka loginėmis, o jūsų įdėtinė struktūra nesugriūva.

Štai kas šį įrankį daro skirtingą nuo įprastinių vertimo įrankių: kai verčiate tipinį i18n failą su 50+ įdėtinių raktų, jums reikia, kad struktūra išliktų tokia pati, kad jūsų kodas vis dar galėtų nukreipti į user.profile.displayName ispaniškai, prancūziškai ar japoniškai. Sulaužykite tą struktūrą, ir jūs valandas ieškote klaidų.

Šis įrankis automatiškai tvarko rekursinį perėjimą, identifikuodamas, kurios eilutės turi būti išverstos, o kurie elementai (pvz., API raktai, konfigūracijos reikšmės ar skaitmeniniai ID) turi likti lygiai tokie, kokie yra.

Kaip veikia JSON struktūros išsaugojimas

Kodėl struktūros išsaugojimas yra svarbus

Dirbant su JSON vertimu, paprastai susiduriama su vienu iš šių scenarijų:

i18n failai, kur jūsų programa tikisi, kad en.json ir fr.json turėtų identiškas raktus
API atsakymai, kuriems reikia nuoseklios struktūros įvairiomis kalbomis kliento analizei
Konfigūraciniai failai, kur rakto pavadinimo pakeitimas sugadina visą programą
Duomenų bazės eksportai, kur ryšiai priklauso nuo konkrečių laukų pavadinimų

Iššūkis: JSON nėra tik tekstas. Tai struktūruoti duomenys su schema, kuria jūsų kodas pasikliauja. Pakeitus "userName" į "nombreUsuario" vertimo metu, jūsų programa išmes undefined klaidą.

Kaip veikia vertimo procesas

Štai kas vyksta po kapotą, kai verčiate JSON:

1. Analizė ir Patvirtinimas Įrankis pirmiausiai patikrina JSON sintaksę. Jei trūksta kablelio ar yra papildomas skliaustelis, gausite aiškią klaidos žinutę dar prieš pradedant vertimą - tai apsaugo nuo sugadinto išvesties formato.

2. Rekursinis Naršymas Pradedant nuo šaknies, algoritmas eina per kiekvieną JSON medžio mazgą. Kiekvienam elementui tikrina duomenų tipą:

Eilutė? Įtraukti į vertimo eilę
Skaičius, loginė reikšmė, tuščia? Praleisti visiškai
Objektas ar masyvas? Rekursiškai eiti gilyn

3. Tipo Saugus Vertimas Tik eilučių reikšmės siunčiamos į vertimo API. Jūsų "quantity": 42 lieka 42, o ne "keturiasdešimt du". Jūsų "isActive": true išlieka true, o ne "tiesa".

4. Raktų Išsaugojimas Visi objektų raktai išlieka originalioje kalboje. Tai kritiškai svarbu, nes translations.header.welcomeMessage turi būti tas pats kelias kiekviename kalbos faile.

5. Struktūros Surinkimas Išversti tekstai grąžinami į tiksliai tas pačias vietas, išlaikant visus įdėjimo lygius, masyvo indeksus ir objektų hierarchijas.

Įprastas spąstai: Kai kurie kūrėjai bando JSON.stringify() objektą, išversti visą eilutę, o paskui vėl parsinti. Tai sugadina, nes vertėjas keičia raktus, skliaustelius ir sintaksę. Rekursinis metodas tai visiškai išvengia.

JSON Struktūros Išlaikymo Vertėjo Naudojimas

Žingsnis po Žingsnio Vadovas

1. Įklijuokite Savo JSON Nukopijuokite savo JSON objektą ir įklijuokite jį į kairįjį skydelį. Įrankis tvarko bet kokį galiojantį JSON - nesvarbu, ar tai paprastas objektas su 5 raktais, ar giliai įdėtas struktūra su masyvais ir keliais lygiais.

2. Pasirinkite Tikslinę Kalbą Pasirinkite iš kalbų išskleidžiamojo meniu: ispanų, prancūzų, vokiečių, italų, portugalų, kinų, japonų, korėjiečių, rusų ir kt. Jei verčiate i18next projektui, suderinkite kalbos kodą, kurio tikisi jūsų karkasas.

3. Gaukite Momentinį Vertimą Išverstas rezultatas automatiškai pasirodo dešiniajame skydelyje. Jokio "Versti" mygtuko nereikia - apdorojama iš karto, kai turite galiojantį JSON ir pasirinktą kalbą.

4. Nukopijuokite ir Naudokite Spustelėkite "Kopijuoti" mygtuką, kad gautumėte išverstą JSON. Jis paruoštas tiesiogiai įklijuoti į jūsų projektą - jokio valymo nereikia.

5. Išvalykite Kitam Vertimui Spustelėkite "Išvalyti viską", kai būsite pasiruošę versti kitą failą. Įrankis iš karto atstatys abu skydelius.

Dažniausios Problemos ir Sprendimai

"Netinkamas JSON Formatas" Klaida Tai pamatysite, kai yra sintaksės problema. Dažniausi kaltininkai:

Trūksta kablelio tarp rakto-reikšmės porų
Kableliu užbaigtas paskutinis elementas (galioja JavaScript, bet ne JSON)
Viengubi kabučių ženklai vietoj dvigubų
Neapsaugoti specialūs simboliai eilutėse

Greitas sprendimas: Paleiskite savo JSON per tikrintuvą, pvz., JSONLint, prieš įklijuojant.

Vertimas Nepavyksta Tyliai Jei išvesties skydelis lieka tuščias:

Patikrinkite interneto ryšį - vertimui reikia API prieigos
Patikrinkite, ar pasirinkote tikslinę kalbą
Pabandykite su mažesniu JSON fragmentu, kad izoliuotumėte problemą

Netikėti Rezultatai Vertime Mašininis vertimas gerai veikia standartinėms frazėms, bet sunkiai susidoroja su:

Technine terminija ar specifinės srities terminais
Prekių pavadinimais (kurie dažnai turėtų likti neišversti)
Vietų žymėjimo sintakse, pvz., {{username}} arba %s

Gamybinėms programėlėms naudokite šį įrankį kaip pirminį variantą, o paskui paprašykite gimtosios kalbos specialisto peržiūrėti specifinę ar klientams skirtą turinį.

Profesionalūs Patarimai Geresnėms Išvadoms

Laikykite Techninius Tekstus Atskirai Jei jūsų JSON maišo vartotojams skirtą tekstą su techniniais identifikatoriais, apsvarstykite juos atskirti. Pavyzdžiui:

1{
2  "display": {"welcome": "Sveiki sugrįžę"},
3  "config": {"apiKey": "abc123", "endpoint": "https://api.example.com"}
4}
5

Atskirai išverskite display objektą, kad išvengtumėte atsitiktinio config verčių apdorojimo.

Naudokite Kontekstą Eilutėse "Pateikti" gali skirtingai išsiversti priklausomai nuo konteksto. "Pateikti formą" arba "Pateikti mokėjimą" suteikia vertėjams (žmonėms ar mašinoms) geresnį kontekstą tiksliam vertimui.

Testuokite Su Tikrais Duomenimis Prieš išverčiant visą i18n failą su 500+ raktų, išbandykite su mažu pavyzdžiu, kuriame yra visi jūsų duomenų tipai - eilutės, skaičiai, įdėti objektai, masyvai.

Kodo pavyzdžiai

JSON vertimas naudojant JavaScript

1// Pavyzdys, kaip galėtumėte įgyvendinti panašią funkciją JavaScript
2function translateJsonStructure(jsonObj, targetLanguage) {
3  // Pagalbinė funkcija eilutės vertimui
4  function translateString(str, lang) {
5    // Tikrame įgyvendinime, tai iškviestų vertimo API
6    return `[${lang}] ${str}`;
7  }
8  
9  // Rekursinė funkcija JSON struktūros perėjimui ir vertimui
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    // Grąžinti skaičius, loginius kintamuosius ir kt. nepakeistus
30    return node;
31  }
32  
33  return processNode(jsonObj);
34}
35
36// Naudojimo pavyzdys
37const sourceJson = {
38  "product": {
39    "name": "Belaidės ausinės",
40    "description": "Aukštos kokybės belaidės ausinės su triukšmo slopinimu",
41    "features": ["Bluetooth 5.0", "40 valandų baterijos veikimo laikas", "Sulankstomas dizainas"],
42    "price": 99.99,
43    "inStock": true
44  }
45};
46
47const translatedJson = translateJsonStructure(sourceJson, "es");
48console.log(JSON.stringify(translatedJson, null, 2));
49

JSON vertimas naudojant Python

1import json
2
3def translate_json_structure(json_obj, target_language):
4    """
5    Verčia eilučių reikšmes JSON objekte išlaikant struktūrą.
6    
7    Args:
8        json_obj: Parsintas JSON objektas
9        target_language: Tikslinės kalbos kodas (pvz., 'es', 'fr')
10        
11    Returns:
12        Išverstas JSON objektas su išlaikyta struktūra
13    """
14    def translate_string(text, lang):
15        # Tikrame įgyvendinime, tai iškviestų vertimo 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        # Grąžinti skaičius, loginius kintamuosius ir kt. nepakeistus
35        return node
36    
37    return process_node(json_obj)
38
39# Naudojimo pavyzdys
40source_json = {
41    "user": {
42        "name": "Jane Smith",
43        "bio": "Programinės įrangos kūrėja ir atvirojo kodo bendraautorė",
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 vertimas naudojant PHP

1<?php
2/**
3 * Verčia JSON struktūrą išlaikant originalią struktūrą
4 * 
5 * @param mixed $jsonObj Parsintas JSON objektas
6 * @param string $targetLanguage Tikslinės kalbos kodas
7 * @return mixed Išverstas JSON objektas
8 */
9function translateJsonStructure($jsonObj, $targetLanguage) {
10    // Pagalbinė funkcija eilutės vertimui
11    function translateString($text, $lang) {
12        // Tikrame įgyvendinime, tai iškviestų vertimo API
13        return "[$lang] $text";
14    }
15    
16    // Rekursinė funkcija kiekvieno mazgo apdorojimui
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            // Patikrinti, ar tai asociatyvus masyvas (objektas) ar indeksuotas masyvas
28            if (array_keys($node) !== range(0, count($node) - 1)) {
29                // Asociatyvus masyvas (objektas)
30                $result = [];
31                foreach ($node as $key => $value) {
32                    $result[$key] = processNode($value, $lang);
33                }
34                return $result;
35            } else {
36                // Indeksuotas masyvas
37                return array_map(function($item) use ($lang) {
38                    return processNode($item, $lang);
39                }, $node);
40            }
41        }
42        
43        // Grąžinti skaičius, loginius kintamuosius ir kt. nepakeistus
44        return $node;
45    }
46    
47    return processNode($jsonObj, $targetLanguage);
48}
49
50// Naudojimo pavyzdys
51$sourceJson = [
52    "company" => [
53        "name" => "Globalūs technologijų sprendimai",
54        "description" => "Inovatyvi programinės įrangos kūrimo įmonė",
55        "founded" => 2010,
56        "services" => ["Interneto svetainių kūrimas", "Mobiliosios programėlės", "Debesų sprendimai"],
57        "active" => true
58    ]
59];
60
61$translatedJson = translateJsonStructure($sourceJson, "de");
62echo json_encode($translatedJson, JSON_PRETTY_PRINT);
63?>
64

Realūs Naudojimo Atvejai

Žiniatinklio Programėlių i18n Failai

Dauguma šiuolaikinių karkasų, tokių kaip Next.js, React ar Vue, laiko vertimus JSON formatu. Kai reikia pridėti naują kalbą į programėlę, jūs susiduriate su pasirinkimu: rankiniu būdu kopijuoti ir versti kiekvieną raktą (klaidinga), arba naudoti šį įrankį, kad per kelias minutes sugeneruotumėte pirminį variantą.

Realus scenarijus: Jūsų programėlėje yra en.json su 200+ vertimo raktų įvairiose įdėtinėse kategorijose—navigacija, formos, klaidų pranešimai, paaiškinamieji užrašai. Jums reikia prancūzų ir vokiečių versijų iki kito sprinTo.

Įvestis (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

Išverskite į prancūzų kalbą, gaukite fr.json su tokia pačia struktūra. Jūsų kodas vis dar nukreipia į t('common.errorMessages.required') be pakeitimų.

Kas, mano nuomone, veikia gerai: Sugeneruokite vertimus šiuo įrankiu, tada paprašykite dvikalbio komandos nario patikrinti techninius terminus ir mygtukų užrašus. Tai padeda aptikti atvejus, kai "Submit" gali reikėti skirtingų vertimų "Pateikti formą" ar "Pateikti mokėjimą."

API Atsako Lokalizacija

Kuriate API, kuris aptarnauja kelias šalis? Jums reikia nuoseklių atsakų struktūrų visomis kalbomis. Pranešimų API gali grąžinti:

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

Jūsų mobilioji programėlė analizuoja notification.title ir notification.message. Jei prancūziškas vertimas pakeičia rakto struktūrą, programėlė sugenda prancūziškiems vartotojams.

Šis įrankis užtikrina, kad notification.title išlieka notification.title kiekvienoje kalboje, keičiantis tik eilučių reikšmėms. Jūsų kliento kodas veikia identiškai visose lokalėse.

Vienas apribojimas, kurį reikia pažymėti: Automatinis vertimas nesupranta jūsų domeno. "Shipped" elektroninės prekybos kontekste gali būti verčiamas kitaip nei logistikos ar jūrų transporto kontekste. Klientams skirtoms API, peržiūrėkite išvestį prieš diegiant.

Headless CMS Turinio Vertimas

Headless CMS platformos, tokios kaip Contentful ar Strapi, dažnai eksportuoja turinį kaip JSON. Kai turite 50 tinklaraščio įrašų su struktūrizuotais metaduomenimis (autorius, žymos, pagrindinių vaizdų URL, publikavimo datos), norite išversti tekstą ir antraštę neliečiant metaduomenų.

Tipinis eksportas apima ir turinio eilutes, ir konfigūraciją:

Turinys: straipsnio tekstas, antraštė, ištrauka
Struktūra: autorių ID, vaizdų keliai, kategorijų trumpiniai, laiko žymos

Rankinis vertimas kelia riziką pakeisti trumpinį iš technology į tecnología, sulaužant maršrutizavimą. Struktūrą išsaugantis vertimas tvarko tik turinio laukus.

Konfigūracijos Failai Kelių Regionų Diegimams

Diegiate keliuose regionuose? Jūsų konfigūracijos failai gali reikalauti lokalizuotų eilučių, išlaikant galutinius taškus, kredencialus ir funkcijų vėliavėles nepakeistus:

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

Išverskite welcomeMessage į vokiečių kalbą, palikdami endpoint, retryAttempts ir features nepakeistus.

Vertimo metodų palyginimas

Metodas	Tinka Geriausiai	Greitis	Tikslumas	Struktūros Apsauga	Kaina
Šis Įrankis	Greitas i18n failų generavimas, prototipai, vidiniai įrankiai	Momentinis	Geras standartiniam turiniui	100% išsaugotas	Nemokama
Google Vertėjas (kopijuoti/įklijuoti)	Atskiros frazės, netechninis tekstas	Momentinis	Kintamas	Suardo JSON	Nemokama
Profesionalus Vertimas	Klientams skirti tekstai, teisiniai dokumentai, rinkodara	Dienos	Puikus	Reikalingas rankinis darbas	$0.08-0.15/žodis
Vertimo Valdymo Sistemos (Lokalise, Phrase)	Įmonių programėlės, bendradarbiavimo darbo eigos	Valandos-Dienos	Puikus su peržiūra	Integruota JSON parama	$$$+

Kada naudoti šį įrankį: Ankstyvosios projekto stadijos, juodraščių generavimas peržiūrai, vidinės programėlės, kur tobulas vertimas nėra kritiškai svarbus.

Kada investuoti į profesionalų vertimą: Klientams skirti tekstai, teisiniai/atitikties dokumentai, prekės ženklo pranešimai arba kai kultūriniai atspalviai yra svarbesni už greitį.

Techniniai Aspektai ir Kraštutiniai Atvejai

Kas Verčiama (ir Kas Ne)

Įrankis naudoja tipo patikrinimą, kad nustatytų, ką versti:

✅ Verčiama:

Eilučių reikšmės: "Welcome" → "Sveiki"
Eilutės masyve: ["Hello", "World"] → ["Sveiki", "Pasaulis"]
Eilutės bet kokiame įdėties lygyje

❌ Neverčiama:

Skaičiai: 42, 3.14, -10 lieka nepakitę
Loginės reikšmės: true ir false lieka tokios pat
Null: null išlieka null
Objektų raktai: "userName" kaip raktas lieka "userName"
Tuščios eilutės: "" lieka ""

Specialių Simbolių Tvarkymas

Unikodas ir Emoji Įrankis tinkamai tvarko UTF-8, todėl emoji ir ne lotynų simboliai veikia gerai:

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

Išverčiama į lietuvių kalbą kaip:

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

Escape Sekos JSON escape sekos (\n, \t, \") išsaugomos:

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

\n išlieka nepakitęs vertime.

Vietos rezervavimo ženklai Štai galima problema: Jei jūsų eilutėse yra vietos rezervavimo ženklų kaip {username} ar %s, jie gali būti išversti arba pertvarkomi. Kalbose su dešinės į kairę rašymo kryptimi, vietos rezervavimo ženklų padėtys gali pasikeisti. Peržiūrėkite juos atidžiai.

Didelių JSON Failų Našumas

Žiniatinklio įrankis tvarko tipinius i18n failus (iki 500KB) be problemų. Didesniems duomenų rinkiniams:

500KB - 2MB: Veikia, bet gali būti lėtas naršyklėje
Virš 2MB: Apsvarstykite skaidymą į logines dalis (pvz., atskiri failai pagal funkciją ar skyrių)

Naršyklės atmintis yra ribojantis veiksnys, o ne pats algoritmas.

Dažniausiai užduodami klausimai

Kuo tai skiriasi nuo JSON įkėlimo į „Google Translate"?

„Google Translate" traktuoja JSON kaip paprastą tekstą, tai reiškia, kad bando išversti viską – įskaitant raktus, sintaksės simbolius ir skaitinius verčių. Gausite išvestį, pvz.:

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

Pastebėkite, kaip "username" tapo "nom d'utilisateur", o skaičius 25 tapo eilute "vingt-cinq"? Jūsų kodas iš karto sugenda.

Šis įrankis supranta JSON struktūrą ir išverčia tik eilučių vertes, palikdamas raktus ir kitus duomenų tipus nepakeistus.

Ar jis tvarkys giliai įdėtą JSON su masyvais?

Taip. Rekursinis algoritmas apdoroja kiekvieną įdėjimo lygį:

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

Jis išverčia visas eilučių vertes ("John", "Jane", "admin", "editor", "viewer"), išlaikydamas tikslią struktūrą.

Kas bus, jei mano JSON turi ir anglišką, ir jau išverstą turinį?

Įrankis išverčia visas eilutes, kurias randa, net jei kai kurios jau yra tikslinėje kalboje. Jei pridėsite naujus raktus prie esamo vertimo failo, atskirai išverskite tik naują dalį, tada sujunkite rezultatus.

Ar galiu naudoti tai i18next ar react-intl failams?

Absoliučiai. Išvesties struktūra atitinka to, ko šios sistemos tikisi. i18next JSON failas, pvz.:

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

Tampa:

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

Jūsų t('translation.welcome') iškvietimai išlieka nepakitę.

Koks tikslumas automatiškai verčiant techninį turinį?

Priklauso nuo konteksto:

Bendras UI tekstas: „Išsaugoti", „Atšaukti", „Pateikti" → Paprastai tikslūs
Techninis žargonas: „webhook", „OAuth2", „idempotent" → Gali būti neteisingai išversti arba palikti originalo kalba
Specifinės srities terminai: „paciento įrašas" (medicinos) vs „pacientas" (kantrybė) → Kontekstas dažnai praleidžiamas

Gamybinėms programėlėms naudokite tai kaip pirminį variantą, tada tegul kas nors peržiūri techninius ir specifinės srities terminus.

O kaip su kalbomis, turinčiomis skirtingus rašmenis (kinų, arabų, rusų)?

Įrankis tinkamai tvarko „Unicode", tad visos rašmenų sistemos veikia. Į ką reikia atkreipti dėmesį: arabų ir hebrajų kalbos rašomos iš dešinės į kairę (RTL), kas gali paveikti išverstų eilučių vietos žymes. JSON struktūra išlieka teisinga, bet peržiūrėkite išverstą tekstą skaitomumui.

Ar išsaugos mano formatavimą (įtraukas, eilučių lūžius)?

Išvestis yra tinkamas JSON, bet formatavimas (tarpai, įtraukos) gali skirtis nuo jūsų įvesties. Jei reikia specifinio formatavimo, paleiskite išvestį per JSON formatuoklę su jūsų pasirinktais nustatymais.

Ar galima išversti konfigūracijos vertes, pvz., URL ar API raktus?

Įrankis išverčia visas eilutes, įskaitant URL ir konfigūracijos vertes. Kad to išvengti:

Padalinkite JSON į vartotojo matomą turinį ir konfigūraciją
Išverskite tik turinio dalį
Palikite konfigūraciją neišverstą

Dar geriau, iš pat pradžių struktūruokite failus taip, kad atskirtumėte verčiamą turinį nuo techninių verčių.

Ar tai nemokama? Ar yra apribojimų?

Žiniatinklio įrankis nemokamas įprastam naudojimui. Labai didelis vertimų kiekis (šimtai failų per minutę) gali pasiekti ribas pagrindiniame vertimo servise. Daugumai kūrimo darbo eigų, ribų nebus pasiekta.

Nuorodos ir papildoma literatūra

Gilesniam JSON struktūros, internacionalizacijos standartų ir geriausių praktikų supratimui:

ECMA-404: JSON duomenų mainų sintaksė - Oficiali JSON specifikacija, kurią pateikė Ecma International, apibrėžianti standartinį formatą: ecma-international.org/publications-and-standards/standards/ecma-404/
MDN Web Dokumentai: Darbas su JSON - Išsami „Mozilla" gairė apie JSON analizę, eilučių kūrimą ir struktūrą: developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/JSON
W3C Internacionalizacijos (i18n) veikla - Standartai ir geriausios praktikos interneto internacionalizacijai: w3.org/International/
RFC 8259: JSON duomenų mainų formatas - IETF specifikacija JSON sintaksei ir semantikai: datatracker.ietf.org/doc/html/rfc8259

Pradėkite versti savo JSON failus

Reikia greitai sugeneruoti vertimo failus savo daugiakalbei programai? Įklijuokite savo JSON, pasirinkite tikslinę kalbą ir iš karto gaukite struktūrą išsaugančius vertimus. Veikia su i18next, react-intl, vue-i18n ir bet kokia sistema, kuri tikisi nuoseklios JSON struktūros įvairiomis kalbomis.

Pradėkite vertimą dabar: