JSON ಅನುವಾದಕ ಸಂರಚನೆಯನ್ನು ಕಾಯ್ದಿರಿಸುವ | ಉಚಿತ i18n ಉಪಕರಣ

Q: ಇದನ್ನು i18next ಅಥವಾ react-intl ಕಡತಗಳಿಗೆ ಬಳಸಬಹುದೇ?

ಖಂಡಿತ. ಫಲಿತಾಂಶ ಸಂರಚನೆಯು ಈ ಫ್ರೇಮ್ವರ್ಕ್ಗಳಿಗೆ ನಿರೀಕ್ಷಿಸಿದ ಸಂರಚನೆಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ. i18next JSON ಕಡತ ಹೀಗಿರಬಹುದು: ಇದಾಗಿ ಬದಲಾಗುತ್ತದೆ: ನಿಮ್ಮ t('translation.welcome') ಕರೆಗಳು ಬದಲಾಗದೇ ಉಳಿಯುತ್ತವೆ.

Q: ತಾಂತ್ರಿಕ ಸಾಮಗ್ರಿಗಾಗಿ ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದ ಎಷ್ಟು ನಿಖರವಾಗಿದೆ?

ಸಂದರ್ಭದ ಮೇಲೆ ಅವಲಂಬಿಸಿದೆ: ಸಾಮಾನ್ಯ UI ಪಠ್ಯ: "ಉಳಿಸಿ", "ರದ್ದು", "ಸಲ್ಲಿಸಿ" → ಸಾಮಾನ್ಯತಃ ನಿಖರ ತಾಂತ್ರಿಕ ಪದಗಳು: "webhook", "OAuth2", "idempotent" → ತಪ್ಪಾಗಿ ಅನುವಾದಿಸಬಹುದು ಅಥವಾ ಅಪಿವಾಹ್ಯವಾಗಿ ಉಳಿಯಬಹುದು ಡೊಮೇನ್-ನಿಶ್ಚಿತ ಪದಗಳು: "patient record" (ವೈದ್ಯಕೀಯ) vs "patient" (ಧೈರ್ಯ) → ಸಂದರ್ಭ ಅಕ್ಸರ ಕಳೆದುಹೋಗುತ್ತದೆ ಉತ್ಪಾದನಾ ಅಪ್ಲಿಕೇಶನ್ಗಳಿಗೆ, ಇದನ್ನು ಮೊದಲ ಹಂತವಾಗಿ ಬಳಸಿ, ನಂತರ ಯಾರಾದರೂ ತಾಂತ್ರಿಕ ಮತ್ತು ಡೊಮೇನ್-ನಿಶ್ಚಿತ ಪದಗಳನ್ನು ಪರಿಶೀಲಿಸಲಿ. (ಅನುವಾದ ಮುಂದುವರಿಯುತ್ತದೆ...)

ಉಚಿತ JSON ಅನುವಾದಕ ಯಾವ ಸಂರಚನೆಯನ್ನೂ ಕಾಯ್ದಿರಿಸುತ್ತದೆ. i18n ಕಡತಗಳನ್ನು, API ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಮತ್ತು ಅಂತಸ್ಥ JSON ಅನ್ನು ಕೀಲಿಗಳನ್ನು, ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಮತ್ತು ಫಾರ್ಮೇಟಿಂಗ್ ಅನ್ನು ಕಾಯ್ದಿರಿಸಿಕೊಂಡು ಅನುವಾದಿಸಿ. i18next ಮತ್ತು ಬಹುಭಾಷಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸಂಪೂರ್ಣ.

JSON ಸಂರಚನೆಯನ್ನು ಕಾಯ್ದುಕೊಳ್ಳುವ ಅನುವಾದಕ

ಈ ಉಪಕರಣವು JSON ವಸ್ತುಗಳ ವಿಷಯವನ್ನು ಅವುಗಳ ಸಂರಚನೆಯನ್ನು ಕಾಯ್ದುಕೊಂಡು ಅನುವಾದಿಸುತ್ತದೆ. ಎಡ ಫಲಕದಲ್ಲಿ ನಿಮ್ಮ JSON ಅನ್ನು ಅಂಟಿಸಿ, ಗುರಿ ಭಾಷೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡಿ, ಬಲ ಫಲಕದಲ್ಲಿ ಅನುವಾದಿಸಿದ ಫಲಿತಾಂಶವನ್ನು ನೋಡಿ.

ಗುರಿ ಭಾಷೆ:

ಮೂಲ JSON

ಅನುವಾದಿಸಿದ JSON

ಅನುವಾದಿಸಿದ ಫಲಿತಾಂಶ ಇಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವುದು...

ಬಳಸುವ ವಿಧಾನ

ಮೂಲ JSON ಕ್ಷೇತ್ರದಲ್ಲಿ ನಿಮ್ಮ JSON ವಸ್ತುವನ್ನು ಅಂಟಿಸಿ.
ಡ್ರಾಪ್‌ಡೌನ್ ಮೆನುವಿನಿಂದ ನಿಮ್ಮ ಗುರಿ ಭಾಷೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡಿ.
ಅನುವಾದಿಸಿದ JSON ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬಲ ಫಲಕದಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವುದು.
ಅನುವಾದಿಸಿದ JSON ಅನ್ನು ನಿಮ್ಮ ಕ್ಲಿಪ್‌ಬೋರ್ಡ್‌ಗೆ ನಕಲಿಸಲು ನಕಲಿಸಿ ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ.

ಲೋಡಿಂಗ್ ಕ್ಯಾಲ್ಕ್ಯುಲೇಟರ್...

📚

ದಸ್ತಾವೇಜನೆಯು

JSON ಸಂರಚನೆಯನ್ನು ಕಾಯ್ದುಕೊಳ್ಳುವ ಅನುವಾದಕ ಎಂದರೇನು?

ಯಾವಾಗಲಾದರೂ Google Translate ನಲ್ಲಿ JSON ಅನ್ನು ಕಾಪಿ ಮಾಡಿ, ಮುಚ್ಚಿಹೋಗಿರುವ ಕೀಗಳು, ಕಾಣೆಯಾಗಿರುವ ಬ್ರಾಕೆಟ್‌ಗಳು ಅಥವಾ ಹಾಳಾಗಿರುವ ಸಿಂಟ್ಯಾಕ್ಸ್ ಕಂಡಿದ್ದೀರಾ? ಇದೇ ಸಮಸ್ಯೆಯನ್ನು ಈ ಉಪಕರಣ ಬಗೆಹರಿಸುತ್ತದೆ.

JSON ಸಂರಚನೆಯನ್ನು ಕಾಯ್ದುಕೊಳ್ಳುವ ಅನುವಾದಕ ನಿಮ್ಮ JSON ವಸ್ತುಗಳ ಒಳಗಿನ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳನ್ನು ಇತರ ಭಾಷೆಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಇನ್ನಿತರ ಎಲ್ಲವನ್ನೂ ಅಪಿವರ್ತಿಸಿ ಇಡುತ್ತದೆ—ಕೀಗಳು ಅದೇ ಇರುತ್ತವೆ, ಸಂಖ್ಯೆಗಳು ಸಂಖ್ಯೆಗಳಾಗಿ, ಬೂಲಿಯನ್‌ಗಳು ಬೂಲಿಯನ್‌ಗಳಾಗಿ, ಮತ್ತು ನಿಮ್ಮ ಅಂತಸ್ಥ ಸಂರಚನೆ ಕುಸಿಯುವುದಿಲ್ಲ.

ಇದು ಸಾಮಾನ್ಯ ಅನುವಾದ ಉಪಕರಣಗಳಿಂದ ಭಿನ್ನವಾಗಿ: ನೀವು 50+ ಅಂತಸ್ಥ ಕೀಗಳ ಹೊಂದಿರುವ ಸಾಮಾನ್ಯ i18n ಫೈಲ್‌ಅನ್ನು ಅನುವಾದಿಸಿದಾಗ, ಸಂರಚನೆಯು ಸಂಪೂರ್ಣವಾಗಿ ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಇರಬೇಕು ಏಕೆಂದರೆ ನಿಮ್ಮ ಕೋಡ್ ಇನ್ನೂ ಸ್ಪ್ಯಾನಿಷ್, ಫ್ರೆಂಚ್ ಅಥವಾ ಜಪಾನೀಸ್‌ನಲ್ಲಿ user.profile.displayName ಅನ್ನು ಉಲ್ಲೇಖಿಸಬಹುದು. ಆ ಸಂರಚನೆಯನ್ನು ಮುರಿಯಿರಿ, ಮತ್ತು ನೀವು ಗಂಟಗಟಲೆ ಡೀಬಗ್ ಮಾಡಲು ಸಿದ್ಧರಾಗಿರುತ್ತೀರಿ.

ಈ ಉಪಕರಣವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪುನರಾವರ್ತಕ ಪ್ರಯಾಣವನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ, ಯಾವ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಅನುವಾದ ಬೇಕಾಗಿದೆ ಮತ್ತು ಯಾವ ಘಟಕಗಳನ್ನು (API ಕೀಗಳು, ಸಂರಚನಾ ಮೌಲ್ಯಗಳು ಅಥವಾ ಸಂಖ್ಯಾತ್ಮಕ ಐಡಿಗಳಂತಹವು) ಅಂಥಾ ಇರಿಸಬೇಕೆಂಬುದನ್ನು ಗುರುತಿಸುತ್ತದೆ.

JSON ಸಂರಚನೆ ಸಂರಕ್ಷಣೆ ಹೇಗೆ ಕಾಮ್ ಮಾಡುತ್ತದೆ

ಸಂರಚನೆ ಸಂರಕ್ಷಣೆ ಏಕೆ ಮಹತ್ವಪೂರ್ಣ

ನೀವು JSON ಅನುವಾದ ಮಾಡುವಾಗ, ಈ ಕೆಳಗಿನ ಸ್ಥಿತಿಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿರಬಹುದು:

i18n ಫೈಲ್‌ಗಳು ಎಲ್ಲಿ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ en.json ಮತ್ತು fr.json ಗಳಲ್ಲಿ ಒಂದೇ ಕೀಗಳನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ
API ಪ್ರತಿಕ್ರಿಯೆಗಳು ಕ್ಲೈಂಟ್ ಪಾರ್ಸಿಂಗ್ಗಾಗಿ ಭಾಷೆಗಳ ಮಧ್ಯೆ ಸ್ಥಿರ ಸಂರಚನೆ ಅಗತ್ಯ
ಸಂರಚನಾ ಫೈಲ್‌ಗಳು ಎಲ್ಲಿ ಒಂದು ಕೀ ಹೆಸರನ್ನು ಬದಲಾಯಿಸಿದರೆ ನಿಮ್ಮ ಸಂಪೂರ್ಣ ಅಪ್ಲಿಕೇಶನ್ ಕೆಡುತ್ತದೆ
ಡೇಟಾಬೇಸ್ ಎಕ್ಸ್‌ಪೋರ್ಟ್‌ಗಳು ಎಲ್ಲಿ ಸಂಬಂಧಗಳು ನಿರ್ಧಿಷ್ಟ ಫೀಲ್ಡ್ ಹೆಸರುಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತವೆ

ಸವಾಲು: JSON ಕೇವಲ ಪಠ್ಯವಲ್ಲ. ಇದು ಸಂರಚಿತ ಡೇಟಾ ಮತ್ತು ಒಂದು ಸ್ಕೀಮಾ ಯಾವುದನ್ನು ನಿಮ್ಮ ಕೋಡ್ ಅವಲಂಬಿಸಿಕೊಂಡಿದೆ. "userName" ಅನ್ನು "nombreUsuario" ಗೆ ಬದಲಾಯಿಸಿದರೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ undefined ದೋಷ ಎಸೆಯುತ್ತದೆ.

ಅನುವಾದ ಪ್ರಕ್ರಿಯೆ ಹೇಗೆ ಕಾಮ್ ಮಾಡುತ್ತದೆ

ಇಲ್ಲಿ ಹೊಂಚಿನ ಕೆಳಗೆ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ:

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}
5

Translate 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.

ಕೋಡ್ ಉದಾಹರಣೆಗಳು

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    ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳು:
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": ["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 ಸ್ವರೂಪದಲ್ಲಿ ಅನುವಾದಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತವೆ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಹೊಸ ಭಾಷೆಯನ್ನು ಸೇರಿಸಬೇಕಾಗಿ ಬಂದಾಗ, ನೀವು ಎರಡು ಆಯ್ಕೆಗಳ ನಡುವೆ ಆಯ್ಕೆ ಮಾಡಬೇಕಾಗಿದೆ: ಕೈಯಿಂದ ನಕಲಿಸಿ-ಅಂಟಿಸಿ ಮತ್ತು ಪ್ರತಿ ಕೀಯನ್ನು ಅನುವಾದಿಸಿ (ದೋಷ ಸಾಧ್ಯತೆ ಹೆಚ್ಚಿರುವ), ಅಥವಾ ಈ ಉಪಕರಣವನ್ನು ಬಳಸಿ ಕೆಲವೇ ನಿಮಿಷಗಳಲ್ಲಿ ಮೊದಲ 초ಸ್ಕರಣೆಯನ್ನು ರಚಿಸಿ.

ವಾಸ್ತವಿಕ ಪರಿಸ್ಥಿತಿ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ 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') ಅನ್ನು ಯಾವ ಬದಲಾವಣೆಯಿಲ್ಲದೆ ಉಲ್ಲೇಖಿಸುತ್ತದೆ.

ನಾನು ಒಳ್ಳೆಯದೆಂದು ಕಂಡುಕೊಂಡಿರುವುದು: ಈ ಉಪಕರಣದಿಂದ ಅನುವಾದಗಳನ್ನು ರಚಿಸಿ, ನಂತರ ಬಹುಭಾಷಾ ತಂಡದ ಸದಸ್ಯರಿಗೆ ತಾಂತ್ರಿಕ ಪದಗಳನ್ನು ಮತ್ತು ಬಟನ್ ಲೇಬಲ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಹೇಳಿ. ಇದು "Submit" ಪದವನ್ನು "ಫಾರ್ಮ್ ಸಲ್ಲಿಸಿ" ಮತ್ತು "ಪಾವತಿ ಸಲ್ಲಿಸಿ" ಎಂಬಂತಹ ಭಿನ್ನ ಅನುವಾದಗಳನ್ನು ಗಮನಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

[ಉಳಿದ ಅನುವಾದ ಮುಂದುವರಿಯುತ್ತದೆ...]

ಅನುವಾದ ವಿಧಾನಗಳ ಹೋಲಿಕೆ

ವಿಧಾನ	ಯಾವಾಗ ಉಪಯೋಗಿಸಬೇಕು	ವೇಗ	ನಿಖಾರಿತಾ	ಸಂರಚನಾ ಸುರಕ್ಷೆ	ವೆಚ್ಚ
ಈ ಉಪಕರಣ	ಕ್ಷಿಪ್ರ 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 ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ಗಳಿದ್ದರೆ, ಅವು ಅನುವಾದಿಸಲ್ಪಡಬಹುದು ಅಥವಾ ಮರುಕ್ರಮಿಸಲ್ಪಡಬಹುದು. ಅರಬಿಕ್ ಅಥವಾ ಹೀಬ್ರೂ ಭಾಷೆಗಳಂಥ RTL ಪಠ್ಯಗಳಲ್ಲಿ, ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ ಸ್ಥಾನಗಳು ಬದಲಾಗಬಹುದು. ಇವುಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಶೀಲಿಸಿ.

ದೊಡ್ಡ JSON ಕಾರ್ಯಕ್ಷಮತೆ

ವೆಬ್ ಆಧಾರಿತ ಟೂಲ್ ಸಾಮಾನ್ಯ i18n ಫೈಲ್ಗಳನ್ನು (500KB ಕ್ಕಿಂತ ಕಡಿಮೆ) ಸಮಸ್ಯೆ ಇಲ್ಲದೆ ನಿಭಾಯಿಸುತ್ತದೆ. ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ಗಳಿಗೆ:

500KB - 2MB: ಕಾಮ್ಯೂನಿಕೇಟ್ ಆಗುತ್ತದೆ ಆದರೆ ಬ್ರೌಸರ್ನಲ್ಲಿ ನಿಧಾನ
2MB ಮೇಲೆ: ವಿಭಾಗಗಳಾಗಿ ವಿಭಜಿಸಿ (ಉದಾ. ಪ್ರತ್ಯೇಕ ಫೈಲ್ಗಳಲ್ಲಿ ವೈಶಿಷ್ಟ್ಯ ಅಥವಾ ವಿಭಾಗ)

ಬ್ರೌಸರ್ ಮೆಮೊರಿ ಅಲ್ಗೋರಿಥಂ ಅಲ್ಲ, ಆದರೆ ಮಿತಿಯಾಗಿ ಉಳಿಯುತ್ತದೆ.

ಆಮೂಲಕ ಪ್ರಶ್ನೆಗಳು

ಇದು Google ಅನುವಾದಕಕ್ಕೆ JSON ಅಂಟಿಸುವುದಕ್ಕಿಂತ ಹೇಗೆ ಭಿನ್ನವಾಗಿದೆ?

Google ಅನುವಾದಕ 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 ಪಠ್ಯ: "ಉಳಿಸಿ", "ರದ್ದು", "ಸಲ್ಲಿಸಿ" → ಸಾಮಾನ್ಯತಃ ನಿಖರ
ತಾಂತ್ರಿಕ ಪದಗಳು: "webhook", "OAuth2", "idempotent" → ತಪ್ಪಾಗಿ ಅನುವಾದಿಸಬಹುದು ಅಥವಾ ಅಪಿವಾಹ್ಯವಾಗಿ ಉಳಿಯಬಹುದು
ಡೊಮೇನ್-ನಿಶ್ಚಿತ ಪದಗಳು: "patient record" (ವೈದ್ಯಕೀಯ) vs "patient" (ಧೈರ್ಯ) → ಸಂದರ್ಭ ಅಕ್ಸರ ಕಳೆದುಹೋಗುತ್ತದೆ

ಉತ್ಪಾದನಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ, ಇದನ್ನು ಮೊದಲ ಹಂತವಾಗಿ ಬಳಸಿ, ನಂತರ ಯಾರಾದರೂ ತಾಂತ್ರಿಕ ಮತ್ತು ಡೊಮೇನ್-ನಿಶ್ಚಿತ ಪದಗಳನ್ನು ಪರಿಶೀಲಿಸಲಿ.

(ಅನುವಾದ ಮುಂದುವರಿಯುತ್ತದೆ...)

ಉಲ್ಲೇಖಗಳು ಮತ್ತು ಹೆಚ್ಚಿನ ಓದುವಿಕೆ

JSON ಸಂರಚನೆ, ಅಂತರರಾಷ್ಟ್ರೀಯೀಕರಣ ಮಾನಕಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಅರಿವಿಗಾಗಿ:

ECMA-404: JSON ಡೇಟಾ ವಿನಿಮಯ ಸಿಂಟ್ಯಾಕ್ಸ್ - Ecma ಅಂತರರಾಷ್ಟ್ರೀಯ ನಿಂದ ಅಧಿಕೃತ 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 ಸಂರಚನೆಯನ್ನು ನಿರೀಕ್ಷಿಸುವ ಯಾವುದೇ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಅನುವಾದ ಈಗ ಪ್ರಾರಂಭಿಸಿ: