i18n बहुवचन

Question 1

मैं रेल में i18n में बहुवचन तार का अनुवाद करने में सक्षम होना चाहता हूं। एक स्ट्रिंग हो सकती है:

You have 2 kids

या

You have 1 kid

मुझे पता है कि मैं बहुवचन सहायक विधि का उपयोग कर सकता हूं, लेकिन मैं इसे i18n अनुवादों में एम्बेड करना चाहता हूं ताकि मुझे भविष्य में किसी भी बिंदु पर अपने विचारों के साथ गड़बड़ न करना पड़े। मैंने पढ़ा कि :countकिसी तरह बहुवचन के लिए अनुवाद में उपयोग किया जाता है, लेकिन मैं इसे लागू करने के तरीके पर कोई वास्तविक संसाधन नहीं पा सकता हूं।

ध्यान दें कि मुझे पता है कि मैं अनुवाद स्ट्रिंग में एक चर पारित कर सकता हूं। मैंने भी कुछ इस तरह की कोशिश की:

<%= t 'misc.kids', :kids_num => pluralize(1, 'kid') %>

जो ठीक काम करता है, लेकिन एक ही विचार की एक मौलिक समस्या है। मुझे 'kid'बहुवचन सहायक में स्ट्रिंग निर्दिष्ट करने की आवश्यकता है । मैं ऐसा नहीं करना चाहता क्योंकि इससे भविष्य में समस्याएं देखने को मिलेंगी। इसके बजाय मैं अनुवाद में सब कुछ और दृश्य में कुछ भी नहीं रखना चाहता हूं।

मैं उसे कैसे कर सकता हूँ ?

Question 2

इसे इस्तेमाल करे:

en.yml :

en:
  misc:
    kids:
      zero: no kids
      one: 1 kid
      other: %{count} kids

एक दृश्य में:

You have <%= t('misc.kids', :count => 4) %>

कई बहुवचन के साथ भाषाओं के लिए अद्यतित उत्तर (रेल 3.0.7 के साथ परीक्षण):

फ़ाइल config/initializers/pluralization.rb :

require "i18n/backend/pluralization" 
I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)

फ़ाइल config/locales/plurals.rb :

{:ru => 
  { :i18n => 
    { :plural => 
      { :keys => [:one, :few, :other],
        :rule => lambda { |n| 
          if n == 1
            :one
          else
            if [2, 3, 4].include?(n % 10) && 
               ![12, 13, 14].include?(n % 100) && 
               ![22, 23, 24].include?(n % 100)

              :few 
            else
              :other 
            end
          end
        } 
      } 
    } 
  } 
}

#More rules in this file: https://github.com/svenfuchs/i18n/blob/master/test/test_data/locales/plurals.rb
#(copy the file into `config/locales`)

फ़ाइल config/locales/en.yml :

en:
  kids:
    zero: en_zero
    one: en_one
    other: en_other

फ़ाइल config/locales/ru.yml :

ru:
  kids:
    zero: ru_zero
    one: ru_one
    few: ru_few
    other: ru_other

परीक्षण :

$ rails c
>> I18n.translate :kids, :count => 1
=> "en_one"
>> I18n.translate :kids, :count => 3
=> "en_other"
>> I18n.locale = :ru
=> :ru
>> I18n.translate :kids, :count => 1
=> "ru_one"
>> I18n.translate :kids, :count => 3
=> "ru_few"  #works! yay! 
>> I18n.translate :kids, :count => 5
=> "ru_other"  #works! yay!

Question 3

मुझे उम्मीद है कि रल्स प्रोग्रामर्स पर रूसी बोलने वाली रूबी को यह मिल सकता है। बस अपने बहुत सटीक रूसी बहुवचन सूत्र को साझा करना चाहता हूं। यह यूनिकोड स्पेक्स पर आधारित है । यहां config/locales/plurals.rbकेवल फ़ाइल की सामग्री है , बाकी सब कुछ उसी तरह किया जाना चाहिए जैसा कि ऊपर दिए गए उत्तर में है।

{:ru => 
  { :i18n => 
    { :plural => 
      { :keys => [:zero, :one, :few, :many],
        :rule => lambda { |n| 
          if n == 0
            :zero
          elsif
            ( ( n % 10 ) == 1 ) && ( ( n % 100 != 11 ) )
            # 1, 21, 31, 41, 51, 61...
            :one
          elsif
            ( [2, 3, 4].include?(n % 10) \
            && ![12, 13, 14].include?(n % 100) )
            # 2-4, 22-24, 32-34...
            :few
          elsif ( (n % 10) == 0 || \
            ![5, 6, 7, 8, 9].include?(n % 10) || \
            ![11, 12, 13, 14].include?(n % 100) )
            # 0, 5-20, 25-30, 35-40...
            :many
          end
        } 
      } 
    } 
  } 
}

देशी वक्ताओं जैसे 111और मामलों का आनंद सकता है 121। और यहाँ परीक्षण के परिणाम:

शून्य: 0 запросов / куриц / яблок
एक: 1 запрос / курица / яблоко
कुछ: 3 запроса / курицы / яблока
कई: 5 запросов / куриц / яблок
एक: 101 запрос / курица / яблоко
कुछ: 102 запроса / курицы / яблока
कई: 105 запросов / куриц / яблок
कई: 111 запросов / куриц / яблок
कई: 119 запросов / куриц / яблок
एक: 121 запрос / курица / яблоко
कुछ: 122 запроса / курицы / яблока
कई: 125 запросов / куриц / яблок

प्रारंभिक उत्तर के लिए धन्यवाद!

Question 4

सबसे पहले, याद रखें कि बहुवचन रूपों की संख्या भाषा पर निर्भर करती है , अंग्रेजी के लिए दो हैं, रोमानियाई के लिए 3 हैं और अरबी के लिए 6 हैं! 6!

यदि आप बहुवचन रूप में उपयोग करने में सक्षम होना चाहते हैं तो आपको उपयोग करना होगा gettext।

रूबी और रेल के लिए आप इस जाँच करनी चाहिए http://www.yotabanana.com/hiki/ruby-gettext-howto-rails.html

Question 5

रेल 3 इसे सीएलडीआर विचार के साथ मजबूती से संभालती है और प्रक्षेप चर की गणना करती है। Http://guides.rubyonrails.org/i18n.html#pluralization देखें

# in view
t('actors', :count => @movie.actors.size)

# locales file, i.e. config/locales/en.yml
en:
  actors:
    one: Actor
    other: Actors

Question 6

अंग्रेज़ी

यह सिर्फ बॉक्स से बाहर काम करता है

en.yml :

en:
  kid:
    one: '1 kid'
    other: '%{count} kids'

उपयोग (आप एक दृश्य फ़ाइल में I18n को छोड़ सकते हैं, निश्चित रूप से):

> I18n.t :kid, count: 1
 => "1 kid"

> I18n.t :kid, count: 3
 => "3 kids"

रूसी (और बहुवचन रूपों के साथ अन्य भाषाएं)

रेल -18 एन मणि स्थापित करें और उदाहरण के.yml रूप में अपनी फ़ाइलों में अनुवाद जोड़ें :

ru.yml :

ru:
  kid:
    zero: 'нет детей'
    one: '%{count} ребенок'
    few: '%{count} ребенка'
    many: '%{count} детей'
    other: 'дети'

उपयोग:

> I18n.t :kid, count: 0
 => "нет детей"

> I18n.t :kid, count: 1
 => "1 ребенок"

> I18n.t :kid, count: 3
 => "3 ребенка"

> I18n.t :kid, count: 5
 => "5 детей"

> I18n.t :kid, count: 21
 => "21 ребенок"

> I18n.t :kid, count: 114
 => "114 детей"

> I18n.t :kid, count: ''
 => "дети"

Question 7

वास्तव में बोझिल i18n दृष्टिकोण का एक विकल्प है। समाधान को Tr8n कहा जाता है।

आपका उपरोक्त कोड बस होगा:

 <%= tr("You have {num || kid}", num: 1) %>

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

उपरोक्त अनुवाद कुंजी की पूरी परिभाषा वास्तव में इस तरह दिखाई देगी:

 <%= tr("You have {num:number || one: kid, other: kids}", num: 1) %>

लेकिन चूँकि हम स्थान और समय को बचाना चाहते हैं, इसलिए अंक स्वचालित रूप से संख्यात्मक नियमों के लिए मैप हो जाता है और नियम मूल्यों के लिए सभी विकल्प प्रदान करने की आवश्यकता नहीं होती है। Tr8n बहुवचन और inflectors के साथ आता है जो मक्खी पर आपके लिए काम करेंगे।

रूसी में आपकी कुंजी के लिए अनुवाद, बस होगा:

 "У вас есть {num || ребенок, ребенка, детей}"

वैसे, आपका अनुवाद उन भाषाओं में गलत होगा जिनके लिंग विशिष्ट नियम हैं। उदाहरण के लिए, हिब्रू में, आपको वास्तव में अपने उदाहरण के लिए कम से कम 2 अनुवाद निर्दिष्ट करने होंगे, क्योंकि "आप" देखने वाले उपयोगकर्ता के लिंग के आधार पर भिन्न होंगे। Tr8n इसे बहुत अच्छी तरह से संभालता है। यहाँ हिब्रू अनुवाद का लिप्यंतरण है:

 "Yesh leha yeled ahad" with {context: {viewing_user: male, num: one}}
 "Yesh leha {num} yeladim" with {context: {viewing_user: male, num: other}}
 "Yesh lah yeled ahad" with {context: {viewing_user: female, num: one}}
 "Yesh lah {num} yeladim" with {context: {viewing_user: female, num: other}}

तो आपकी एकल अंग्रेजी कुंजी, इस मामले में, 4 अनुवादों की आवश्यकता है। सभी अनुवाद संदर्भ में किए गए हैं - आपको वाक्य को तोड़ने की आवश्यकता नहीं है। Tr8n में भाषा और संदर्भ के आधार पर कई अनुवादों के लिए एक कुंजी को मैप करने के लिए एक तंत्र है - यह सब मक्खी पर किया जाता है।

एक अंतिम बात। क्या होगा अगर आपको गिनती को बोल्ड करना था? यह बस होगा:

<%= tr("You have [bold: {num || kid}]", num: 1, bold: "<strong>{$0}</strong>") %>

बस अगर आप बाद में अपने "बोल्ड" को फिर से परिभाषित करना चाहते हैं - तो यह बहुत आसान होगा - आपको अपनी सभी YAML फाइलों से गुजरना और उन्हें बदलना नहीं होगा - आप बस इसे एक जगह पर करते हैं।

अधिक जानने के लिए, कृपया यहां देखें:

https://github.com/tr8n/tr8n_rails_clientsdk

प्रकटीकरण: मैं डेवलपर और Tr8n ढांचे और इसके सभी पुस्तकालयों का अनुरक्षक हूं।

Question 8

Redmine के बारे में। यदि आप कॉन्फ़िगरेशन / स्थानों / plurals.rb के रूप में बहुवचन फ़ाइल नियमों की प्रतिलिपि बनाते हैं और अन्य स्थानीय नाम (ru.rb, pl.rb .. आदि) के समान नहीं हैं, तो ये काम नहीं करते हैं। आपको फ़ाइल नियमों का नाम बदलकर 'locale.rb' करना चाहिए या फ़ाइल /lib/redmine/i182.bb में विधि बदलनी चाहिए।

def init_translations(locale)
  locale = locale.to_s
  paths = ::I18n.load_path.select {|path| File.basename(path, '.*') == locale}
  load_translations(paths)
  translations[locale] ||= {}
end

और यदि आपके पास पुराना रेडमीन है, तो जोड़ें

module Implementation
        include ::I18n::Backend::Base
        **include ::I18n::Backend::Pluralization**