Ruby on Rails 5.2 - ActionView::Helpers::NumberHelper

मॉड्यूल एक्शन व्यू :: हेल्पर्स :: नंबर हेल्पर




ruby

मॉड्यूल एक्शन व्यू :: हेल्पर्स :: नंबर हेल्पर

स्वरूपित तारों में संख्याओं को परिवर्तित करने के लिए तरीके प्रदान करता है। फोन नंबर, मुद्रा, प्रतिशत, सटीक, स्थिति संकेतन, फ़ाइल आकार और सुंदर मुद्रण के लिए तरीके प्रदान किए जाते हैं।

अधिकांश विधियाँ एक number तर्क की अपेक्षा करती हैं, और यदि यह मान्य संख्या में परिवर्तित नहीं की जा सकती हैं, तो इसे अपरिवर्तित कर देगी।

सार्वजनिक प्रवृत्ति के तरीके

number_to_currency (संख्या, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/number_helper.rb, line 120
def number_to_currency(number, options = {})
  delegate_number_helper_method(:number_to_currency, number, options)
end

एक मुद्रा स्ट्रिंग (उदाहरण, $ 13.65) में एक number को प्रारूपित करता है। आप options हैश में प्रारूप को अनुकूलित कर सकते हैं।

वर्तमान स्थान में मुद्रा इकाई और संख्या स्वरूपण का उपयोग तब तक किया जाएगा जब तक कि उपलब्ध विकल्पों में निर्दिष्ट नहीं किया जाता है। कोई मुद्रा रूपांतरण नहीं किया जाता है। यदि उपयोगकर्ता को अपने स्थान को बदलने का एक तरीका दिया जाता है, तो वे इस सहायक के साथ प्रदर्शित मुद्रा के सापेक्ष मूल्य को भी बदल सकेंगे। यदि आपका आवेदन कभी-कभी कई स्थानों का समर्थन करेगा, तो आप एक स्थिर निर्दिष्ट करना चाह सकते हैं :locale विकल्प या मुद्रा रूपांतरण में सक्षम पुस्तकालय का उपयोग करने पर विचार करें।

विकल्प

  • :locale - लोकेल को फॉर्मेटिंग (वर्तमान लोकेल में डिफॉल्ट) के लिए इस्तेमाल करने के लिए सेट करता है।

  • :precision - :precision का स्तर निर्धारित करता है (चूक 2)।

  • :unit - मुद्रा का मूल्यवर्ग निर्धारित करता है ("$" में चूक)।

  • :separator - इकाई के बीच विभाजक को सेट करता है (डिफ़ॉल्ट "")।

  • :delimiter - हजारों सीमांकक ("," के लिए चूक) सेट करता है।

  • :format - गैर-ऋणात्मक संख्याओं के लिए प्रारूप निर्धारित करता है ("% u% n" के लिए डिफ़ॉल्ट)। मुद्रा के लिए फ़ील्ड्स %u हैं, और संख्या के लिए %n

  • :negative_format - ऋणात्मक संख्याओं के लिए प्रारूप सेट करता है (एक :format दिए गए स्वरूपित संख्या के लिए एक हाइफ़न को प्रवृत्त करने के लिए चूक)। %n को छोड़कर, :format की संख्या का निरपेक्ष मान यहां है:

  • :raise InvalidNumberError - यदि सत्य है, तो तर्क अमान्य होने पर InvalidNumberError उठाता है।

उदाहरण

number_to_currency(1234567890.50)                    # => $1,234,567,890.50
number_to_currency(1234567890.506)                   # => $1,234,567,890.51
number_to_currency(1234567890.506, precision: 3)     # => $1,234,567,890.506
number_to_currency(1234567890.506, locale: :fr)      # => 1 234 567 890,51 €
number_to_currency("123a456")                        # => $123a456

number_to_currency("123a456", raise: true)           # => InvalidNumberError

number_to_currency(-1234567890.50, negative_format: "(%u%n)")
# => ($1,234,567,890.50)
number_to_currency(1234567890.50, unit: "R$", separator: ",", delimiter: "")
# => R$1234567890,50
number_to_currency(1234567890.50, unit: "R$", separator: ",", delimiter: "", format: "%n %u")
# => 1234567890,50 R$
number_to_human (संख्या, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/number_helper.rb, line 396
def number_to_human(number, options = {})
  delegate_number_helper_method(:number_to_human, number, options)
end

सुंदर प्रिंट (प्रारूप और सन्निकट) एक संख्या एक तरह से यह मनुष्यों द्वारा अधिक पठनीय है (उदाहरण के लिए: 1200000000 "1.2 बिलियन")। यह उन संख्याओं के लिए उपयोगी है जो बहुत बड़ी हो सकती हैं (और पढ़ने में बहुत कठिन)।

यदि आप एक फ़ाइल का आकार प्रिंट करना चाहते हैं तो number_to_human_size देखें।

यदि आप अन्य दशमलव इकाइयों का उपयोग करना चाहते हैं, तो आप अपनी खुद की इकाई-मात्रात्मक नामों को भी परिभाषित कर सकते हैं (उदाहरण के लिए: 1500 "1.5 किलोमीटर", 0.150 "150 मिलीलीटर", आदि) हो जाता है। आप यूनिट क्वांटिफायर की एक विस्तृत श्रृंखला को परिभाषित कर सकते हैं, यहां तक ​​कि आंशिक (सेंटी, डेसी, मिलि, आदि)।

विकल्प

  • :locale - लोकेल को फॉर्मेटिंग (वर्तमान लोकेल में डिफॉल्ट) के लिए इस्तेमाल करने के लिए सेट करता है।

  • :precision - संख्या की शुद्धता (3 से चूक) निर्धारित करता है।

  • :significant - यदि true , तो prote_digits की संख्या सटीक होगी। यदि false , तो भिन्नात्मक अंकों की संख्या ( true चूक)

  • :separator - विभाजक को अंश और पूर्णांक अंकों के बीच सेट करता है (डिफ़ॉल्ट "")।

  • :delimiter - हजारों सीमांकक ("करने के लिए चूक") सेट करता है।

  • :strip_insignificant_zeros - यदि दशमलव विभाजक के बाद महत्वहीन शून्य हटाता है ( true लिए चूक)

  • :units - इकाई परिमाणक नामों का एक Hash । या एक स्ट्रिंग जिसमें i18n स्कोप है, जहां इस हैश को ढूंढना है। इसमें निम्नलिखित कुंजी हो सकती हैं:

    • पूर्णांक :: :unit :ten :hundred :thousand :million :billion :trillion , :quadrillion

    • भिन्न :: :deci , :centi :mili :micro :nano :pico , :femto

  • :format - आउटपुट स्ट्रिंग का प्रारूप सेट करता है (डिफ़ॉल्ट रूप से "% n% u")। क्षेत्र प्रकार हैं:

    • % u - परिमाणक (उदा .: 'हज़ार')

    • % n - संख्या

  • :raise InvalidNumberError - यदि सत्य है, तो तर्क अमान्य होने पर InvalidNumberError उठाता है।

उदाहरण

number_to_human(123)                                          # => "123"
number_to_human(1234)                                         # => "1.23 Thousand"
number_to_human(12345)                                        # => "12.3 Thousand"
number_to_human(1234567)                                      # => "1.23 Million"
number_to_human(1234567890)                                   # => "1.23 Billion"
number_to_human(1234567890123)                                # => "1.23 Trillion"
number_to_human(1234567890123456)                             # => "1.23 Quadrillion"
number_to_human(1234567890123456789)                          # => "1230 Quadrillion"
number_to_human(489939, precision: 2)                         # => "490 Thousand"
number_to_human(489939, precision: 4)                         # => "489.9 Thousand"
number_to_human(1234567, precision: 4,
                        significant: false)                   # => "1.2346 Million"
number_to_human(1234567, precision: 1,
                        separator: ',',
                        significant: false)                   # => "1,2 Million"

number_to_human(500000000, precision: 5)                      # => "500 Million"
number_to_human(12345012345, significant: false)              # => "12.345 Billion"

दशमलव विभाजक द्वारा डिफ़ॉल्ट रूप से छीन लिए जाने के बाद गैर-महत्वपूर्ण शून्य (सेट :strip_insignificant_zeros को बदलने के लिए false ):

#number_to_human (12.00001) # => "12" #number_to_human (12.00001, strip_insignificant_zeros: false) # => "12.0"

कस्टम यूनिट क्वांटिफ़ायर

आप अपनी खुद की कस्टम यूनिट क्वांटिफायर का भी उपयोग कर सकते हैं:

number_to_human(500000, units: {unit: "ml", thousand: "lt"})  # => "500 lt"

यदि आपके I18n लोकेल में आपके पास:

distance:
  centi:
    one: "centimeter"
    other: "centimeters"
  unit:
    one: "meter"
    other: "meters"
  thousand:
    one: "kilometer"
    other: "kilometers"
  billion: "gazillion-distance"

तो आप कर सकते हैं:

number_to_human(543934, units: :distance)              # => "544 kilometers"
number_to_human(54393498, units: :distance)            # => "54400 kilometers"
number_to_human(54393498000, units: :distance)         # => "54.4 gazillion-distance"
number_to_human(343, units: :distance, precision: 1)   # => "300 meters"
number_to_human(1, units: :distance)                   # => "1 meter"
number_to_human(0.34, units: :distance)                # => "34 centimeters"
number_to_human_size (संख्या, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/number_helper.rb, line 290
def number_to_human_size(number, options = {})
  delegate_number_helper_method(:number_to_human_size, number, options)
end

एक अधिक समझने योग्य प्रतिनिधित्व में number को बाइट्स बनाता है (जैसे, यह 1500 केबी 1.5 केबी दे)। यह विधि उपयोगकर्ताओं के लिए फ़ाइल आकार की रिपोर्ट करने के लिए उपयोगी है। आप options हैश में प्रारूप को अनुकूलित कर सकते हैं।

यदि आप एक जेनेरिक नंबर को सुंदर प्रिंट करना चाहते हैं तो number_to_human देखें।

विकल्प

  • :locale - लोकेल को फॉर्मेटिंग (वर्तमान लोकेल में डिफॉल्ट) के लिए इस्तेमाल करने के लिए सेट करता है।

  • :precision - संख्या की शुद्धता (3 से चूक) निर्धारित करता है।

  • :significant - यदि true , तो prote_digits की संख्या सटीक होगी। यदि false , तो भिन्नात्मक अंकों की संख्या ( true चूक)

  • :separator - विभाजक को अंश और पूर्णांक अंकों के बीच सेट करता है (डिफ़ॉल्ट "")।

  • :delimiter - हजारों सीमांकक ("करने के लिए चूक") सेट करता है।

  • :strip_insignificant_zeros - यदि दशमलव विभाजक के बाद महत्वहीन शून्य हटाता है ( true लिए चूक)

  • :raise InvalidNumberError - यदि सत्य है, तो तर्क अमान्य होने पर InvalidNumberError उठाता है।

उदाहरण

number_to_human_size(123)                                          # => 123 Bytes
number_to_human_size(1234)                                         # => 1.21 KB
number_to_human_size(12345)                                        # => 12.1 KB
number_to_human_size(1234567)                                      # => 1.18 MB
number_to_human_size(1234567890)                                   # => 1.15 GB
number_to_human_size(1234567890123)                                # => 1.12 TB
number_to_human_size(1234567890123456)                             # => 1.1 PB
number_to_human_size(1234567890123456789)                          # => 1.07 EB
number_to_human_size(1234567, precision: 2)                        # => 1.2 MB
number_to_human_size(483989, precision: 2)                         # => 470 KB
number_to_human_size(1234567, precision: 2, separator: ',')        # => 1,2 MB
number_to_human_size(1234567890123, precision: 5)                  # => "1.1228 TB"
number_to_human_size(524288000, precision: 5)                      # => "500 MB"
number_to_percentage (संख्या, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/number_helper.rb, line 160
def number_to_percentage(number, options = {})
  delegate_number_helper_method(:number_to_percentage, number, options)
end

एक प्रतिशत स्ट्रिंग (जैसे, 65%) के रूप में एक number को प्रारूपित करता है। आप options हैश में प्रारूप को अनुकूलित कर सकते हैं।

विकल्प

  • :locale - लोकेल को फॉर्मेटिंग (वर्तमान लोकेल में डिफॉल्ट) के लिए इस्तेमाल करने के लिए सेट करता है।

  • :precision - संख्या की शुद्धता (3 से चूक) निर्धारित करता है।

  • :significant - यदि true , तो prote_digits की संख्या सटीक होगी। यदि false , तो भिन्नात्मक अंकों की संख्या ( false लिए चूक)।

  • :separator - विभाजक को अंश और पूर्णांक अंकों के बीच सेट करता है (डिफ़ॉल्ट "")।

  • :delimiter - हजारों सीमांकक ("करने के लिए चूक") सेट करता है।

  • :strip_insignificant_zeros - यदि दशमलव विभाजक ( false करने के लिए चूक) के बाद true महत्वहीन शून्य हटाता है।

  • :format - प्रतिशत स्ट्रिंग के प्रारूप को निर्दिष्ट करता है संख्या क्षेत्र %n ("% n%" के लिए चूक)।

  • :raise InvalidNumberError - यदि सत्य है, तो तर्क अमान्य होने पर InvalidNumberError उठाता है।

उदाहरण

number_to_percentage(100)                                        # => 100.000%
number_to_percentage("98")                                       # => 98.000%
number_to_percentage(100, precision: 0)                          # => 100%
number_to_percentage(1000, delimiter: '.', separator: ',')       # => 1.000,000%
number_to_percentage(302.24398923423, precision: 5)              # => 302.24399%
number_to_percentage(1000, locale: :fr)                          # => 1 000,000%
number_to_percentage("98a")                                      # => 98a%
number_to_percentage(100, format: "%n  %")                       # => 100.000  %

number_to_percentage("98a", raise: true)                         # => InvalidNumberError
number_to_phone (संख्या, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/number_helper.rb, line 62
def number_to_phone(number, options = {})
  return unless number
  options = options.symbolize_keys

  parse_float(number, true) if options.delete(:raise)
  ERB::Util.html_escape(ActiveSupport::NumberHelper.number_to_phone(number, options))
end

फ़ोन number में एक number को प्रारूपित करता है (डिफ़ॉल्ट रूप से US जैसे, (555) 123-9876)। आप options हैश में प्रारूप को अनुकूलित कर सकते हैं।

विकल्प

  • :area_code - क्षेत्र कोड के आसपास कोष्ठक जोड़ता है।

  • :delimiter - परिसीमन का उपयोग करने के लिए निर्दिष्ट करता है ("-" के लिए चूक)।

  • :extension - उत्पन्न संख्या के अंत में जोड़ने के लिए एक एक्सटेंशन निर्दिष्ट करता है।

  • :country_code - फोन नंबर के लिए देश कोड सेट करता है।

  • :pattern - निर्दिष्ट करता है कि डिफ़ॉल्ट प्रारूप को ओवरराइड करने के लिए कस्टम रीगेक्सपी के साथ संख्या को तीन समूहों में कैसे विभाजित किया गया है।

  • :raise InvalidNumberError - यदि सत्य है, तो तर्क अमान्य होने पर InvalidNumberError उठाता है।

उदाहरण

number_to_phone(5551234)                                           # => 555-1234
number_to_phone("5551234")                                         # => 555-1234
number_to_phone(1235551234)                                        # => 123-555-1234
number_to_phone(1235551234, area_code: true)                       # => (123) 555-1234
number_to_phone(1235551234, delimiter: " ")                        # => 123 555 1234
number_to_phone(1235551234, area_code: true, extension: 555)       # => (123) 555-1234 x 555
number_to_phone(1235551234, country_code: 1)                       # => +1-123-555-1234
number_to_phone("123a456")                                         # => 123a456
number_to_phone("1234a567", raise: true)                           # => InvalidNumberError

number_to_phone(1235551234, country_code: 1, extension: 1343, delimiter: ".")
# => +1.123.555.1234 x 1343

number_to_phone(75561234567, pattern: /(\d{1,4})(\d{4})(\d{4})$/, area_code: true)
# => "(755) 6123-4567"
number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/))
# => "133-1234-5678"
number_with_delimiter (संख्या, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/number_helper.rb, line 199
def number_with_delimiter(number, options = {})
  delegate_number_helper_method(:number_to_delimited, number, options)
end

delimiter (उदाहरण, 12,324) का उपयोग करके हजारों की number में समूह बनाए गए हैं। आप options हैश में प्रारूप को अनुकूलित कर सकते हैं।

विकल्प

  • :locale - लोकेल को फॉर्मेटिंग (वर्तमान लोकेल में डिफॉल्ट) के लिए इस्तेमाल करने के लिए सेट करता है।

  • :delimiter - हजारों सीमांकक ("," के लिए चूक) सेट करता है।

  • :separator - विभाजक को अंश और पूर्णांक अंकों के बीच सेट करता है (डिफ़ॉल्ट "")।

  • :delimiter_pattern - :delimiter_pattern के स्थान को प्राप्त करने के लिए प्रयुक्त एक नियमित नियमित अभिव्यक्ति सेट करता है। INR जैसे मुद्रा प्रारूपों का उपयोग करते समय सहायक।

  • :raise InvalidNumberError - यदि सत्य है, तो तर्क अमान्य होने पर InvalidNumberError उठाता है।

उदाहरण

 number_with_delimiter(12345678)                        # => 12,345,678
 number_with_delimiter("123456")                        # => 123,456
 number_with_delimiter(12345678.05)                     # => 12,345,678.05
 number_with_delimiter(12345678, delimiter: ".")        # => 12.345.678
 number_with_delimiter(12345678, delimiter: ",")        # => 12,345,678
 number_with_delimiter(12345678.05, separator: " ")     # => 12,345,678 05
 number_with_delimiter(12345678.05, locale: :fr)        # => 12 345 678,05
 number_with_delimiter("112a")                          # => 112a
 number_with_delimiter(98765432.98, delimiter: " ", separator: ",")
 # => 98 765 432,98

 number_with_delimiter("123456.78",
   delimiter_pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/)    # => "1,23,456.78"

number_with_delimiter("112a", raise: true)              # => raise InvalidNumberError
number_with_preaches (संख्या, विकल्प = {}) स्रोत दिखाएं
# File actionview/lib/action_view/helpers/number_helper.rb, line 244
def number_with_precision(number, options = {})
  delegate_number_helper_method(:number_to_rounded, number, options)
end

निर्दिष्ट स्तर के साथ एक number को प्रारूपित करता है :precision (जैसे, 112.32 में 2 की सटीकता है यदि :significant false , और 5 यदि :significant true )। आप options हैश में प्रारूप को अनुकूलित कर सकते हैं।

विकल्प

  • :locale - लोकेल को फॉर्मेटिंग (वर्तमान लोकेल में डिफॉल्ट) के लिए इस्तेमाल करने के लिए सेट करता है।

  • :precision - संख्या की शुद्धता (3 से चूक) निर्धारित करता है।

  • :significant - यदि true , तो prote_digits की संख्या सटीक होगी। यदि false , तो भिन्नात्मक अंकों की संख्या ( false लिए चूक)।

  • :separator - विभाजक को अंश और पूर्णांक अंकों के बीच सेट करता है (डिफ़ॉल्ट "")।

  • :delimiter - हजारों सीमांकक ("करने के लिए चूक") सेट करता है।

  • :strip_insignificant_zeros - यदि दशमलव विभाजक ( false करने के लिए चूक) के बाद true :strip_insignificant_zeros शून्य हटाता है।

  • :raise InvalidNumberError - यदि सत्य है, तो तर्क अमान्य होने पर InvalidNumberError उठाता है।

उदाहरण

number_with_precision(111.2345)                                         # => 111.235
number_with_precision(111.2345, precision: 2)                           # => 111.23
number_with_precision(13, precision: 5)                                 # => 13.00000
number_with_precision(389.32314, precision: 0)                          # => 389
number_with_precision(111.2345, significant: true)                      # => 111
number_with_precision(111.2345, precision: 1, significant: true)        # => 100
number_with_precision(13, precision: 5, significant: true)              # => 13.000
number_with_precision(111.234, locale: :fr)                             # => 111,234

number_with_precision(13, precision: 5, significant: true, strip_insignificant_zeros: true)
# => 13

number_with_precision(389.32314, precision: 4, significant: true)       # => 389.3
number_with_precision(1111.2345, precision: 2, separator: ',', delimiter: '.')
# => 1.111,23