Rust अनुप्रयोगों का अंतर्राष्ट्रीयकरण: शून्य से बहुभाषीता तक

आपके Rust अनुप्रयोग को अंतर्राष्ट्रीयकरण की आवश्यकता क्यों है (और गलतियाँ कैसे न करें)

आपने Rust में एक आदर्श पार्सर लिखा है। यह बिजली से भी तेज़ चलता है और एक विनम्र चिड़िया से भी कम मेमोरी खाता है। लेकिन एक समस्या है: आपका टेक्स्ट केवल अंग्रेजी में आउटपुट होता है। और टोक्यो, बर्लिन और सेंट पीटर्सबर्ग के उपयोगकर्ता अपनी मातृभाषा में इंटरफ़ेस देखना चाहते हैं।

अंतर्राष्ट्रीयकरण (i18n) केवल "बटन का अनुवाद" नहीं है। यह एक आर्किटेक्चरल निर्णय है जो आपके कोड को एक सुरुचिपूर्ण कंस्ट्रक्टर या if-else का नारकीय ढेर बना सकता है। इस लेख में, हम देखेंगे कि Rust में अंतर्राष्ट्रीयकरण को सही तरीके से कैसे करें: बिना दर्द के, उदाहरणों के साथ और भविष्य के डेवलपर (आपके) के दिमाग के सम्मान के साथ।

हम दो शक्तिशाली दृष्टिकोणों के बारे में बात करेंगे: fluent लाइब्रेरी (Mozilla की अनुशंसा) और gettext पर आधारित क्लासिक rust-i18n। लेख के अंत तक, आप 15 मिनट में अपने टूल में रूसी, अंग्रेजी और किसी भी अन्य भाषा का समर्थन जोड़ पाएंगे।

युद्ध योजना: Rust की दुनिया में i18n और l10n क्या है

कोड में कूदने से पहले, आइए शब्दों पर सहमत हों:

\n
• अंतर्राष्ट्रीयकरण (i18n) — अनुवाद के लिए कोड तैयार करना। आप सभी स्ट्रिंग्स को अलग-अलग फ़ाइलों में निकालते हैं और प्रोग्राम को आवश्यक लोकेल लेने के लिए सिखाते हैं।
\n
• स्थानीयकरण (l10n) — स्वयं अनुवाद। प्रत्येक भाषा के लिए फ़ाइलें बनाना।
\n
• लोकेल — भाषा और क्षेत्र का संयोजन (उदाहरण के लिए, ru-RU, en-US, de-DE)।
\n

Rust में कई रास्ते हैं। हम दो सबसे लोकप्रिय पर विचार करेंगे:

\n
• Fluent — Mozilla की आधुनिक प्रणाली। शक्तिशाली, लचीली, बहुवचन और संदर्भ के समर्थन के साथ।
\n
• rust-i18n — Ruby on Rails से प्रेरित मैक्रोज़। सरल, लेकिन कम लचीला।
\n

चुनाव कार्य पर निर्भर करता है। CLI उपयोगिताओं के लिए rust-i18n पर्याप्त है। वेब अनुप्रयोगों या जटिल GUI (जैसे Tauri पर) के लिए Fluent लेना बेहतर है।

विधि संख्या 1: Fluent के साथ Rust का अंतर्राष्ट्रीयकरण (पेशेवर दृष्टिकोण)

Fluent की स्थापना और कॉन्फ़िगरेशन

एक नया प्रोजेक्ट बनाएं और निर्भरताएँ जोड़ें:

cargo new i18n_demo\ncd i18n_demo\ncargo add fluent fluent-bundle fluent-langtag unic-langid\n

फ़ाइल संरचना इस प्रकार होगी:

प्रोजेक्ट/\n├── Cargo.toml\n├── locales/\n│   ├── ru/\n│   │   └── main.ftl\n│   └── en/\n│       └── main.ftl\n└── src/\n    └── main.rs\n

स्थानीयकरण फ़ाइलें (FTL) बनाएँ

Fluent FTL (Fluent Translation List) प्रारूप का उपयोग करता है। यह सफाई और शक्ति है:

locales/en/main.ftl:

greeting = Hello, { $name }!\ngoodbye = Goodbye\napples = { $count ->\n    [one] { $count } apple\n    [few] { $count } apples\n    *[other] { $count } apples\n}\n

locales/ru/main.ftl:

greeting = Привет, { $name }!\ngoodbye = До свидания\napples = { $count ->\n    [one] { $count } яблоко\n    [few] { $count } яблока\n    [many] { $count } яблок\n    *[other] { $count } яблок\n}\n

बहुवचन पर ध्यान दें। रूसी भाषा में चार रूप हैं (एक, दो-चार, पाँच-बीस, शेष), और अंग्रेजी में दो (एक, शेष)। Fluent स्वचालित रूप से इससे निपटता है।

लोकेल लोड करने के लिए Rust कोड लिखें

अब सबसे दिलचस्प हिस्सा — कोड जो उपयोगकर्ता के सिस्टम के आधार पर आवश्यक भाषा का चयन करेगा:

use fluent_bundle::{FluentBundle, FluentResource};\nuse unic_langid::LanguageIdentifier;\nuse std::fs;\nuse std::path::Path;\n\nfn load_locale(locale: &str) -> FluentBundle<FluentResource> {\n    let langid: LanguageIdentifier = locale.parse().expect("Неверная локаль");\n    let mut bundle = FluentBundle::new(vec![langid]);\n\n    let file_path = format!("locales/{}/main.ftl", locale);\n    let source = fs::read_to_string(&file_path)\n        .expect(&format!("Не удалось прочитать файл {}", file_path));\n\n    let resource = FluentResource::try_new(source)\n        .expect("Не удалось разобрать FTL файл");\n\n    bundle.add_resource(resource)\n        .expect("Не удалось добавить ресурс");\n\n    bundle\n}\n\nfn main() {\n    let locale = \"ru\"; // В реальной жизни — определяем из системы\n    let bundle = load_locale(locale);\n\n    let mut errors = vec![];\n    let greeting = bundle.format_pattern(\n        &bundle.get_message(\"greeting\").unwrap().value().unwrap(),\n        Some(&[(\"name\", \"Мир\").into()]),\n        &mut errors\n    );\n\n    println!(\"{}\", greeting);\n}\n

यह कोड सिस्टम लोकेल पढ़ता है, आवश्यक FTL फ़ाइल लोड करता है और आवश्यक मैसेज को चर के साथ प्रदर्शित करता है। परिणाम:

Привет, Мир!

यदि आप locale को 'en' में बदलते हैं, तो आउटपुट बदल जाएगा:

Hello, World!

विधि संख्या 2: rust-i18n मैक्रोज़ (तेज़ शुरुआत)

स्थापना और कॉन्फ़िगरेशन

उन लोगों के लिए जो सादगी पसंद करते हैं:

cargo add rust-i18n\n

YAML प्रारूप में locales/ru.yml फ़ाइल बनाएँ:

greeting: "Привет, {{ name }}!"\ngoodbye: "До свидания"\napples:\n  one: "{{ count }} яблоко"\n  few: "{{ count }} яблока"\n  many: "{{ count }} яблок"\n  other: "{{ count }} яблок"\n

और locales/en.yml:

greeting: "Hello, {{ name }}!"\ngoodbye: "Goodbye"\napples:\n  one: "{{ count }} apple"\n  other: "{{ count }} apples"\n

Rust कोड में उपयोग

use rust_i18n::t;\n\nrust_i18n::i18n!(\"locales\");\n\nfn main() {\n    let greeting = t!(\"greeting\", name = \"Мир\");\n    println!(\"{}\", greeting); // Привет, Мир!\n\n    // बहुवचन का परीक्षण\n    for count in &[1, 2, 5, 10] {\n        let apples = t!(\"apples\", count = count);\n        println!(\"{}\", apples);\n    }\n}\n

स्वचालित बहुवचन काम करता है। t! मैक्रो स्वयं आवश्यक रूप चुनता है।

उपयोगी युक्तियाँ और अच्छी प्रथाएँ

\n
1. हार्डकोडिंग से बचें। "यहाँ एक अस्थायी स्ट्रिंग है" का कोई भी उपयोग भविष्य में अनुवाद को जटिल बनाता है।
\n
2. लोकेल पहचान को अलग करें। सिस्टम लोकेल प्राप्त करने और इसे अपने प्रारूप में परिवर्तित करने के लिए sys-locale क्रेट का उपयोग करें।
\n
3. संदर्भ जोड़ें। अनुवादकों के लिए FTL में टिप्पणियाँ लिखें (## से शुरू करें)।
\n
4. स्वचालित परीक्षण। सुनिश्चित करें कि अनुवाद फ़ाइलों में सभी कुंजियाँ मौजूद हैं। CI में cargo i18n_check जोड़ें।
\n
5. फ़ॉलबैक भाषा। हमेशा एक डिफ़ॉल्ट लोकेल (सामान्यतः en) रखें, यदि आवश्यक फ़ाइल न मिले तो उसका उपयोग करें।
\n

निष्कर्ष

हमने देखा कि Rust प्रोजेक्ट को i18n के दो तरीकों से कैसे अनुकूलित किया जाए: Fluent — जटिल अनुप्रयोगों के लिए लचीलापन और rust-i18n — छोटी परियोजनाओं के लिए सादगी। दोनों दृष्टिकोण सही ढंग से उपयोग किए जाने पर बहुवचन और चर प्रतिस्थापन प्रदान करते हैं।

अब आपके पास अपने Rust एप्लिकेशन को वास्तव में अंतर्राष्ट्रीय बनाने के लिए सभी उपकरण हैं। मुख्य बात यह है कि अंतिम क्षण तक स्थानीयकरण को स्थगित न करें। शुरू से ही i18n पर विचार करें, और आपका कोड दुनिया भर के डेवलपर्स के प्रति आभारी होगा।

याद रखें: अच्छा i18n वह है जिस पर आप ध्यान नहीं देते। उपयोगकर्ता बस अपनी मूल भाषा में एप्लिकेशन का उपयोग करते हैं और आनंद लेते हैं। यही वास्तविक जादू है।