JSON tulkotājs, kas saglabā struktūru | Bezmaksas i18n rīks

Q: Cik precīza ir automatizētā tulkošana tehniskam saturam?

Tas ir atkarīgs no konteksta: Vispārīgs UI teksts: "Save", "Cancel", "Submit" → Parasti precīzi Tehniskā terminoloģija: "webhook", "OAuth2", "idempotent" → Var tikt nepareizi iztulkoti vai atstāti nemainīti Nozarei specifiski termini: "patient record" (medicīnā) pret "patient" (pacietība) → Konteksts bieži netiek saprasts Ražošanas lietotnēm izmantojiet šo kā pirmo piegājienu, pēc tam lieciet kādam pārskatīt tehniskos un nozarei specifiskos terminus.

Kas ir JSON struktūru saglabājošs tulkotājs?

Vai kādreiz mēģinājāt ielīmēt JSON Google Translate un rezultātā ieguva bojātus atslēgvārdus, pazudušus iekavus vai sabojātu sintaksi? Tieši šo problēmu šis rīks risina.

JSON struktūru saglabājošs tulkotājs pārveido virkņu vērtības jūsu JSON objektos uz citu valodu, vienlaikus atstājot visu pārējo neskartu — atslēgas paliek tādas pašas, skaitļi paliek skaitļi, Buļļi paliek Buļļi, un jūsu ligzdotā struktūra nesabrūk.

Lūk, kas šo atšķir no parastiem tulkošanas rīkiem: kad tulkojat tipisko i18n failu ar 50+ ligzdotām atslēgām, jums ir nepieciešams, lai struktūra paliktu identiska, lai jūsu kods joprojām varētu atsaukties uz user.profile.displayName spāņu, franču vai japāņu valodā. Salauziet šo struktūru, un jūs stundām ilgi meklēsiet kļūdas.

Šis rīks automātiski veic rekursīvu šķērsošanu, identificējot, kuras virknes ir jātulko un kuri elementi (piemēram, API atslēgas, konfigurācijas vērtības vai skaitliskie ID) ir jāatstāj tieši tādi, kādi tie ir.

Kā darbojas JSON struktūras saglabāšana

Kāpēc struktūras saglabāšana ir svarīga

Strādājot ar JSON tulkošanu, jūs parasti sastopaties ar vienu no šiem scenārijiem:

i18n faili, kur jūsu lietotne sagaida, ka en.json un fr.json saturēs identiskus atslēgvārdus
API atbildes, kurām nepieciešama konsekventa struktūra starp valodām klienta parsēšanai
Konfigurācijas faili, kur atslēgas nosaukuma maiņa salauž visu lietotni
Datu bāzes eksporti, kur attiecības ir atkarīgas no specifiskiem lauku nosaukumiem

Izaicinājums: JSON nav tikai teksts. Tā ir strukturēta informācija ar shēmu, uz kuru jūsu kods paļaujas. Mainot "userName" uz "nombreUsuario" tulkošanas laikā, jūsu lietotne izmetīs undefined kļūdu.

Kā darbojas tulkošanas process

Šeit notiek darbības zem pārsega:

1. Parsēšana un validācija Rīks vispirms pārbauda JSON sintaksi. Ja trūkst komata vai ir lieks iekavs, jūs saņemsiet skaidru kļūdas paziņojumu pirms tulkošanas sākuma — pasargājot jūs no bojātas izejas.

2. Rekursīva traversēšana Sākot no saknes, algoritms iet cauri katram mezglam JSON kokā. Katram elementam tas pārbauda datu tipu:

Virkne? Ielikt tulkošanas rindā
Skaitlis, Booleans, null? Pilnībā izlaist
Objekts vai masīvs? Rekursīvi ieiet tajā

3. Tipam droša tulkošana Tikai virkņu vērtības tiek sūtītas tulkošanas API. Jūsu "quantity": 42 paliek kā 42, nevis "četrdesmit divi". Jūsu "isActive": true paliek true, nevis "patiess".

4. Atslēgu saglabāšana Visas objektu atslēgas paliek to oriģinālajā valodā. Tas ir kritiski, jo translations.header.welcomeMessage jābūt vienādam ceļam katrā valodas failā.

5. Struktūras pārsalikšana Iztulkotās virknes tiek ievietotas atpakaļ tieši tajās pašās pozīcijās, saglabājot visus ligzdošanas līmeņus, masīvu indeksus un objektu hierarhijas.

Izplatīta kļūda: Daži izstrādātāji mēģina JSON.stringify() objektu, iztulkot visu virkni, tad atkal to parsēt. Tas salauž, jo tulkotājs modificē atslēgas, iekavas un sintaksi. Rekursīvā pieeja to pilnībā izvairās.

JSON Struktūras Saglabājošā Tulkotāja Izmantošana

Pakāpeniska Rokasgrāmata

1. Ielīmēt JSON Nokopējiet savu JSON objektu un ielīmējiet to kreisajā panelī. Rīks apstrādā jebkuru derīgu JSON — vai tas būtu vienkāršs objekts ar 5 atslēgām, vai dziļi ligzdots struktūra ar masīviem un vairākiem līmeņiem.

2. Izvēlēties Mērķvalodu Izvēlieties no valodu nolaižamā saraksta: spāņu, franču, vācu, itāļu, portugāļu, ķīniešu, japāņu, korejiešu, krievu un citas. Ja tulkojat i18next projektu, saskaņojiet valodas kodu ar jūsu ietvara gaidāmo kodu.

3. Saņemt Momentālu Tulkojumu Tulkotais rezultāts parādās automātiski labajā panelī. Nav nepieciešama "Tulkot" poga — tas tiek apstrādāts uzreiz, līdzko ir derīgs JSON un izvēlēta valoda.

4. Kopēt un Izmantot Noklikšķiniet uz "Kopēt" pogas, lai iegūtu tulkoto JSON. Tas ir gatavs tieši ielīmēšanai projektā — nav nepieciešama tīrīšana.

5. Notīrīt Nākamajai Tulkošanai Nospiediet "Notīrīt Visu", kad esat gatavs tulkot citu failu. Rīks momentāni atiestatīs abas rūtis.

Bieži Sastopamās Problēmas un Risinājumi

"Nederīgs JSON Formāts" Kļūda Jūs to redzēsiet, ja ir sintakses problēma. Biežākie vaininieki:

Trūkstoša komata starp atslēgas-vērtības pāriem
Aizmugurējā komata pēc pēdējā elementa (derīga JavaScript, bet ne JSON)
Vienkāršās pēdiņas vietā divkāršās pēdiņas
Neekranēti speciālie rakstzīmes virknēs

Ātrs risinājums: Palaidiet savu JSON caur validatoru kā JSONLint pirms ielīmēšanas.

Tulkošana Klusām Neizdevās Ja izvades panelis paliek tukšs:

Pārbaudiet interneta savienojumu — tulkošanai nepieciešama API piekļuve
Pārliecinieties, ka esat izvēlējies mērķvalodu
Mēģiniet ar mazāku JSON fragmentu, lai izolētu problēmu

Negaidīti Rezultāti Tulkošanā Mašīntulkošana labi darbojas standarta frāzēm, bet saskaras ar grūtībām:

Tehniskais žargons vai nozarei specifiski termini
Zīmolu nosaukumi (kuri bieži jāatstāj netulkoti)
Viettura sintakse kā {{username}} vai %s

Ražošanas lietojumprogrammām izmantojiet šo rīku kā pirmo pārlaidi, pēc tam lūdziet dzimtās valodas runātāju pārskatīt nozarei specifisko vai klientam paredzēto saturu.

Profesionāli Padomi Labākiem Rezultātiem

Saglabāt Tehniskās Virknes Atsevišķi Ja jūsu JSON sajauc lietotājam redzamo tekstu ar tehniskajiem identifikatoriem, apsveriet to sadalīšanu. Piemēram:

1{
2  "display": {"welcome": "Laipni lūdzam atpakaļ"},
3  "config": {"apiKey": "abc123", "endpoint": "https://api.example.com"}
4}
5

Tulkojiet display objektu atsevišķi, lai izvairītos no nejaušas config vērtību apstrādes.

Izmantot Kontekstu Virknēs "Iesniegt" varētu tulkoties atšķirīgi atkarībā no konteksta. "Iesniegt formu" vai "Iesniegt maksājumu" sniedz tulkotājiem (cilvēkiem vai mašīnām) labāku kontekstu precīzam tulkojumam.

Testēt ar Reāliem Datiem Pirms tulkot visu savu i18n failu ar 500+ atslēgām, pārbaudiet ar mazu paraugu, kas ietver visus jūsu datu tipus — virknes, skaitļus, ligzdotus objektus, masīvus.

Kodu piemēri

JSON tulkošana ar JavaScript

1// Piemērs, kā varētu īstenot līdzīgu funkcionalitāti JavaScript
2function translateJsonStructure(jsonObj, targetLanguage) {
3  // Palīgfunkcija virknes tulkošanai
4  function translateString(str, lang) {
5    // Reālā realizācijā tas izsauktu tulkošanas API
6    return `[${lang}] ${str}`;
7  }
8  
9  // Rekursīva funkcija JSON traversēšanai un tulkošanai
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    // Atgriež skaitļus, būla vērtības u.c. nemainītas
30    return node;
31  }
32  
33  return processNode(jsonObj);
34}
35
36// Lietošanas piemērs
37const sourceJson = {
38  "product": {
39    "name": "Bezvadu austiņas",
40    "description": "Augstas kvalitātes bezvadu austiņas ar trokšņu slāpēšanu",
41    "features": ["Bluetooth 5.0", "40 stundu baterijas darbības laiks", "Salokāms dizains"],
42    "price": 99.99,
43    "inStock": true
44  }
45};
46
47const translatedJson = translateJsonStructure(sourceJson, "es");
48console.log(JSON.stringify(translatedJson, null, 2));
49

JSON tulkošana ar Python

1import json
2
3def translate_json_structure(json_obj, target_language):
4    """
5    Tulko virknes vērtības JSON objektā, saglabājot struktūru.
6    
7    Args:
8        json_obj: Parsētais JSON objekts
9        target_language: Mērķvalodas kods (piem., 'es', 'fr')
10        
11    Returns:
12        Tulkots JSON objekts ar saglabātu struktūru
13    """
14    def translate_string(text, lang):
15        # Reālā realizācijā tas izsauktu tulkošanas 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        # Atgriež skaitļus, būla vērtības u.c. nemainītas
35        return node
36    
37    return process_node(json_obj)
38
39# Lietošanas piemērs
40source_json = {
41    "user": {
42        "name": "Jānis Kalniņš",
43        "bio": "Programmatūras izstrādātājs un atvērtā pirmkoda līdzdalībnieks",
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 tulkošana ar PHP

1<?php
2/**
3 * Tulko JSON struktūru, saglabājot sākotnējo struktūru
4 * 
5 * @param mixed $jsonObj Parsētais JSON objekts
6 * @param string $targetLanguage Mērķvalodas kods
7 * @return mixed Tulkotais JSON objekts
8 */
9function translateJsonStructure($jsonObj, $targetLanguage) {
10    // Palīgfunkcija virknes tulkošanai
11    function translateString($text, $lang) {
12        // Reālā realizācijā tas izsauktu tulkošanas API
13        return "[$lang] $text";
14    }
15    
16    // Rekursīva funkcija katra mezgla apstrādei
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            // Pārbauda, vai tā ir asociatīvā masīvs (objekts) vai indeksētais masīvs
28            if (array_keys($node) !== range(0, count($node) - 1)) {
29                // Asociatīvais masīvs (objekts)
30                $result = [];
31                foreach ($node as $key => $value) {
32                    $result[$key] = processNode($value, $lang);
33                }
34                return $result;
35            } else {
36                // Indeksētais masīvs
37                return array_map(function($item) use ($lang) {
38                    return processNode($item, $lang);
39                }, $node);
40            }
41        }
42        
43        // Atgriež skaitļus, būla vērtības u.c. nemainītas
44        return $node;
45    }
46    
47    return processNode($jsonObj, $targetLanguage);
48}
49
50// Lietošanas piemērs
51$sourceJson = [
52    "company" => [
53        "name" => "Globālās Tehnoloģiju Risinājumi",
54        "description" => "Inovatīva programmatūras izstrādes kompānija",
55        "founded" => 2010,
56        "services" => ["Tīmekļa izstrāde", "Mobilo lietotņu izstrāde", "Mākoņrisinājumi"],
57        "active" => true
58    ]
59];
60
61$translatedJson = translateJsonStructure($sourceJson, "de");
62echo json_encode($translatedJson, JSON_PRETTY_PRINT);
63?>
64

Reāli pasaules lietošanas gadījumi

Tīmekļa lietojumprogrammu i18n faili

Lielākā daļa mūsdienu ietvaru, piemēram, Next.js, React vai Vue, glabā tulkojumus JSON formātā. Kad jums ir jāpievieno jauna valoda savai lietotnei, jūs saskaraties ar izvēli: manuāli kopēt un tulkot katru atslēgu (kļūdu risks), vai izmantot šo rīku, lai minūtēs ģenerētu pirmo melnrakstu.

Reāls scenārijs: Jūsu lietotne ir ar en.json, kurā ir 200+ tulkojumu atslēgas dažādās ligzdotās kategorijās - navigācija, formas, kļūdu ziņojumi, rīku padomi. Jums ir nepieciešamas franču un vācu versijas nākamajā sprintā.

Ievade (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

Tulkojiet franciski, iegūstot fr.json ar identisko struktūru. Jūsu kods joprojām atsaucas uz t('common.errorMessages.required') bez izmaiņām.

Ko es esmu atradis, kas darbojas labi: Ģenerējiet tulkojumus ar šo rīku, pēc tam lūdziet divvalodu komandas loceklim pārbaudīt tehniskos terminus un pogu uzrakstus. Tas ļauj pamanīt gadījumus, kad "Submit" var prasīt atšķirīgus tulkojumus "Submit form" un "Submit payment" kontekstā.

API atbildes lokalizācija

Būvējot API, kas apkalpo vairākas valstis? Jums ir nepieciešamas konsekventi atbilžu struktūras dažādās valodās. Paziņojumu API var atgriezt:

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ūsu mobilā lietotne parsē notification.title un notification.message. Ja franču tulkojums maina atslēgas struktūru, lietotne salūzt franču lietotājiem.

Šis rīks nodrošina, ka notification.title paliek notification.title katrā valodā, mainot tikai virkņu vērtības. Jūsu klienta kods darbojas identisks visās lokālēs.

Viena ierobežojuma piezīme: Automatizētais tulkojums nesaprot jūsu domēnu. "Shipped" e-komercijas kontekstā var tulkoties citādi nekā loģistikas vai jūrniecības kontekstā. Klientiem paredzētām API, pārskatiet izvadi pirms izvietošanas.

Bezsaistes satura pārvaldības sistēmas (CMS) satura tulkošana

Bezsaistes satura pārvaldības platformas, piemēram, Contentful vai Strapi, bieži eksportē saturu kā JSON. Kad jums ir 50 emuāru ieraksti ar strukturētiem metadatiem (autors, tagi, izcelta attēla URL, publicēšanas datumi), jūs vēlaties tulkot saturu un virsrakstu, nepieskaroties metadatiem.

Tipiska eksporte ietver gan satura virknes, gan konfigurāciju:

Saturs: raksta pamatteksts, virsraksts, izvilkums
Struktūra: autora ID, attēlu ceļi, kategoriju slug, laika zīmogi

Manuāla tulkošana rada risku mainīt slug no technology uz tecnología, bojājot maršrutēšanu. Struktūru saglabājošs tulkojums apstrādā tikai satura laukus.

Konfigurācijas faili vairāku reģionu izvietošanai

Izvietojot dažādos reģionos? Jūsu konfigurācijas failiem var būt nepieciešamas lokalizētas virknes, vienlaikus saglabājot identiskus galapunktus, akreditācijas datus un funkciju karogus:

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

Tulkojiet welcomeMessage vāciski, atstājot endpoint, retryAttempts un features nemainītus.

Tulkošanas pieeju salīdzinājums

Metode	Vislabāk piemērota	Ātrums	Precizitāte	Struktūras saglabāšana	Izmaksas
Šis rīks	Ātrai i18n failu ģenerēšanai, prototipiem, iekšējiem rīkiem	Momentāni	Laba standarta saturam	100% saglabāta	Bez maksas
Google Tulkotājs (kopēt/ielīmēt)	Atsevišķām frāzēm, netehniskim tekstiem	Momentāni	Mainīga	Bojā JSON	Bez maksas
Profesionāla tulkošana	Klientiem paredzētam saturam, juridiskiem dokumentiem, mārketingam	Dienas	Izcila	Nepieciešams manuāls darbs	$0.08-0.15/vārds
Tulkošanas pārvaldības sistēmas (Lokalise, Phrase)	Uzņēmumu lietojumprogrammām, sadarbības plūsmām	Stundas-Dienas	Izcila ar pārskati	Iebūvēts JSON atbalsts	$$$+

Kad izmantot šo rīku: Agrīnās stadijas projektos, melnrakstu ģenerēšanai pārskatīšanai, iekšējām lietojumprogrammām, kur ideāla tulkošana nav kritiska.

Kad ieguldīt profesionālā tulkošanā: Klientiem paredzētā saturā, juridiskos/atbilstības tekstos, zīmola vēstījumos vai kad kultūras nianses ir svarīgākas par ātrumu.

Tehniskie apsvērumi un īpašie gadījumi

Ko tulko (un ko netulko)

Rīks izmanto tipa pārbaudi, lai noteiktu, ko tulkot:

✅ Tulkots:

Virkņu vērtības: "Welcome" → "Sveicināti"
Virknes masīvos: ["Hello", "World"] → ["Sveiki", "Pasaule"]
Virknes jebkurā ligzdošanas līmenī

❌ Netulkots:

Skaitļi: 42, 3.14, -10 paliek nemainīgi
Būla vērtības: true un false paliek tādas pašas
Null: null paliek null
Objektu atslēgas: "userName" kā atslēga paliek "userName"
Tukšas virknes: "" paliek ""

Speciālo rakstzīmju apstrāde

Unicode un Emoji Rīks pareizi apstrādā UTF-8, tāpēc emoji un ne-latīņu rakstzīmes darbojas labi:

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

Tulkots spāņu valodā:

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

Escape sekvences JSON escape sekvences (\n, \t, \") tiek saglabātas:

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

\n paliek nemainīgs tulkošanas laikā.

Vietturi Šeit ir potenciāla problēma: Ja jūsu virknēs ir vietturi kā {username} vai %s, tie var tikt tulkoti vai pārkārtoti. Valodās kā arābu vai ebreju (ar tekstu no labās uz kreiso), viettura pozīcijas var mainīties. Pārbaudiet tos rūpīgi.

Lielu JSON failu veiktspēja

Tīmekļa rīks apstrādā tipiskus i18n failus (līdz 500KB) bez problēmām. Lielākiem datu kopumiem:

500KB - 2MB: Darbojas, bet var būt lēns pārlūkprogrammā
Vairāk par 2MB: Apsveriet sadalīšanu loģiskās daļās (piemēram, atsevišķi faili katrai funkcijai vai sadaļai)

Pārlūkprogrammas atmiņa ir ierobežojošais faktors, nevis algoritms.

Bieži uzdotie jautājumi

Kā tas atšķiras no JSON ielīmēšanas Google Tulkotājā?

Google Tulkotājs JSON apstrādā kā parasto tekstu, kas nozīmē, ka tas mēģina tulkot visu - ieskaitot atslēgas, sintakses rakstzīmes un skaitliskās vērtības. Jūs iegūsit izvadi, piemēram:

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

Ievērojiet, kā "username" kļuva par "nom d'utilisateur" un skaitlis 25 kļuva par virkni "vingt-cinq"? Jūsu kods uzreiz salūzt.

Šis rīks saprot JSON struktūru un tulko tikai virkņu vērtības, atstājot atslēgas un citus datu tipus neskartas.

Vai tas spēs apstrādāt dziļi ligzdotu JSON ar masīviem?

Jā. Rekursīvais algoritms apstrādā katru ligzdojuma līmeni:

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

Tas tulko visas virkņu vērtības ("John", "Jane", "admin", "editor", "viewer"), saglabājot precīzu struktūru.

Kas notiek, ja manā JSON ir gan angļu, gan jau tulkots saturs?

Rīks tulko visas atrastās virknes, pat ja dažas jau ir mērķvalodā. Ja pievienojat jaunas atslēgas esošam tulkojuma failam, atsevišķi iztulkojiet tikai jauno sadaļu, pēc tam apvienojiet rezultātus.

Vai varu izmantot šo i18next vai react-intl failiem?

Pilnīgi noteikti. Izvades struktūra atbilst tam, ko šīs sistēmas sagaida. i18next JSON fails, piemēram:

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

Kļūst par:

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

Jūsu t('translation.welcome') izsaukumi paliek nemainīgi.

Cik precīza ir automatizētā tulkošana tehniskam saturam?

Tas ir atkarīgs no konteksta:

Vispārīgs UI teksts: "Save", "Cancel", "Submit" → Parasti precīzi
Tehniskā terminoloģija: "webhook", "OAuth2", "idempotent" → Var tikt nepareizi iztulkoti vai atstāti nemainīti
Nozarei specifiski termini: "patient record" (medicīnā) pret "patient" (pacietība) → Konteksts bieži netiek saprasts

Ražošanas lietotnēm izmantojiet šo kā pirmo piegājienu, pēc tam lieciet kādam pārskatīt tehniskos un nozarei specifiskos terminus.

Kā ir ar valodām ar atšķirīgām rakstzīmju kopām (ķīniešu, arābu, krievu)?

Rīks pareizi apstrādā Unicode, tāpēc visas rakstzīmju kopas darbojas. Uz ko jāpievērš uzmanība: arābu un ebreju valodas ir no labās uz kreiso (RTL), kas var ietekmēt, kā tulkotajās virknēs izskatās vietturi. JSON struktūra paliek pareiza, bet pārskatiet tulkoto tekstu salasāmības ziņā.

Vai tas saglabās manu formatējumu (atkāpes, rindiņu pārtraukumi)?

Izvade ir derīgs JSON, bet formatējums (atstarpes, atkāpes) var atšķirties no ievades. Ja nepieciešams specifisks formatējums, izejošo failu pārvadiet caur JSON formatētāju ar jūsu vēlamajām iestatēm.

Vai varu tulkot konfigurācijas vērtības kā URL vai API atslēgas?

Rīks tulko visas virknes, ieskaitot URL un konfigurācijas vērtības. Lai to novērstu:

Sadaliet savu JSON lietotājam redzamā saturā un konfigurācijā
Tulkojiet tikai satura sadaļu
Atstājiet konfigurāciju netulkotu

Vēl labāk - sāciet strukturēt savus failus, no paša sākuma nošķirot tulkojamos saturus no tehniskajām vērtībām.

Vai tas ir bez maksas? Vai ir ierobežojumi?

Tīmekļa rīks ir bez maksas tipveida lietošanai. Ļoti augsts tulkošanas apjoms (simtiem failu minūtē) var saskarties ar ierobežojumiem pamatā esošajā tulkošanas pakalpojumā. Lielākajai daļai izstrādes darba plūsmu limits netiks sasniegts.

Atsauces un papildu literatūra

Lai iegūtu dziļāku izpratni par JSON struktūru, internacionalizācijas standartiem un labākajām praksēm:

ECMA-404: JSON datu apmaiņas sintakse - Oficiālā JSON specifikācija no Ecma International, kas definē standarta formātu: ecma-international.org/publications-and-standards/standards/ecma-404/
MDN Web Docs: Darbs ar JSON - Mozilla visaptverošais ceļvedis JSON parsēšanā, stringifikācijā un struktūrā: developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/JSON
W3C Internacionalizācijas (i18n) aktivitāte - Standarti un labākās prakses tīmekļa internacionalizācijai: w3.org/International/
RFC 8259: JSON datu apmaiņas formāts - IETF specifikācija JSON sintaksei un semantikai: datatracker.ietf.org/doc/html/rfc8259

Sāciet tulkot savus JSON failus

Vai jums ir nepieciešams ātri ģenerēt tulkojumu failus jūsu daudzvalodu lietotnei? Ielīmējiet savu JSON, izvēlieties mērķa valodu un saņemiet tulkojumus, kas saglabā struktūru momentāni. Darbojas ar i18next, react-intl, vue-i18n un jebkuru sistēmu, kas sagaida konsekventu JSON struktūru dažādās valodās.

Sāciet tulkošanu tūlīt: