JSON ਅਨੁਵਾਦਕ ਜੋ ਸਟਰਕਚਰ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ | ਮੁਫਤ i18n ਟੂਲ
ਮੁਫਤ JSON ਅਨੁਵਾਦਕ ਜੋ ਤੁਹਾਡੀ ਸਟਰਕਚਰ ਨੂੰ ਅਖੰਡ ਰੱਖਦਾ ਹੈ। i18n ਫਾਈਲਾਂ, API ਪ੍ਰਤੀਕਿਰਿਆਵਾਂ ਅਤੇ ਨੈਸਟਡ JSON ਨੂੰ ਅਨੁਵਾਦ ਕਰੋ ਜਦਕਿ ਕੁੰਜੀਆਂ, ਡਾਟਾ ਟਾਈਪਾਂ ਅਤੇ ਫਾਰਮੈਟਿੰਗ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖੋ। i18next ਅਤੇ ਬਹੁ-ਭਾਸ਼ਾਈ ਐਪਸ ਲਈ ਬਿਲਕੁਲ ਸਹੀ।
JSON ਸਟਰਕਚਰ-ਪ੍ਰਿਜ਼ਰਵਿੰਗ ਅਨੁਵਾਦਕ
ਇਹ ਟੂਲ JSON ਆਬਜੈਕਟਾਂ ਦੀ ਸਮੱਗਰੀ ਦਾ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ ਜਦਕਿ ਉਨ੍ਹਾਂ ਦੀ ਸਟਰਕਚਰ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ। ਆਪਣਾ JSON ਖੱਬੇ ਪੈਨਲ ਵਿੱਚ ਪੇਸਟ ਕਰੋ, ਇੱਕ ਲੱਕਵਾਂ ਭਾਸ਼ਾ ਚੁਣੋ, ਅਤੇ ਸੱਜੇ ਪੈਨਲ ਵਿੱਚ ਅਨੁਵਾਦਿਤ ਆਉਟਪੁਟ ਵੇਖੋ।
ਅਨੁਵਾਦਿਤ ਆਉਟਪੁਟ ਇੱਥੇ ਦਿਖਾਈ ਦੇਵੇਗਾ...
ਵਰਤਣ ਦਾ ਤਰੀਕਾ
- ਆਪਣੇ JSON ਆਬਜੈਕਟ ਨੂੰ ਸਰੋਤ JSON ਫੀਲਡ ਵਿੱਚ ਪੇਸਟ ਕਰੋ।
- ਡਰੌਪਡਾਊਨ ਮੇਨੂ ਤੋਂ ਆਪਣੀ ਲੱਕਵਾਂ ਭਾਸ਼ਾ ਚੁਣੋ।
- ਅਨੁਵਾਦਿਤ JSON ਸੱਜੇ ਪੈਨਲ ਵਿੱਚ ਆਪਣੇ-ਆਪ ਦਿਖਾਈ ਦੇਵੇਗਾ।
- ਅਨੁਵਾਦਿਤ JSON ਨੂੰ ਆਪਣੇ ਕਲਿੱਪਬੋਰਡ ਤੇ ਕਾਪੀ ਕਰਨ ਲਈ ਕਾਪੀ ਬਟਨ ਤੇ ਕਲਿੱਕ ਕਰੋ।
ਦਸਤਾਵੇਜ਼ੀਕਰਣ
ਜੋਸਨ ਸਟਰਕਚਰ-ਪ੍ਰਿਜ਼ਰਵਿੰਗ ਅਨੁਵਾਦਕ ਕੀ ਹੈ?
ਕੀ ਤੁਸੀਂ ਕਦੇ ਜੋਸਨ ਨੂੰ ਗੂਗਲ ਅਨੁਵਾਦ ਵਿੱਚ ਕਾਪੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਹੈ ਅਤੇ ਟੁੱਟੇ ਹੋਏ ਕੁੰਜੀਆਂ, ਗਾਇਬ ਬ੍ਰੈਕਟਸ, ਜਾਂ ਬਿਗੜੇ ਹੋਏ ਸਿੰਟੈਕਸ ਨਾਲ ਅੰਤ ਹੋਇਆ? ਇਹ ਠੀਕ ਉਹੀ ਸਮੱਸਿਆ ਹੈ ਜਿਸ ਨੂੰ ਇਹ ਟੂਲ ਹੱਲ ਕਰਦਾ ਹੈ।
ਇੱਕ ਜੋਸਨ ਸਟਰਕਚਰ-ਪ੍ਰਿਜ਼ਰਵਿੰਗ ਅਨੁਵਾਦਕ ਸਟਰਿੰਗ ਮੁੱਲਾਂ ਨੂੰ ਤੁਹਾਡੇ ਜੋਸਨ ਆਬਜੈਕਟਸ ਦੇ ਅੰਦਰ ਇੱਕ ਹੋਰ ਭਾਸ਼ਾ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ ਜਦਕਿ ਹਰ ਚੀਜ਼ ਨੂੰ ਅਨਟੁੱਚਡ ਰੱਖਦਾ ਹੈ—ਕੁੰਜੀਆਂ ਉਹੀ ਰਹਿੰਦੀਆਂ ਹਨ, ਨੰਬਰ ਨੰਬਰ ਰਹਿੰਦੇ ਹਨ, ਬੂਲੀਅਨ ਬੂਲੀਅਨ ਰਹਿੰਦੇ ਹਨ, ਅਤੇ ਤੁਹਾਡੀ ਨੈਸਟਡ ਸਟਰਕਚਰ ਨਹੀਂ ਢਹਿੰਦਾ।
ਇੱਥੇ ਉਹ ਹੈ ਜੋ ਇਸ ਨੂੰ ਨਿਯਮਿਤ ਅਨੁਵਾਦ ਟੂਲਸ ਤੋਂ ਵੱਖਰਾ ਬਣਾਉਂਦਾ ਹੈ: ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਆਮ i18n ਫਾਈਲ ਨੂੰ ਅਨੁਵਾਦ ਕਰਦੇ ਹੋ ਜਿਸ ਵਿੱਚ 50+ ਨੈਸਟਡ ਕੁੰਜੀਆਂ ਹਨ, ਤੁਹਾਨੂੰ ਸਟਰਕਚਰ ਨੂੰ ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਰੱਖਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਤਾਂ ਜੋ ਤੁਹਾਡਾ ਕੋਡ ਅਜੇ ਵੀ ਸਪੈਨਿਸ਼, ਫ੍ਰੈਂਚ, ਜਾਂ ਜਾਪਾਨੀ ਵਿੱਚ 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() ਆਬਜੈਕਟ ਨੂੰ ਅਨੁਵਾਦ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਨ, ਪੂਰੀ ਸਟਰਿੰਗ ਅਨੁਵਾਦ ਕਰਦੇ ਹਨ, ਫਿਰ ਵਾਪਸ ਪਾਰਸ ਕਰਦੇ ਹਨ। ਇਹ ਟੁੱਟ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਅਨੁਵਾਦਕ ਕੁੰਜੀਆਂ, ਬਰੈਕਟਸ, ਅਤੇ ਸਿੰਟੈਕਸ ਨੂੰ ਸੋਧਦਾ ਹੈ। ਰੀਕਰਸਿਵ ਪਹੁੰਚ ਇਸਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਰੋਕਦੀ ਹੈ।
Using the JSON Structure-Preserving Translator
Step-by-Step Guide
1. Paste Your JSON Copy your JSON object and paste it into the left panel. The tool handles any valid JSON—whether it's a simple object with 5 keys or a deeply nested structure with arrays and multiple levels.
2. Select Target Language Choose from the language dropdown: Spanish, French, German, Italian, Portuguese, Chinese, Japanese, Korean, Russian, and more. If you're translating for an i18next project, match the language code your framework expects.
3. Get Instant Translation The translated output appears automatically in the right panel. No "Translate" button needed—it processes as soon as you have valid JSON and a selected language.
4. Copy and Use Click the "Copy" button to grab the translated JSON. It's ready to paste directly into your project—no cleanup needed.
5. Clear for Next Translation Hit "Clear All" when you're ready to translate another file. The tool resets both panels instantly.
Common Issues and Solutions
"Invalid JSON Format" Error You'll see this when there's a syntax problem. Common culprits:
- Missing comma between key-value pairs
- Trailing comma after the last item (valid in JavaScript, not JSON)
- Single quotes instead of double quotes
- Unescaped special characters in strings
Quick fix: Run your JSON through a validator like JSONLint before pasting.
Translation Fails Silently If the output panel stays empty:
- Check your internet connection—translation requires API access
- Verify you've selected a target language
- Try with a smaller JSON snippet to isolate the problem
Unexpected Results in Translation Machine translation works well for standard phrases but struggles with:
- Technical jargon or domain-specific terms
- Brand names (which should often stay untranslated)
- Placeholder syntax like
{{username}}or%s
For production applications, use this tool as a first pass, then have a native speaker review domain-specific or customer-facing content.
Pro Tips for Better Results
Keep Technical Strings Separate If your JSON mixes user-facing text with technical identifiers, consider splitting them. For example:
1{
2 "display": {"welcome": "Welcome back"},
3 "config": {"apiKey": "abc123", "endpoint": "https://api.example.com"}
4}
5Translate the display object separately to avoid accidentally processing the config values.
Use Context in Your Strings "Submit" could translate differently depending on context. "Submit form" or "Submit payment" gives translators (human or machine) better context for accurate results.
Test with Real Data Before translating your entire i18n file with 500+ keys, test with a small sample that includes all your data types—strings, numbers, nested objects, arrays.
ਕੋਡ ਉਦਾਹਰਣਾਂ
ਜਾਵਾਸਕ੍ਰਿਪਟ ਨਾਲ JSON ਅਨੁਵਾਦ ਕਰਨਾ
1// ਜਾਵਾਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇਸੇ ਤਰ੍ਹਾਂ ਦੀ ਕਾਰਯਕ੍ਮਤਾ ਦਾ ਉਦਾਹਰਣ
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ਪਾਇਥਨ ਨਾਲ JSON ਅਨੁਵਾਦ ਕਰਨਾ
1import json
2
3def translate_json_structure(json_obj, target_language):
4 """
5 JSON ਵਸਤੂ ਵਿੱਚ ਸਟਰਿੰਗ ਮੁੱਲਾਂ ਨੂੰ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ ਜਦਕਿ ਸਟਰਕਚਰ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ।
6
7 ਆਰਗੂਮੈਂਟਸ:
8 json_obj: ਪਾਰਸ ਕੀਤਾ ਗਿਆ JSON ਆਬਜੈਕਟ
9 target_language: ਟਾਰਗੇਟ ਭਾਸ਼ਾ ਕੋਡ (ਉਦਾ., 'es', 'fr')
10
11 ਰਿਟਰਨ:
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": ["ਜਾਵਾਸਕ੍ਰਿਪਟ", "ਪਾਇਥਨ", "ਰੀਐਕਟ"],
45 "active": True,
46 "followers": 245
47 }
48}
49
50translated_json = translate_json_structure(source_json, "fr")
51print(json.dumps(translated_json, indent=2))
52PHP ਨਾਲ 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 ਫਾਰਮੈਟ ਵਿੱਚ ਸਟੋਰ ਕਰਦੇ ਹਨ। ਜਦੋਂ ਤੁਹਾਨੂੰ ਆਪਣੀ ਐਪ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਭਾਸ਼ਾ ਜੋੜਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਤੁਹਾਡੇ ਸਾਹਮਣੇ ਇੱਕ ਚੋਣ ਹੈ: ਹਰੇਕ ਕੁੰਜੀ ਨੂੰ ਮੈਨੂਅਲੀ ਕਾਪੀ-ਪੇਸਟ ਅਤੇ ਅਨੁਵਾਦ ਕਰਨਾ (ਗਲਤੀ ਵਾਲਾ), ਜਾਂ ਇਸ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੁਝ ਮਿੰਟਾਂ ਵਿੱਚ ਇੱਕ ਪਹਿਲਾ ਡਰਾਫਟ ਤਿਆਰ ਕਰਨਾ।
ਇੱਕ ਅਸਲ ਸਥਿਤੀ: ਤੁਹਾਡੀ ਐਪ ਵਿੱਚ en.json ਹੈ ਜਿਸ ਵਿੱਚ 200+ ਅਨੁਵਾਦ ਕੁੰਜੀਆਂ ਹਨ ਜੋ ਨੈਸਟਡ ਸ਼੍ਰੇਣੀਆਂ ਵਿੱਚ ਫੈਲੀਆਂ ਹੋਈਆਂ ਹਨ—ਨੇਵੀਗੇਸ਼ਨ, ਫਾਰਮ, ਗਲਤੀ ਦੇ ਸੁਨੇਹੇ, ਟੂਲਟਿਪਸ। ਤੁਹਾਨੂੰ ਅਗਲੇ ਸਪ੍ਰਿੰਟ ਤੱਕ ਫ੍ਰੈਂਚ ਅਤੇ ਜਰਮਨ ਸੰਸਕਰਣ ਚਾਹੀਦੇ ਹਨ।
ਇਨਪੁਟ (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') ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਬਦਲਾਵ ਦੇ ਰੈਫਰੈਂਸ ਕਰਦਾ ਹੈ।
ਮੈਂ ਜੋ ਚੰਗਾ ਮੰਨਦਾ ਹਾਂ: ਇਸ ਟੂਲ ਨਾਲ ਅਨੁਵਾਦ ਤਿਆਰ ਕਰੋ, ਫਿਰ ਇੱਕ ਦੋ-ਭਾਸ਼ੀ ਟੀਮ ਮੈਂਬਰ ਨੂੰ ਤਕਨੀਕੀ ਸ਼ਬਦਾਂ ਅਤੇ ਬਟਨ ਲੇਬਲਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦਿਓ। ਇਹ ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਨੂੰ ਫੜ ਲੈਂਦਾ ਹੈ ਜਿੱਥੇ "ਸਬਮਿਟ" ਨੂੰ "ਫਾਰਮ ਸਬਮਿਟ ਕਰੋ" ਬਨਾਮ "ਭੁਗਤਾਨ ਸਬਮਿਟ ਕਰੋ" ਲਈ ਵੱਖ-ਵੱਖ ਅਨੁਵਾਦ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ।
[ਬਾਕੀ ਦਾ ਅਨੁਵਾਦ ਜਾਰੀ ਰਹੇਗਾ...]
ਅਨੁਵਾਦ ਦੇ ਤਰੀਕਿਆਂ ਦੀ ਤੁਲਨਾ
| ਤਰੀਕਾ | ਸਭ ਤੋਂ ਵਧੀਆ ਲਈ | ਗਤੀ | ਸਟੀਕਤਾ | ਸਟਰਕਚਰ ਸੁਰੱਖਿਆ | ਲਾਗਤ |
|---|---|---|---|---|---|
| ਇਹ ਟੂਲ | ਤੁਰੰਤ i18n ਫਾਈਲ ਉਤਪਾਦਨ, ਪ੍ਰੋਟੋਟਾਈਪ, ਅੰਦਰੂਨੀ ਟੂਲ | ਤੁਰੰਤ | ਮਾਮੂਲੀ ਸਮੱਗਰੀ ਲਈ ਚੰਗੀ | 100% ਸੁਰੱਖਿਅਤ | ਮੁਫਤ |
| ਗੂਗਲ ਅਨੁਵਾਦ (ਕਾਪੀ/ਪੇਸਟ) | ਇੱਕ ਵਾਕ, ਗੈਰ-ਤਕਨੀਕੀ ਪਾਠ | ਤੁਰੰਤ | ਵੱਖ-ਵੱਖ | JSON ਤੋੜਦਾ ਹੈ | ਮੁਫਤ |
| ਪੇਸ਼ੇਵਰ ਅਨੁਵਾਦ | ਗਾਹਕ-ਸਾਹਮਣੇ ਸਮੱਗਰੀ, ਕਾਨੂੰਨੀ ਦਸਤਾਵੇਜ਼, ਮਾਰਕੇਟਿੰਗ | ਦਿਨ | ਬਹੁਤ ਵਧੀਆ | ਮੈਨੂਅਲ ਕੰਮ ਦੀ ਲੋੜ | $0.08-0.15/ਸ਼ਬਦ |
| ਅਨੁਵਾਦ ਪ੍ਰਬੰਧਨ ਸਿਸਟਮ (Lokalise, Phrase) | ਉਦਯੋਗਿਕ ਐਪਸ, ਸਹਿਯੋਗ ਵਰਕਫਲੋ | ਘੰਟੇ-ਦਿਨ | ਸਮੀਖਿਆ ਨਾਲ ਬਹੁਤ ਵਧੀਆ | ਬਿਲਟ-ਇਨ JSON ਸਮਰਥਨ | $$$+ |
ਇਸ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਦੋਂ ਕਰਨੀ ਹੈ: ਸ਼ੁਰੂਆਤੀ ਪ੍ਰੋਜੈਕਟ, ਸਮੀਖਿਆ ਲਈ ਡਰਾਫਟ ਤਿਆਰ ਕਰਨਾ, ਅੰਦਰੂਨੀ ਐਪਲੀਕੇਸ਼ਨ ਜਿੱਥੇ ਬਿਲਕੁਲ ਸਹੀ ਅਨੁਵਾਦ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ।
ਪੇਸ਼ੇਵਰ ਅਨੁਵਾਦ ਵਿੱਚ ਨਿਵੇਸ਼ ਕਦੋਂ ਕਰਨਾ ਹੈ: ਗਾਹਕ-ਸਾਹਮਣੇ ਸਮੱਗਰੀ, ਕਾਨੂੰਨੀ/ਪਾਲਣਾ ਪਾਠ, ਬ੍ਰਾਂਡ ਸੰਦੇਸ਼, ਜਾਂ ਜਦੋਂ ਸੱਭਿਆਚਾਰਕ ਨੁਆਂਸ ਗਤੀ ਤੋਂ ਵੱਧ ਮਹੱਤਵਪੂਰਨ ਹੋਵੇ।
ਤਕਨੀਕੀ ਵਿਚਾਰ ਅਤੇ ਕੋਨੇ ਦੇ ਕੇਸ
ਕੀ ਅਨੁਵਾਦ ਹੁੰਦਾ ਹੈ (ਅਤੇ ਕੀ ਨਹੀਂ)
ਟੂਲ ਅਨੁਵਾਦ ਕਰਨ ਲਈ ਟਾਈਪ ਚੈਕਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ:
✅ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ:
- ਸਟਰਿੰਗ ਮੁੱਲ:
"Welcome"→"Bienvenue" - ਐਰੇ ਵਿੱਚ ਸਟਰਿੰਗ:
["Hello", "World"]→["Bonjour", "Monde"] - ਕਿਸੇ ਵੀ ਨੈਸਟਿੰਗ ਸਤਰ 'ਤੇ ਸਟਰਿੰਗ
❌ ਅਨੁਵਾਦ ਨਹੀਂ ਕੀਤਾ ਗਿਆ:
- ਨੰਬਰ:
42,3.14,-10ਬਦਲਾਅ ਤੋਂ ਬਿਨਾਂ ਰਹਿੰਦੇ ਹਨ - ਬੂਲੀਅਨ:
trueਅਤੇfalseਉਸੇ ਤਰ੍ਹਾਂ ਰਹਿੰਦੇ ਹਨ - ਨਲ:
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, ਤਾਂ ਉਹ ਅਨੁਵਾਦਿਤ ਜਾਂ ਮੁੜ ਕ੍ਰਮਬੱਧ ਹੋ ਸਕਦੇ ਹਨ। ਅਰਬੀ ਜਾਂ ਹਿਬਰੂ ਵਿੱਚ RTL ਪਾਠ ਦੇ ਨਾਲ, ਪਲੇਸਹੋਲਡਰ ਦੀ ਸਥਿਤੀ ਬਦਲ ਸਕਦੀ ਹੈ। ਇਨ੍ਹਾਂ ਨੂੰ ਧਿਆਨ ਨਾਲ ਜਾਂਚੋ।
ਵੱਡੇ 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ਇਹ ਸਾਰੇ ਸਟਰਿੰਗ ਮੁੱਲਾਂ ("John", "Jane", "admin", "editor", "viewer") ਦਾ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ ਜਦਕਿ ਸਟਰਕਚਰ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ।
ਜੇਕਰ ਮੇਰੇ JSON ਵਿੱਚ ਅੰਗਰੇਜ਼ੀ ਅਤੇ ਪਹਿਲੇ ਤੋਂ ਹੀ ਅਨੁਵਾਦਿਤ ਸਮੱਗਰੀ ਹੈ?
ਟੂਲ ਇਹ ਲੱਭਦਾ ਹੈ ਕਿ ਉਹ ਹਰ ਸਟਰਿੰਗ ਦਾ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ, ਭਾਵੇਂ ਕੁਝ ਪਹਿਲੇ ਤੋਂ ਹੀ ਲੱਕ ਭਾਸ਼ਾ ਵਿੱਚ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ ਮੌਜੂਦਾ ਅਨੁਵਾਦ ਫਾਈਲ ਵਿੱਚ ਨਵੀਆਂ ਕੁੰਜੀਆਂ ਜੋੜ ਰਹੇ ਹੋ, ਤਾਂ ਸਿਰਫ ਨਵੇਂ ਭਾਗ ਦਾ ਅਲੱਗ ਤੋਂ ਅਨੁਵਾਦ ਕਰੋ, ਫਿਰ ਨਤੀਜਿਆਂ ਨੂੰ ਮਿਲਾਓ।
ਕੀ ਮੈਂ ਇਸ ਨੂੰ i18next ਜਾਂ react-intl ਫਾਈਲਾਂ ਲਈ ਵਰਤ ਸਕਦਾ ਹਾਂ?
ਬਿਲਕੁਲ। ਆਉਟਪੁੱਟ ਸਟਰਕਚਰ ਉਨ੍ਹਾਂ ਫਰੇਮਵਰਕਾਂ ਦੀਆਂ ਅਪੇਖਿਆਵਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਇੱਕ i18next JSON ਫਾਈਲ ਵਜੋਂ:
1{"translation": {"welcome": "Hello", "goodbye": "Goodbye"}}
2ਬਣ ਜਾਂਦਾ ਹੈ:
1{"translation": {"welcome": "Hola", "goodbye": "Adiós"}}
2ਤੁਹਾਡੇ t('translation.welcome') ਕਾਲਾਂ ਬਿਨਾਂ ਬਦਲਾਵ ਦੇ ਕੰਮ ਕਰਦੀਆਂ ਹਨ।
ਤਕਨੀਕੀ ਸਮੱਗਰੀ ਲਈ ਆਟੋਮੇਟਡ ਅਨੁਵਾਦ ਕਿੰਨਾ ਸਟੀਕ ਹੈ?
ਇਹ ਸੰਦਰਭ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ:
- ਸਧਾਰਨ UI ਪਾਠ: "Save", "Cancel", "Submit" → ਆਮ ਤੌਰ 'ਤੇ ਸਟੀਕ
- ਤਕਨੀਕੀ ਸ਼ਬਦਾਵਲੀ: "webhook", "OAuth2", "idempotent" → ਗਲਤ ਅਨੁਵਾਦ ਹੋ ਸਕਦਾ ਹੈ ਜਾਂ ਉਸੇ ਤਰ੍ਹਾਂ ਰਹਿ ਸਕਦਾ ਹੈ
- ਡੋਮੇਨ-ਵਿਸ਼ੇਸ਼ ਸ਼ਬਦ: "patient record" (ਮੈਡੀਕਲ) ਬਨਾਮ "patient" (ਧੀਰਜ) → ਸੰਦਰਭ ਅਕਸਰ ਖੁੰਝ ਜਾਂਦਾ ਹੈ
ਉਤਪਾਦਨ ਐਪਾਂ ਲਈ, ਇਸ ਨੂੰ ਪਹਿਲੀ ਵਾਰ ਵਜੋਂ ਵਰਤੋ, ਫਿਰ ਕਿਸੇ ਨੂੰ ਤਕਨੀਕੀ ਅਤੇ ਡੋਮੇਨ-ਵਿਸ਼ੇਸ਼ ਸ਼ਬਦਾਂ ਦੀ ਸਮੀਖਿਆ ਕਰਨ ਦਿਓ।
ਵੱਖ-ਵੱਖ ਅੱਖਰ ਸੈੱਟ ਵਾਲੀਆਂ ਭਾਸ਼ਾਵਾਂ (ਚੀਨੀ, ਅਰਬੀ, ਰੂਸੀ) ਬਾਰੇ ਕੀ?
ਟੂਲ Unicode ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ, ਇਸਲਈ ਸਾਰੇ ਅੱਖਰ ਸੈੱਟ ਕੰਮ ਕਰਦੇ ਹਨ। ਇੱਕ ਚੀਜ਼ 'ਤੇ ਧਿਆਨ ਦੇਣਾ: ਅਰਬੀ ਅਤੇ ਹਿਬਰੂ ਸੱਜੇ-ਤੋਂ-ਖੱਬੇ (RTL) ਹਨ, ਜੋ ਅਨੁਵਾਦਿਤ ਸਟਰਿੰਗਾਂ ਵਿੱਚ ਪਲੇਸਹੋਲਡਰਾਂ ਨੂੰ ਪਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। JSON ਸਟਰਕਚਰ ਸਹੀ ਰਹਿੰਦਾ ਹੈ, ਪਰ ਪੜ੍ਹਨ ਯੋਗਤਾ ਲਈ ਅਨੁਵਾਦਿਤ ਪਾਠ ਦੀ ਸਮੀਖਿਆ ਕਰੋ।
ਕੀ ਇਹ ਮੇਰੇ ਫਾਰਮੈਟਿੰਗ (ਇੰਡੈਂਟੇਸ਼ਨ, ਲਾਈਨ ਬਰੇਕ) ਨੂੰ ਬਰਕਰਾਰ ਰੱਖੇਗਾ?
ਆਉਟਪੁੱਟ ਵੈਧ JSON ਹੈ, ਪਰ ਫਾਰਮੈਟਿੰਗ (ਵਾਈਟਸਪੇਸ, ਇੰਡੈਂਟੇਸ਼ਨ) ਤੁਹਾਡੇ ਇਨਪੁੱਟ ਤੋਂ ਵੱਖ ਹੋ ਸਕਦੀ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਵਿਸ਼ੇਸ਼ ਫਾਰਮ
ਸੰਦਰਭ ਅਤੇ ਹੋਰ ਪੜ੍ਹਾਈ
JSON ਸਟਰਕਚਰ, ਅੰਤਰਰਾਸ਼ਟਰੀਕਰਣ ਮਾਨਕਾਂ ਅਤੇ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸਾਂ ਨੂੰ ਡੂੰਘਾਈ ਨਾਲ ਸਮਝਣ ਲਈ:
-
ECMA-404: JSON ਡਾਟਾ ਇੰਟਰਚੇਂਜ ਸਿੰਟੈਕਸ - Ecma International ਵੱਲੋਂ JSON ਦੇ ਮਾਨਕ ਫਾਰਮੈਟ ਨੂੰ ਪਰਿਭਾਸ਼ਤ ਕਰਨ ਵਾਲਾ ਅਧਿਕਾਰਕ ਵਿਸ਼ੇਸ਼ ਸੰਸਕਰਣ: ecma-international.org/publications-and-standards/standards/ecma-404/
-
MDN ਵੈਬ ਡੌਕਸ: JSON ਨਾਲ ਕੰਮ ਕਰਨਾ - Mozilla ਦਾ 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 ਸਟਰਕਚਰ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ।
ਅਨੁਵਾਦ ਹੁਣੇ ਸ਼ੁਰੂ ਕਰੋ: