Module | ActionView::Helpers::NumberHelper |
In: |
vendor/rails/actionpack/lib/action_view/helpers/number_helper.rb
|
Provides methods for converting numbers into formatted strings. Methods are provided for phone numbers, currency, percentage, precision, positional notation, and file size.
Formats a number into a currency string (e.g., $13.65). You can customize the format in the options hash.
%u The currency unit %n The number
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.50, :unit => "£", :separator => ",", :delimiter => "") # => £1234567890,50 number_to_currency(1234567890.50, :unit => "£", :separator => ",", :delimiter => "", :format => "%n %u") # => 1234567890,50 £
# File vendor/rails/actionpack/lib/action_view/helpers/number_helper.rb, line 71 71: def number_to_currency(number, options = {}) 72: options.symbolize_keys! 73: 74: defaults = I18n.translate('number.format''number.format', :locale => options[:locale], :raise => true) rescue {} 75: currency = I18n.translate('number.currency.format''number.currency.format', :locale => options[:locale], :raise => true) rescue {} 76: defaults = defaults.merge(currency) 77: 78: precision = options[:precision] || defaults[:precision] 79: unit = options[:unit] || defaults[:unit] 80: separator = options[:separator] || defaults[:separator] 81: delimiter = options[:delimiter] || defaults[:delimiter] 82: format = options[:format] || defaults[:format] 83: separator = '' if precision == 0 84: 85: begin 86: format.gsub(/%n/, number_with_precision(number, 87: :precision => precision, 88: :delimiter => delimiter, 89: :separator => separator) 90: ).gsub(/%u/, unit) 91: rescue 92: number 93: end 94: end
Formats the bytes in size into a more understandable representation (e.g., giving it 1500 yields 1.5 KB). This method is useful for reporting file sizes to users. This method returns nil if size cannot be converted into a number. You can customize the format in the options hash.
number_to_human_size(123) # => 123 Bytes number_to_human_size(1234) # => 1.2 KB number_to_human_size(12345) # => 12.1 KB number_to_human_size(1234567) # => 1.2 MB number_to_human_size(1234567890) # => 1.1 GB number_to_human_size(1234567890123) # => 1.1 TB number_to_human_size(1234567, :precision => 2) # => 1.18 MB number_to_human_size(483989, :precision => 0) # => 473 KB number_to_human_size(1234567, :precision => 2, :separator => ',') # => 1,18 MB
You can still use number_to_human_size with the old API that accepts the precision as its optional second parameter:
number_to_human_size(1234567, 2) # => 1.18 MB number_to_human_size(483989, 0) # => 473 KB
# File vendor/rails/actionpack/lib/action_view/helpers/number_helper.rb, line 249 249: def number_to_human_size(number, *args) 250: return number.nil? ? nil : pluralize(number.to_i, "Byte") if number.to_i < 1024 251: 252: options = args.extract_options! 253: options.symbolize_keys! 254: 255: defaults = I18n.translate('number.format''number.format', :locale => options[:locale], :raise => true) rescue {} 256: human = I18n.translate('number.human.format''number.human.format', :locale => options[:locale], :raise => true) rescue {} 257: defaults = defaults.merge(human) 258: storage_units = I18n.translate('number.human.storage_units''number.human.storage_units', :locale => options[:locale], :raise => true) 259: 260: unless args.empty? 261: ActiveSupport::Deprecation.warn('number_to_human_size takes an option hash ' + 262: 'instead of a separate precision argument.', caller) 263: precision = args[0] || defaults[:precision] 264: end 265: 266: precision ||= (options[:precision] || defaults[:precision]) 267: separator ||= (options[:separator] || defaults[:separator]) 268: delimiter ||= (options[:delimiter] || defaults[:delimiter]) 269: 270: max_exp = storage_units.size - 1 271: number = Float(number) 272: exponent = (Math.log(number) / Math.log(1024)).to_i # Convert to base 1024 273: exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit 274: number /= 1024 ** exponent 275: unit = storage_units[exponent] 276: 277: begin 278: escaped_separator = Regexp.escape(separator) 279: number_with_precision(number, 280: :precision => precision, 281: :separator => separator, 282: :delimiter => delimiter 283: ).sub(/(\d)(#{escaped_separator}[1-9]*)?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '') + " #{unit}" 284: rescue 285: number 286: end 287: end
Formats a number as a percentage string (e.g., 65%). You can customize the format in the options hash.
number_to_percentage(100) # => 100.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%
# File vendor/rails/actionpack/lib/action_view/helpers/number_helper.rb, line 109 109: def number_to_percentage(number, options = {}) 110: options.symbolize_keys! 111: 112: defaults = I18n.translate('number.format''number.format', :locale => options[:locale], :raise => true) rescue {} 113: percentage = I18n.translate('number.percentage.format''number.percentage.format', :locale => options[:locale], :raise => true) rescue {} 114: defaults = defaults.merge(percentage) 115: 116: precision = options[:precision] || defaults[:precision] 117: separator = options[:separator] || defaults[:separator] 118: delimiter = options[:delimiter] || defaults[:delimiter] 119: 120: begin 121: number_with_precision(number, 122: :precision => precision, 123: :separator => separator, 124: :delimiter => delimiter) + "%" 125: rescue 126: number 127: end 128: end
Formats a number into a US phone number (e.g., (555) 123-9876). You can customize the format in the options hash.
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(1235551234, :country_code => 1, :extension => 1343, :delimiter => ".") => +1.123.555.1234 x 1343
# File vendor/rails/actionpack/lib/action_view/helpers/number_helper.rb, line 26 26: def number_to_phone(number, options = {}) 27: number = number.to_s.strip unless number.nil? 28: options = options.symbolize_keys 29: area_code = options[:area_code] || nil 30: delimiter = options[:delimiter] || "-" 31: extension = options[:extension].to_s.strip || nil 32: country_code = options[:country_code] || nil 33: 34: begin 35: str = "" 36: str << "+#{country_code}#{delimiter}" unless country_code.blank? 37: str << if area_code 38: number.gsub!(/([0-9]{1,3})([0-9]{3})([0-9]{4}$)/,"(\\1) \\2#{delimiter}\\3") 39: else 40: number.gsub!(/([0-9]{1,3})([0-9]{3})([0-9]{4})$/,"\\1#{delimiter}\\2#{delimiter}\\3") 41: end 42: str << " x #{extension}" unless extension.blank? 43: str 44: rescue 45: number 46: end 47: end
Formats a number with grouped thousands using delimiter (e.g., 12,324). You can customize the format in the options hash.
number_with_delimiter(12345678) # => 12,345,678 number_with_delimiter(12345678.05) # => 12,345,678.05 number_with_delimiter(12345678, :delimiter => ".") # => 12.345.678 number_with_delimiter(12345678, :seperator => ",") # => 12,345,678 number_with_delimiter(98765432.98, :delimiter => " ", :separator => ",") # => 98 765 432,98
You can still use number_with_delimiter with the old API that accepts the delimiter as its optional second and the separator as its optional third parameter:
number_with_delimiter(12345678, " ") # => 12 345.678 number_with_delimiter(12345678.05, ".", ",") # => 12.345.678,05
# File vendor/rails/actionpack/lib/action_view/helpers/number_helper.rb, line 150 150: def number_with_delimiter(number, *args) 151: options = args.extract_options! 152: options.symbolize_keys! 153: 154: defaults = I18n.translate('number.format''number.format', :locale => options[:locale], :raise => true) rescue {} 155: 156: unless args.empty? 157: ActiveSupport::Deprecation.warn('number_with_delimiter takes an option hash ' + 158: 'instead of separate delimiter and precision arguments.', caller) 159: delimiter = args[0] || defaults[:delimiter] 160: separator = args[1] || defaults[:separator] 161: end 162: 163: delimiter ||= (options[:delimiter] || defaults[:delimiter]) 164: separator ||= (options[:separator] || defaults[:separator]) 165: 166: begin 167: parts = number.to_s.split('.') 168: parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}") 169: parts.join(separator) 170: rescue 171: number 172: end 173: end
Formats a number with the specified level of :precision (e.g., 112.32 has a precision of 2). You can customize the format in the options hash.
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(1111.2345, :precision => 2, :separator => ',', :delimiter => '.') # => 1.111,23
You can still use number_with_precision with the old API that accepts the precision as its optional second parameter:
number_with_precision(number_with_precision(111.2345, 2) # => 111.23
# File vendor/rails/actionpack/lib/action_view/helpers/number_helper.rb, line 194 194: def number_with_precision(number, *args) 195: options = args.extract_options! 196: options.symbolize_keys! 197: 198: defaults = I18n.translate('number.format''number.format', :locale => options[:locale], :raise => true) rescue {} 199: precision_defaults = I18n.translate('number.precision.format''number.precision.format', :locale => options[:locale], 200: :raise => true) rescue {} 201: defaults = defaults.merge(precision_defaults) 202: 203: unless args.empty? 204: ActiveSupport::Deprecation.warn('number_with_precision takes an option hash ' + 205: 'instead of a separate precision argument.', caller) 206: precision = args[0] || defaults[:precision] 207: end 208: 209: precision ||= (options[:precision] || defaults[:precision]) 210: separator ||= (options[:separator] || defaults[:separator]) 211: delimiter ||= (options[:delimiter] || defaults[:delimiter]) 212: 213: begin 214: rounded_number = (Float(number) * (10 ** precision)).round.to_f / 10 ** precision 215: number_with_delimiter("%01.#{precision}f" % rounded_number, 216: :separator => separator, 217: :delimiter => delimiter) 218: rescue 219: number 220: end 221: end