JSON വിവർത്തകം സ്ട്രക്ചർ സംരക്ഷിക്കുന്ന | സൗജന്യ i18n ഉപകരണം

സ്ട്രക്ചർ അതേപടി സംരക്ഷിക്കുന്ന സൗജന്യ JSON വിവർത്തകം. i18n ഫയലുകൾ, API പ്രതികരണങ്ങൾ, നെസ്റ്റഡ് JSON എന്നിവ കീകൾ, ഡാറ്റ തരങ്ങൾ, ഫോർമാറ്റിംഗ് സംരക്ഷിച്ചുകൊണ്ട് വിവർത്തനം ചെയ്യുക. i18next, ബഹുഭാഷാ അപ്ലിക്കേഷനുകൾക്ക് പ്രഫക്ട്.

JSON സ്ട്രക്ചർ പരിവർത്തനം ചെയ്യുന്ന വിവർത്തകൻ

ഈ ഉപകരണം JSON വസ്തുക്കളുടെ ഉള്ളടക്കം അതിന്റെ സ്ട്രക്ചർ സൂക്ഷിച്ചുകൊണ്ട് വിവർത്തനം ചെയ്യുന്നു. ഇടത് പാനലിൽ നിങ്ങളുടെ JSON പേസ്റ്റ് ചെയ്യുക, ലക്ഷ്യ ഭാഷ തിരഞ്ഞെടുക്കുക, വലത് വശത്ത് വിവർത്തിത ഔട്ട്പുട്ട് കാണുക.

ലക്ഷ്യ ഭാഷ:

സ്രോതസ്സ് JSON

വിവർത്തിത JSON

വിവർത്തിത ഔട്ട്പുട്ട് ഇവിടെ പ്രത്യക്ഷപ്പെടും...

ഉപയോഗിക്കുന്ന വിധം

സ്രോതസ്സ് JSON വസ്തുവിനെ JSON ഫീൽഡിൽ പേസ്റ്റ് ചെയ്യുക.
ഡ്രോപ്ഡൗൺ മെനുവിൽ നിന്ന് നിങ്ങളുടെ ലക്ഷ്യ ഭാഷ തിരഞ്ഞെടുക്കുക.
വിവർത്തിത JSON സ്വയമേവ വലത് പാനലിൽ പ്രത്യക്ഷപ്പെടും.
വിവർത്തിത JSON നിങ്ങളുടെ ക്ലിപ്പ്ബോർഡിലേക്ക് കോപ്പി ചെയ്യാൻ കോപ്പി ബട്ടൺ ക്ലിക്ക് ചെയ്യുക.

ലോഡിംഗ് കാൽക്യുലേറ്റർ...

📚

വിവരണം

JSON സ്ട്രക്ചർ സംരക്ഷിക്കുന്ന വിവർത്തകം എന്ന് എന്തുകൊണ്ട്?

ഗൂഗിൾ ട്രാൻസ്ലേറ്റിൽ JSON കോപ്പി ചെയ്യുമ്പോൾ കീകൾ തകർന്ന്, കൊക്ഷ്യങ്ങൾ നഷ്ടപ്പെട്ട്, അല്ലെങ്കിൽ സിന്റാക്സ് തകർന്ന് പോയിട്ടുണ്ടോ? അതാണ് ഈ ഉപകരണം പരിഹരിക്കുന്ന പ്രശ്നം.

JSON സ്ട്രക്ചർ സംരക്ഷിക്കുന്ന വിവർത്തകം നിങ്ങളുടെ JSON ഓബ്ജക്റ്റുകളിലെ സ്ട്രിംഗ് മൂല്യങ്ങൾ മറ്റൊരു ഭാഷയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു, മറ്റെല്ലാം മാറ്റമില്ലാതെ—കീകൾ അതേപടി തുടരുന്നു, സംഖ്യകൾ സംഖ്യകളായി, ബൂളിയൻ മൂല്യങ്ങൾ ബൂളിയൻ ആയി, നെസ്റ്റഡ് സ്ട്രക്ചർ തകർന്ന് പോകുന്നില്ല.

ഇതിനെ സാധാരണ വിവർത്തന ഉപകരണങ്ങളിൽ നിന്ന് വ്യത്യസ്തമാക്കുന്നത് ഇതാണ്: 50+ നെസ്റ്റഡ് കീകളുള്ള ടൈപ്പിക്കൽ i18n ഫയൽ വിവർത്തനം ചെയ്യുമ്പോൾ, നിങ്ങളുടെ കോഡിനു ഇപ്പഴും സ്പാനിഷ്, ഫ്രഞ്ച്, അല്ലെങ്കിൽ ജാപ്പനീസിൽ user.profile.displayName റഫർ ചെയ്യാൻ കഴിയണം. ആ സ്ട്രക്ചർ തകർന്നാൽ, നിങ്ങൾ മണിക്കൂറുകളോളം ഡീബഗ് ചെയ്യേണ്ടി വരും.

ഈ ഉപകരണം റിക്കഴ്സീവ് ട്രാവേഴ്സൽ സ്വയമായി കൈകാര്യം ചെയ്യുന്നു, വിവർത്തനം ആവശ്യമുള്ള സ്ട്രിംഗുകളും (API കീകൾ, കോൺഫിഗറേഷൻ മൂല്യങ്ങൾ, അല്ലെങ്കിൽ സംഖ്യാപരമായ IDകൾ) അതേപടി തുടരേണ്ട മൂല്യങ്ങളും തിരിച്ചറിയുന്നു.

JSON സ്ട്രക്ചർ സംരക്ഷണം എങ്ങനെ പ്രവർത്തിക്കുന്നു

സ്ട്രക്ചർ സംരക്ഷണം എന്തുകൊണ്ട് പ്രധാനമാണ്

JSON വിവർത്തനം ചെയ്യുമ്പോൾ, നിങ്ങൾ സാധാരണ ഇവയിൽ ഒന്നിൽ കൂടുതൽ സ്ഥിതിവിവരങ്ങളിൽ കൊണ്ടിരിക്കുന്നു:

i18n ഫയലുകൾ നിങ്ങളുടെ ആപ്പ് en.json കൂടാതെ fr.json ൽ തുല്യമായ കീകൾ പ്രതീക്ഷിക്കുന്നു
API പ്രതികരണങ്ങൾ ക്ലയന്റ് പാഴ്സിംഗിനായി വിവിധ ഭാഷകളിൽ സ്ഥിരമായ സ്ട്രക്ചർ ആവശ്യമുള്ളവ
കോൺഫിഗറേഷൻ ഫയലുകൾ ഒരു കീ പേര് മാറ്റുന്നത് നിങ്ങളുടെ മുഴുവൻ അപ്ലിക്കേഷനെയും തകർക്കുന്നു
ഡാറ്റാബേസ് കയറ്റുമതികൾ വ്യത്യസ്ത ഫീൽഡ് പേരുകൾ ബന്ധങ്ങളെ ആശ്രയിക്കുന്നു

വെല്ലുവിളി: JSON വെറും വാചകം മാത്രമല്ല. ഇത് നിങ്ങളുടെ കോഡ് ആശ്രയിക്കുന്ന ഒരു സ്കീമയുള്ള സ്ട്രക്ചർഡ് ഡാറ്റയാണ്. "userName" നെ "nombreUsuario" ആക്കി വിവർത്തനം ചെയ്യുന്നത്, നിങ്ങളുടെ ആപ്പ് undefined പിഴവ് വർഷിക്കുന്നു.

വിവർത്തന പ്രക്രിയ എങ്ങനെ പ്രവർത്തിക്കുന്നു

ഇവിടെ ഹുഡിനുള്ളിൽ JSON വിവർത്തനം ചെയ്യുമ്പോൾ സംഭവിക്കുന്നത്:

1. പാഴ്സ് ചെയ്യുകയും സ്ഥിരീകരിക്കുകയും ചെയ്യുക ഉപകരണം ആദ്യം നിങ്ങളുടെ JSON വ്യാകരണം സ്ഥിരീകരിക്കുന്നു. ഒരു കോമ്മ കുറവാണെങ്കിൽ അല്ലെങ്കിൽ അധിക ബ്രാക്കറ്റ് ഉണ്ടെങ്കിൽ, വിവർത്തനം തുടങ്ങുന്നതിനുമുമ്പ് ഒരു വ്യക്തമായ പിഴവ് സന്ദേശം നൽകുന്നു—വിരൂപമായ ഔട്ട്പുട്ട് ഒഴിവാക്കുന്നു.

2. പുനരാവർത്തക ട്രാവേഴ്സൽ വേരിൽ നിന്ന് തുടങ്ങി, ആൽഗോരിതം നിങ്ങളുടെ JSON വൃക്ഷത്തിലെ ഓരോ നോഡിലേക്കും നടക്കുന്നു. ഓരോ എലിമെന്റിനും, ഡാറ്റ വ്യവഹാരം പരിശോധിക്കുന്നു:

സ്ട്രിംഗ്? വിവർത്തനത്തിനായി കിউവിൽ ചേർക്കുക
സംഖ്യ, ബൂളിയൻ, ശൂന്യം? പൂർണ്ണമായി ഒഴിവാക്കുക
ഒബ്ജക്റ്റ് അല്ലെങ്കിൽ അറേ? അതിൽ പുനരാവർത്തിക്കുക

3. വ്യവഹാര-സുരക്ഷിത വിവർത്തനം വെറും സ്ട്രിംഗ് മൂല്യങ്ങൾ മാത്രം വിവർത്തന API-യിലേക്ക് അയയ്ക്കുന്നു. നിങ്ങളുടെ "quantity": 42 42 ആയി തുടരുന്നു, "cuarenta y dos" അല്ല. നിങ്ങളുടെ "isActive": true true ആയി തുടരുന്നു, "verdadero" അല്ല.

4. കീ സംരക്ഷണം എല്ലാ ഒബ്ജക്റ്റ് കീകളും അവയുടെ യഥാർത്ഥ ഭാഷയിൽ തുടരുന്നു. ഇത് അത്യന്തം പ്രധാനമാണ്, കാരണം translations.header.welcomeMessage ഓരോ ഭാഷാ ഫയലിലും ഒരേ പാതയിൽ ഉണ്ടായിരിക്കണം.

5. സ്ട്രക്ചർ പുനഃസംഘടന വിവർത്തനം ചെയ്ത സ്ട്രിംഗുകൾ അതേ സ്ഥാനങ്ങളിൽ തിരിച്ചു ഇടുന്നു, എല്ലാ നെസ്റ്റിംഗ് തലങ്ങളും, അറേ സൂചികകളും, ഒബ്ജക്റ്റ് വ്യൂഹങ്ങളും പരിപാലിക്കുന്നു.

ഒരു സാധാരണ കുഴപ്പം: ചില ഡവലപ്പർമാർ JSON.stringify() ഒബ്ജക്റ്റിനെ പരിശ്രമിക്കുന്നു, മുഴുവൻ സ്ട്രിംഗിനെയും വിവർത്തനം ചെയ്ത്, പിന്നെ തിരിച്ച് പാഴ്സ് ചെയ്യുന്നു. ഇത് തകരുന്നു കാരണം വിവർത്തകൻ കീകൾ, ബ്രാക്കറ്റുകൾ, വ്യാകരണം മാറ്റുന്നു. പുനരാവർത്തക സമീപനം ഇതിനെ പൂർണ്ണമായി ഒഴിവാക്കുന്നു.

JSON സ്ട്രക്ചർ സംരക്ഷിക്കുന്ന വിവർത്തക ഉപയോഗിക്കുന്നത്

ഘട്ടം-ഘട്ടമായുള്ള മാർഗ്ഗദർശിക

1. നിങ്ങളുടെ JSON പേസ്റ്റ് ചെയ്യുക നിങ്ങളുടെ JSON ഒബ്ജക്റ്റ് പകർത്തി ഇടത് പാനലിൽ പേസ്റ്റ് ചെയ്യുക. ഉപകരണം ഏത് സാധുവായ JSON-നെയും കൈകാര്യം ചെയ്യും—5 കീസുള്ള ഒരു ലളിതമായ ഒബ്ജക്റ്റ് മുതൽ അരേ, മൾട്ടിപ്പിൾ തലങ്ങളിലുള്ള അരേകളുള്ള ഒരു ആഴത്തിൽ നിക്ഷേപിക്കപ്പെട്ട സ്ട്രക്ചർ വരെ.

2. ലക്ഷ്യ ഭാഷ തിരഞ്ഞെടുക്കുക ഭാഷാ ഡ്രോപ്പ്ഡൗൺ മുതൽ തിരഞ്ഞെടുക്കുക: സ്പാനിഷ്, ഫ്രഞ്ച്, ജർമ്മൻ, ഇറ്റാലിയൻ, പോർട്ടുഗീസ്, ചൈനീസ്, ജാപ്പനീസ്, കൊറിയൻ, റഷ്യൻ, മുതലായവ. i18next പ്രൊജക്റ്റിനായി വിവർത്തനം ചെയ്യുന്നുവെങ്കിൽ, നിങ്ങളുടെ ഫ്രെയിംവർക്ക് പ്രതീക്ഷിക്കുന്ന ഭാഷാ കോഡ് പൊരുത്തപ്പെടുത്തുക.

3. ഉടനടി വിവർത്തനം നേടുക വിവർത്തിക്കപ്പെട്ട ഔട്ട്പുട്ട് വലത് പാനലിൽ സ്വയമേവ പ്രത്യക്ഷപ്പെടുന്നു. "വിവർത്തിക്കുക" ബട്ടൺ ആവശ്യമില്ല—സാധുവായ JSON-വും തിരഞ്ഞെടുത്ത ഭാഷയും ഉണ്ടെങ്കിൽ ഉടനടി പ്രക്രിയിക്കുന്നു.

4. പകർത്തി ഉപയോഗിക്കുക വിവർത്തിക്കപ്പെട്ട JSON പിടിക്കാൻ "പകർത്തുക" ബട്ടൺ ക്ലിക്ക് ചെയ്യുക. ഇത് നിങ്ങളുടെ പ്രൊജക്റ്റിൽ നേരിട്ട് പേസ്റ്റ് ചെയ്യാൻ തയ്യാറാണ്—ക്ലീനപ്പ് ആവശ്യമില്ല.

5. അടുത്ത വിവർത്തനത്തിനായി മായ്ക്കുക മറ്റൊരു ഫയൽ വിവർത്തിക്കാൻ തയ്യാറാണെങ്കിൽ "എല്ലാം മായ്ക്കുക" അമർത്തുക. ഉപകരണം രണ്ട് പാനലുകളും ഉടനടി പുനഃസജ്ജമാക്കുന്നു.

സാധാരണ പ്രശ്നങ്ങളും പരിഹാരങ്ങളും

"അസാധുവായ JSON ഫോർമാറ്റ്" പിശക് കീ-വാല്യൂ ജോഡിക്കിടയിൽ കമ്മ കാണാതിരിക്കൽ, അവസാന ഇനത്തിനുശേഷം ട്രെയിലിംഗ് കമ്മ, ഡബിൾ കോട്ടിനുപകരം സിംഗിൾ കോട്ട്, സ്ട്രിംഗുകളിൽ അൺഏസ്കേപ്ഡ് പ്രത്യേക പ്രതീകങ്ങൾ തുടങ്ങിയ സിന്റാക്സ് പ്രശ്നങ്ങൾ കാണുമ്പോൾ ഇത് കാണിക്കുന്നു.

ത്വരിത പരിഹാരം: JSONLint പോലുള്ള ഒരു വാലിഡേറ്ററിൽ നിങ്ങളുടെ JSON പാസ്സാക്കുക.

വിവർത്തനം നിശ്ശബ്ദമായി പരാജയപ്പെടുന്നു ഔട്ട്പുട്ട് പാനൽ ശൂന്യമായി തുടരുകയാണെങ്കിൽ:

നിങ്ങളുടെ ഇന്റർനെറ്റ് കണക്ഷൻ പരിശോധിക്കുക—വിവർത്തനത്തിന് API ആക്സസ് ആവശ്യമാണ്
ലക്ഷ്യ ഭാഷ തിരഞ്ഞെടുത്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക
പ്രശ്നം തിരിച്ചറിയാൻ ഒരു ചെറിയ JSON ഖണ്ഡം പരീക്ഷിക്കുക

വിവർത്തനത്തിൽ പ്രതീക്ഷിക്കാത്ത ഫലങ്ങൾ മെഷീൻ വിവർത്തനം സാധാരണ വാക്യങ്ങൾക്ക് നന്നായി പ്രവർത്തിക്കുന്നുണ്ടെങ്കിലും ഇവയിൽ പ്രയാസം അനുഭവിക്കുന്നു:

സാങ്കേതിക ജാർഗൺ അല്ലെങ്കിൽ ഡൊമെയിൻ-പ്രത്യേക പദങ്ങൾ
ബ്രാൻഡ് പേരുകൾ (പലപ്പോഴും വിവർത്തനം ചെയ്യാതെ തന്നെ വയ്ക്കേണ്ടവ)
{{username}} അല്ലെങ്കിൽ %s പോലുള്ള പ്ലേസ്ഹോൾഡർ സിന്റാക്സ്

ഉൽപ്പാദന അപ്ലിക്കേഷനുകൾക്ക്, ഈ ഉപകരണം ഒരു ആദ്യ പാസ്സായി ഉപയോഗിക്കുക, തുടർന്ന് ഡൊമെയിൻ-പ്രത്യേക അല്ലെങ്കിൽ ഉപഭോക്തൃ-നേരിട്ടുള്ള ഉള്ളടക്കം ഒരു മൂലഭാഷാ സംസാരിക്കുന്ന വ്യക്തി പരിശോധിക്കട്ടെ.

മെച്ചപ്പെട്ട ഫലങ്ങൾക്കുള്ള പ്രൊ ടിപ്സ്

സാങ്കേതിക സ്ട്രിംഗുകൾ വേർതിരിക്കുക നിങ്ങളുടെ JSON ഉപഭോക്തൃ-നേരിട്ടുള്ള വാചകങ്ങളെയും സാങ്കേതിക ഐഡന്റിഫയറുകളെയും കലർത്തുന്നുവെങ്കിൽ, അവയെ വേർതിരിക്കുന്നതിനെക്കുറിച്ച് പരിഗണിക്കുക. ഉദാഹരണത്തിന്:

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

config മൂല്യങ്ങൾ അനാവശ്യമായി പ്രക്രിയിക്കുന്നത് ഒഴിവാക്കാൻ display ഒബ്ജക്റ്റ് വേർതിരിച്ച് വിവർത്തിക്കുക.

നിങ്ങളുടെ സ്ട്രിംഗുകളിൽ സന്ദർഭം ഉപയോഗിക്കുക "സമർപ്പിക്കുക" സന്ദർഭത്തിൽ വ്യത്യസ്തമായി വിവർത്തിക്കാം. "ഫോം സമർപ്പിക്കുക" അല്ലെങ്കിൽ "പേയ്മെന്റ് സമർപ്പിക്കുക" വിവർത്തകർക്ക് (മനുഷ്യൻ അല്ലെങ്കിൽ മെഷീൻ) കൂടുതൽ കൃത്യമായ വിവർത്തനത്തിനുള്ള മെച്ചപ്പെട്ട സന്ദർഭം നൽകുന്നു.

യഥാർഥ ഡാറ്റയുമായി പരീക്ഷിക്കുക 500+ കീസുള്ള നിങ്ങളുടെ മുഴുവൻ i18n ഫയൽ വിവർത്തിക്കുന്നതിനുമുമ്പ്, നിങ്ങളുടെ എല്ലാ ഡാറ്റ തരങ്ങളും—സ്ട്രിംഗുകൾ, നമ്പറുകൾ, നിക്ഷേപിക്കപ്പെട്ട ഒബ്ജക്റ്റുകൾ, അരേകൾ—ഉൾക്കൊള്ളുന്ന ഒരു ചെറിയ സാമ്പിൾ പരീക്ഷിക്കുക.

കോഡ് ഉദാഹരണങ്ങൾ

JavaScript ഉപയോഗിച്ച് JSON വിവർത്തനം

1// JavaScript-ൽ സമാന സവിശേഷത നടപ്പിലാക്കുന്ന രീതിയുടെ ഉദാഹരണം
2function translateJsonStructure(jsonObj, targetLanguage) {
3  // സ്ട്രിംഗ് വിവർത്തനത്തിനുള്ള സഹായക ഫംഗ്ഷൻ
4  function translateString(str, lang) {
5    // യഥാർഥ നടപ്പിലാക്കലിൽ, ഇത് വിവർത്തന API കൾ വിളിക്കും
6    return `[${lang}] ${str}`;
7  }
8  
9  // 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    // സംഖ്യകൾ, ബൂളിയൻ മുതലായവ മാറ്റം വരുത്താതെ തിരിച്ചയയ്ക്കുക
30    return node;
31  }
32  
33  return processNode(jsonObj);
34}
35
36// ഉപയോഗ ഉദാഹരണം
37const sourceJson = {
38  "product": {
39    "name": "വയർലെസ് ഹെഡ്ഫോൺസ്",
40    "description": "ശബ്ദനിരോധന സവിശേഷതയുള്ള ഉയർന്ന നിലവാരത്തിലുള്ള വയർലെസ് ഹെഡ്ഫോൺസ്",
41    "features": ["ബ്ലൂടൂത്ത് 5.0", "40 മണിക്കൂർ ബാറ്ററി ലൈഫ്", "മടക്കാവുന്ന ഡിസൈൻ"],
42    "price": 99.99,
43    "inStock": true
44  }
45};
46
47const translatedJson = translateJsonStructure(sourceJson, "es");
48console.log(JSON.stringify(translatedJson, null, 2));
49

Python ഉപയോഗിച്ച് JSON വിവർത്തനം

1import json
2
3def translate_json_structure(json_obj, target_language):
4    """
5    JSON ഒബ്ജക്റ്റിലെ സ്ട്രിംഗ് മൂല്യങ്ങൾ വിവർത്തനം ചെയ്യുന്നു, സ്ട്രക്ചർ സൂക്ഷിക്കുന്നു.
6    
7    Args:
8        json_obj: പാഴ്സ് ചെയ്ത JSON ഒബ്ജക്റ്റ്
9        target_language: ലക്ഷ്യ ഭാഷ കോഡ് (ഉദാ., 'es', 'fr')
10        
11    Returns:
12        സ്ട്രക്ചർ സൂക്ഷിച്ച വിവർത്തനം ചെയ്ത JSON ഒബ്ജക്റ്റ്
13    """
14    def translate_string(text, lang):
15        # യഥാർഥ നടപ്പിലാക്കലിൽ, ഇത് വിവർത്തന 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        # സംഖ്യകൾ, ബൂളിയൻ മുതലായവ മാറ്റം വരുത്താതെ തിരിച്ചയയ്ക്കുക
35        return node
36    
37    return process_node(json_obj)
38
39# ഉപയോഗ ഉദാഹരണം
40source_json = {
41    "user": {
42        "name": "ജെയ്ൻ സ്മിത്ത്",
43        "bio": "സോഫ്റ്റ്വെയർ ഡവലപ്പർ, ഓപ്പൺ സോഴ്സ് സംഭാവകൻ",
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

PHP ഉപയോഗിച്ച് JSON വിവർത്തനം

1<?php
2/**
3 * JSON സ്ട്രക്ചർ വിവർത്തനം ചെയ്യുന്നു, യഥാർഥ സ്ട്രക്ചർ സൂക്ഷിക്കുന്നു
4 * 
5 * @param mixed $jsonObj പാഴ്സ് ചെയ്ത JSON ഒബ്ജക്റ്റ്
6 * @param string $targetLanguage ലക്ഷ്യ ഭാഷ കോഡ്
7 * @return mixed വിവർത്തനം ചെയ്ത JSON ഒബ്ജക്റ്റ്
8 */
9function translateJsonStructure($jsonObj, $targetLanguage) {
10    // സ്ട്രിംഗ് വിവർത്തനത്തിനുള്ള സഹായക ഫംഗ്ഷൻ
11    function translateString($text, $lang) {
12        // യഥാർഥ നടപ്പിലാക്കലിൽ, ഇത് വിവർത്തന API കൾ വിളിക്കും
13        return "[$lang] $text";
14    }
15    
16    // ഓരോ നോഡും പ്രോസസ് ചെയ്യുന്നതിനുള്ള റിക്കഴ്സീവ് ഫംഗ്ഷൻ
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            // അസോസിയേറ്റീവ് അറേ (ഒബ്ജക്റ്റ്) അല്ലെങ്കിൽ സൂചിക വിലയുള്ള അറേ പരിശോധിക്കുക
28            if (array_keys($node) !== range(0, count($node) - 1)) {
29                // അസോസിയേറ്റീവ് അറേ (ഒബ്ജക്റ്റ്)
30                $result = [];
31                foreach ($node as $key => $value) {
32                    $result[$key] = processNode($value, $lang);
33                }
34                return $result;
35            } else {
36                // സൂചിക വിലയുള്ള അറേ
37                return array_map(function($item) use ($lang) {
38                    return processNode($item, $lang);
39                }, $node);
40            }
41        }
42        
43        // സംഖ്യകൾ, ബൂളിയൻ മുതലായവ മാറ്റം വരുത്താതെ തിരിച്ചയയ്ക്കുക
44        return $node;
45    }
46    
47    return processNode($jsonObj, $targetLanguage);
48}
49
50// ഉപയോഗ ഉദാഹരണം
51$sourceJson = [
52    "company" => [
53        "name" => "ഗ്ലോബൽ ടെക് സൊല്യൂഷൻസ്",
54        "description" => "നവീന സോഫ്റ്റ്വെയർ വികസന കമ്പനി",
55        "founded" => 2010,
56        "services" => ["വെബ് വികസനം", "മൊബൈൽ ആപ്സ്", "ക്ലൗഡ് സൊല്യൂഷൻസ്"],
57        "active" => true
58    ]
59];
60
61$translatedJson = translateJsonStructure($sourceJson, "de");
62echo json_encode($translatedJson, JSON_PRETTY_PRINT);
63?>
64

യഥാർഥ വൾഡ് ഉപയോഗ കേസുകൾ

വെബ് അപ്ലിക്കേഷൻ i18n ഫയലുകൾ

Next.js, React, അല്ലെങ്കിൽ Vue പോലുള്ള അടുത്തകാലത്തെ ഫ്രെയിംവർക്കുകൾ പരിഭാഷകൾ JSON ഫോർമാറ്റിൽ സൂക്ഷിക്കുന്നു. നിങ്ങളുടെ അപ്ലിക്കേഷനിൽ പുതിയ ഭാഷ ചേർക്കുമ്പോൾ, നിങ്ങൾ നേരിടുന്ന തിരഞ്ഞെടുപ്പ്: ഓരോ കീ മാനുവലായി കോപ്പി-പേസ്റ്റ് ചെയ്യുകയും പരിഭാഷപ്പെടുത്തുകയും ചെയ്യുക (പിഴവുകൾക്ക് വഴിവയ്ക്കുന്ന), അല്ലെങ്കിൽ മിനിറ്റുകൾക്കുള്ളിൽ ഒരു ആദ്യ ഡ്രാഫ്റ്റ് ഉൽപ്പാദിപ്പിക്കാൻ ഈ ഉപകരണം ഉപയോഗിക്കുക.

ഒരു യഥാർഥ സ്സീനാരിയോ: നിങ്ങളുടെ അപ്ലിക്കേഷനിൽ 200+ പരിഭാഷാ കീകൾ ഉൾക്കൊള്ളുന്ന en.json ഉണ്ട്—നാവിഗേഷൻ, ഫോമുകൾ, പിഴവ് സന്ദേശങ്ങൾ, ടൂൾടിപ്സ്. അടുത്ത സ്പ്രിന്റിൽ ഫ്രഞ്ച് വേർഷനും ജർമ്മൻ വേർഷനും വേണം.

ഇൻപുട് (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

ഫ്രഞ്ചിലേക്ക് പരിഭാഷപ്പെടുത്തുക, സമാന സ്ട്രക്ചർ സഹിതം fr.json നേടുക. നിങ്ങളുടെ കോഡ് ഇപ്പഴും t('common.errorMessages.required') സൂചിപ്പിക്കുന്നു.

ഞാൻ നന്നായി കണ്ടെത്തിയത്: ഈ ഉപകരണം ഉപയോഗിച്ച് പരിഭാഷകൾ ഉൽപ്പാദിപ്പിക്കുക, തുടർന്ന് ഭാഷാ വിദഗ്ദ്ധ അംഗം സാങ്കേതിക പദങ്ങളും ബട്ടൺ ലേബലുകളും പരിശോധിക്കുക. ഇത് "Submit" എന്നത് "Submit form" വിനും "Submit payment" വിനും വ്യത്യസ്ത പരിഭാഷകൾ ആവശ്യമാണോ എന്ന കാര്യം കണ്ടെത്തുന്നു.

API പ്രതികരിയ പ്രാദേശീകവൽക്കരണം

ഒന്നിലധികം രാജ്യങ്ങൾക്ക് സേവനം നൽകുന്ന API നിർമ്മിക്കുന്നുവോ? നിങ്ങൾക്ക് വ്യത്യസ്ത ഭാഷകളിൽ സ്ഥിരമായ പ്രതികരിയാ സ്ട്രക്ചറുകൾ വേണം. ഒരു അറിയിപ്പ് API വിളിച്ചുവരുത്തിയേക്കാം:

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

നിങ്ങളുടെ മൊബൈൽ അപ്ലിക്കേഷൻ notification.title യും notification.message യും പാഴ്സ് ചെയ്യുന്നു. ഫ്രഞ്ച് പരിഭാഷ കീ സ്ട്രക്ചർ മാറ്റിയാൽ, ഫ്രഞ്ച് ഉപയോക്താക്കൾക്ക് അപ്ലിക്കേഷൻ പ്രവർത്തിക്കില്ല.

ഈ ഉപകരണം ഉറപ്പാക്കുന്നത് notification.title ഓരോ ഭാഷയിലും notification.title തന്നെ ആയിരിക്കുകയും, കേവലം സ്ട്രിംഗ് മൂല്യങ്ങൾ മാത്രം പരിഭാഷപ്പെടുത്തുകയും ചെയ്യുന്നു. നിങ്ങളുടെ ക്ലൈന്റ് കോഡ് എല്ലാ പ്രാദേശിക ഭാഷകളിലും തുല്യമായി പ്രവർത്തിക്കുന്നു.

ഒരു പരിമിതി കുറിക്കാൻ: സ്വയം-പരിഭാഷ നിങ്ങളുടെ മേഖലയെ മനസ്സിലാക്കുന്നില്ല. ഇ-കൊമേഴ്സ് സന്ദർഭത്തിൽ "Shipped" ഒരു ലോജിസ്റ്റിക്സ് അല്ലെങ്കിൽ സമുദ്ര സന്ദർഭത്തിൽ വ്യത്യസ്തമായി പരിഭാഷപ്പെടുത്തിയേക്കാം. ഉപഭോക്തൃ-മുഖം തുറന്ന API കളിൽ, വിന്യസിക്കുന്നതിനുമുമ്പ് ഔട്ട്പുട്ട് പരിശോധിക്കുക.

ഹെഡ്‌ലെസ് CMS ഉള്ളടക്കം പരിഭാഷപ്പെടുത്തൽ

Contentful അല്ലെങ്കിൽ Strapi പോലുള്ള ഹെഡ്‌ലെസ് CMS പ്ലാറ്റ്ഫോമുകൾ ഉള്ളടക്കം JSON ആയി കയറ്റുമതി ചെയ്യുന്നു. 50 ബ്ലോഗ് പോസ്റ്റുകൾ സ്ട്രക്ചർഡ് മെറ്റാഡാറ്റ (രചയിതാവ്, ടാഗുകൾ, ഫീച്ചേഡ് ഇമേജ് URL, പ്രസിദ്ധീകരണ തീയതികൾ) ഉള്ളപ്പോൾ, നിങ്ങൾ മെറ്റാഡാറ്റ സ്പർശിക്കാതെ ബോഡിയും തലക്കെട്ടും പരിഭാഷപ്പെടുത്തണം.

ഒരു സാധാരണ കയറ്റുമതിയിൽ ഉള്ളടക്ക സ്ട്രിംഗുകളും കോൺഫിഗറേഷനും ഉൾപ്പെടുന്നു:

ഉള്ളടക്കം: ലേഖന ബോഡി, തലക്കെട്ട്, പ്രസ്താവന
സ്ട്രക്ചർ: രചയിതാവ് ഐഡികൾ, ഇമേജ് പാതകൾ, വർഗ്ഗ സ്ലഡ്ഗുകൾ, സമയമുദ്ര

മാനുവൽ പരിഭാഷ technology ഐഡി tecnología ആക്കി മാറ്റുന്ന അപകടസാധ്യത ഉണ്ട്, നിങ്ങളുടെ റൂട്ടിംഗ് തകർക്കുന്നു. സ്ട്രക്ചർ സംരക്ഷിക്കുന്ന പരിഭാഷ കേവലം ഉള്ളടക്ക ഫീൽഡുകൾ കൈകാര്യം ചെയ്യുന്നു.

മൾട്ടി-റീജിയൻ വിന്യാസങ്ങൾക്കുള്ള കോൺഫിഗറേഷൻ ഫയലുകൾ

വിവിധ പ്രദേശങ്ങളിൽ വിന്യസിക്കുന്നുവോ? നിങ്ങളുടെ കോൺഫിഗ ഫയലുകൾക്ക് എൻഡ്‌പോയിന്റുകൾ, ക്രെഡൻഷ്യലുകൾ, ഫീച്ചർ ഫ്ലാഗുകൾ മാറ്റാതെ പ്രാദേശിക സ്ട്രിംഗുകൾ വേണ്ടിവരാം:

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

endpoint, retryAttempts, features മാറ്റാതെ welcomeMessage ജർമ്മൻ ഭാഷയിലേക്ക് പരിഭാഷപ്പെടുത്തുക.

വിവർത്തന രീതികളുടെ താരതമ്യം

രീതി	ഏറ്റവും അനുയോജ്യം	വേഗം	കൃത്യത	സ്ട്രക്ചർ സുരക്ഷ	ചിലവ്
ഈ ഉപകരണം	വേഗത്തിലുള്ള i18n ഫയൽ നിർമ്മാണം, പ്രോട്ടോടൈപ്പുകൾ, ആന്തരിക ഉപകരണങ്ങൾ	ഉടനടി	സാധാരണ ഉള്ളടക്കത്തിന് നല്ലത്	100% സംരക്ഷിച്ചിരിക്കുന്നു	സൗജന്യം
ഗൂഗിൾ വിവർത്തനം (കോപ്പി/പേസ്റ്റ്)	ഒറ്റ വാക്യങ്ങൾ, അ-സാങ്കേതിക പാഠം	ഉടനടി	വ്യത്യാസപ്പെടുന്നു	JSON നഷ്ടപ്പെടുന്നു	സൗജന്യം
പ്രൊഫഷണൽ വിവർത്തനം	ഉപഭോക്തൃ-മുഖം വിളക്കിയ ഉള്ളടക്കം, നിയമ രേഖകൾ, വിപണന രേഖകൾ	ദിവസങ്ങൾ	മികച്ചത്	മാനുവൽ പ്രവൃത്തി ആവശ്യം	$0.08-0.15/വാക്ക്
വിവർത്തന മാനേജ്മെന്റ് സിസ്റ്റങ്ങൾ (Lokalise, Phrase)	എന്റർപ്രൈസ് അപ്ലിക്കേഷനുകൾ, സഹകരണ വർക്ക്ഫ്ലോകൾ	മണിക്കൂറുകൾ-ദിവസങ്ങൾ	പരിശോധനയുടെ കൂടെ മികച്ചത്	ഉൾനിന്ന JSON പിന്തുണ	$$$+

ഈ ഉപകരണം എപ്പോൾ ഉപയോഗിക്കണം: ആദ്യഘട്ട പദ്ധതികൾ, പരിശോധനയ്ക്കുള്ള ഡ്രാഫ്റ്റുകൾ നിർമ്മിക്കൽ, പൂർണ്ണ വിവർത്തനം അത്യന്തം അനിവാര്യമല്ലാത്ത ആന്തരിക അപ്ലിക്കേഷനുകൾ.

പ്രൊഫഷണൽ വിവർത്തനത്തിൽ നിക്ഷേപിക്കേണ്ട സമയം: ഉപഭോക്തൃ-മുഖം വിളക്കിയ ഉള്ളടക്കം, നിയമ/അനുപാലന പാഠം, ബ്രാൻഡ് സന്ദേശം, അല്ലെങ്കിൽ സാംസ്കാരിക സൂക്ഷ്മതകൾ വേഗത്തിലും അധികം പ്രാധാന്യം കൊടുക്കുന്ന സന്ദർഭങ്ങൾ.

സാങ്കേതിക കണക്കിടലുകളും അതിർത്തി കേസുകൾ

എന്തൊക്കെ വിവർത്തനം ചെയ്യപ്പെടുന്നു (എന്തൊക്കെ അല്ല)

ഉപകരണം വിവർത്തനം ചെയ്യേണ്ടതെന്ന് നിർണ്ണയിക്കുന്നത് തരം പരിശോധനയിലൂടെയാണ്:

✅ വിവർത്തനം ചെയ്യപ്പെടുന്നു:

സ്ട്രിംഗ് മൂല്യങ്ങൾ: "Welcome" → "Bienvenue"
അരേ സ്ട്രിംഗുകൾ: ["Hello", "World"] → ["Bonjour", "Monde"]
ഏത് നെസ്റ്റിംഗ് തലത്തിലുമുള്ള സ്ട്രിംഗുകൾ

❌ വിവർത്തനം ചെയ്യപ്പെടുന്നില്ല:

സംഖ്യകൾ: 42, 3.14, -10 മാറ്റമില്ലാതെ തുടരുന്നു
ബൂളിയൻ: true കൂടാതെ false അതേപടി
ശൂന്യം: null null ആയി തുടരുന്നു
ഒബ്ജക്റ്റ് കീകൾ: "userName" കീ ആയി "userName" ആയി തുടരുന്നു
ശൂന്യ സ്ട്രിംഗുകൾ: "" "" ആയി തുടരുന്നു

പ്രത്യേക പ്രതീകങ്ങൾ കൈകാര്യം ചെയ്യൽ

യൂണിക്കോഡ് കൂടാതെ ഇമോജി ഉപകരണം UTF-8 ശരിയായി കൈകാര്യം ചെയ്യുന്നു, അതിനാൽ ഇമോജി കൂടാതെ നോൺ-ലാറ്റിൻ പ്രതീകങ്ങൾ നന്നായി പ്രവർത്തിക്കുന്നു:

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

സ്പാനിഷിലേക്ക് വിവർത്തനം ചെയ്യുന്നു:

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

എസ്കേപ്പ് സീക്വൻസുകൾ JSON എസ്കേപ്പ് സീക്വൻസുകൾ (\n, \t, \") സംരക്ഷിക്കപ്പെടുന്നു:

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

\n വിവർത്തനത്തിൽ അതേപടി തുടരുന്നു.

പ്ലേസ്ഹോൾഡർ ഇവിടെ ഒരു സാധ്യമായ പ്രശ്നം: നിങ്ങളുടെ സ്ട്രിംഗുകൾ {username} അല്ലെങ്കിൽ %s പോലുള്ള പ്ലേസ്ഹോൾഡർ അടങ്ങിയിരിക്കുകയാണെങ്കിൽ, അവ വിവർത്തനം ചെയ്യപ്പെടുകയോ പുനഃക്രമീകരിക്കപ്പെടുകയോ ചെയ്യാം. അറബിക്കോ ഹെബ്രൂവിലോ വലത്തുനിന്ന് ഇടത്തേക്കുള്ള വാചകങ്ങളിൽ, പ്ലേസ്ഹോൾഡർ സ്ഥാനങ്ങൾ മാറിയേക്കാം. ഇവ സൂക്ഷ്മമായി പരിശോധിക്കുക.

വലിയ JSON പ്രകടനം

വെബ്-അധിഷ്ഠിത ഉപകരണം സാധാരണ i18n ഫയലുകൾ (500KB വരെ) യാതൊരു പ്രശ്നവുമില്ലാതെ കൈകാര്യം ചെയ്യുന്നു. വലിയ ഡാറ്റാസെറ്റുകൾക്ക്:

500KB - 2MB: പ്രവർത്തിക്കുന്നു, പക്ഷേ ബ്രൗസറിൽ മന്ദഗതിയിൽ
2MB കവിഞ്ഞ്: യുക്തിപരമായ ഖണ്ഡങ്ങളായി വിഭജിക്കുന്നതിനെ പരിഗണിക്കുക (ഉദാഹരണത്തിന്, ഫീച്ചർ അല്ലെങ്കിൽ വിഭാഗം പ്രകാരം വേർതിരിച്ച ഫയലുകൾ)

ബ്രൗസർ മെമ്മറിയാണ് പരിമിതിയുണ്ടാക്കുന്നത്, അൽഗോരിതം തന്നെയല്ല.

വ്യക്തമാക്കിയ ചോദ്യങ്ങൾ

ഇതു് Google Translate-ൽ JSON പേസ്റ്റ് ചെയ്യുന്നതിൽ നിന്നു് എങ്ങനെ വ്യത്യാസപ്പെടുന്നു?

Google Translate JSON-നെ പ്ലെയിൻ ടെക്സ്റ്റ് ആയി കണക്കാക്കുന്നു, അതിനർത്ഥം അതു് കീകൾ, സിന്റാക്സ് അക്ഷരങ്ങൾ, സംഖ്യാമൂല്യങ്ങൾ എന്നിവയെല്ലാം വിവർത്തനം ചെയ്യാൻ ശ്രമിക്കുന്നു. നിങ്ങൾക്കു് ഇങ്ങനെയുള്ള ഔട്ട്പുട്ട് ലഭിക്കും:

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

"username" "nom d'utilisateur" ആയി മാറിയതും 25 സംഖ്യ "vingt-cinq" സ്ട്രിംഗ് ആയി മാറിയതും കാണാം. നിങ്ങളുടെ കോഡ് ഉടൻ തകരുന്നു.

ഈ ഉപകരണം JSON സ്ട്രക്ചർ മനസ്സിലാക്കുകയും കീകളും മറ്റ് ഡാറ്റാ തരങ്ങളും അതിനുമുകളിൽ വിടുകയും സ്ട്രിംഗ് മൂല്യങ്ങൾ മാത്രം വിവർത്തനം ചെയ്യുകയും ചെയ്യുന്നു.

ഇതു് അരേ അടങ്ങിയ JSON-നെ കൈകാര്യം ചെയ്യുമോ?

അതെ. റിക്കഴ്സീവ് അൽഗോരിതം നെസ്റ്റിംഗിന്റെ എല്ലാ തലങ്ങളും പ്രോസസ്സ് ചെയ്യുന്നു:

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

ഇതു് JSON സ്ട്രക്ചർ പൂർണ്ണമായി നിലനിർത്തിക്കൊണ്ടു് ("John", "Jane", "admin", "editor", "viewer") എല്ലാ സ്ട്രിംഗ് മൂല്യങ്ങളും വിവർത്തനം ചെയ്യുന്നു.

ബാക്കിയുള്ള വിവർത്തനം മലയാളത്തിൽ തുടരുന്നു...

അനുബന്ധങ്ങളും കൂടുതൽ വായനയ്ക്കുള്ള വിവരങ്ങളും

JSON സ്ട്രക്ചർ, അന്തർദ്ദേശീയവൽക്കരണ മാനദണ്ഡങ്ങൾ, മികച്ച പ്രാക്ടീസുകൾ എന്നിവയെക്കുറിച്ച് അഗാധമായ ധാരണ നേടുന്നതിന്:

ECMA-404: JSON ഡാറ്റ വിനിമയ സിന്റാക്സ് - Ecma International നൽകിയ ഔദ്യോഗിക JSON നിർവ്വചനം, സ്റ്റാൻഡേർഡ് ഫോർമാറ്റ്: ecma-international.org/publications-and-standards/standards/ecma-404/
MDN വെബ് ഡോക്സ്: JSON വർക്കിംഗ് - JSON പാഴ്സിംഗ്, സ്ട്രിംഗിഫിക്കേഷൻ, സ്ട്രക്ചർ എന്നിവയുടെ മൊസില്ലയുടെ വിശദമായ മാർഗ്ഗനിർദ്ദേശം: developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/JSON
W3C അന്തർദ്ദേശീയവൽക്കരണ (i18n) പ്രവർത്തനം - വെബ് അന്തർദ്ദേശീയവൽക്കരണത്തിനുള്ള മാനദണ്ഡങ്ങളും മികച്ച പ്രാക്ടീസുകളും: w3.org/International/
RFC 8259: JSON ഡാറ്റ വിനിമയ ഫോർമാറ്റ് - JSON സിന്റാക്സ്, സെമാന്റിക്സ് എന്നിവയ്ക്കുള്ള IETF നിർവ്വചനം: datatracker.ietf.org/doc/html/rfc8259

JSON ഫയലുകൾ വിവർത്തനം ആരംഭിക്കുക

മൾട്ടിലിംഗ്വൽ അപ്ലിക്കേഷനിലേക്ക് വിവർത്തന ഫയലുകൾ വേഗത്തിൽ സൃഷ്ടിക്കേണ്ടതുണ്ടോ? നിങ്ങളുടെ JSON പേസ്റ്റ് ചെയ്യുക, ലക്ഷ്യ ഭാഷ തിരഞ്ഞെടുക്കുക, എന്നിട്ട് ഉടനെ സ്ട്രക്ചർ സംരക്ഷിക്കുന്ന വിവർത്തനങ്ങൾ നേടുക. i18next, react-intl, vue-i18n, എന്നിവയുമായി പ്രവർത്തിക്കുന്നു, വ്യത്യസ്ത ഭാഷകളിൽ സ്ഥിരമായ JSON സ്ട്രക്ചർ പ്രതീക്ഷിക്കുന്ന ഏത് ഫ്രെയിംവർക്കിനും അനുയോജ്യം.

വിവർത്തനം ഇപ്പോൾ ആരംഭിക്കുക: