¿Hay un truco de rails para agregar comas a números grandes?

Para cualquiera que no use rails:

number.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse

Sí, use el Ayuda numérica. El método que está buscando es number_with_delimiter .

 number_with_delimiter(98765432.98, :delimiter => ",", :separator => ".")
 # => 98,765,432.98

Si lo estás haciendo mucho, pero también para tu información porque no está implícito en lo anterior, Rails tiene valores predeterminados razonables para el método number_with_delimiter.

#inside controller or view
number_with_delimiter(2444323.4)
#=> 2,444,323.30

#inside console
helper.number_with_delimiter(233423)
#=> 233,423

No es necesario proporcionar el valor delimitador si lo está haciendo de la manera más típica.

Si desea agregar comas fuera de las vistas y no desea incluir algunos módulos, puede usar el método number_to_delimited (versión de rails >= 4.02). Por ejemplo:

#inside anywhere
ActiveSupport::NumberHelper.number_to_delimited(1000000) # => "1,000,000"

Una mejor manera para aquellos que no usan rails que maneja decimales:

parts = number.to_s.split('.')
parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
parts.join('.')

Si desea un delimitador diferente, cambie el último ',' en la expresión regular.

Para bonus, así es como funciona la expresión regular:

• gsub reemplaza todo lo que coincide con la expresión regular con el segundo parámetro pasado a gsub. En este caso es \\1. \\1 se convierte en \1 cuando se evalúa que coincide con el primer grupo de captura en la expresión regular. En esta expresión regular que es (\d).
• (\d)(?=(\d\d\d)+) es coincidencia de un dígito seguido de 1 o más grupos de 3 dígitos. El primer conjunto de paréntesis es nuestro \1 grupo de captura, el segundo sería \2. Si simplemente lo dejáramos así, obtendríamos: 123456.gsub!(/(\d)(?=(\d\d\d)+)/, "\\1,") #=> 1,2,3,456 Esto se debe a que 1234 coincidencias, 2345 coincidencias y 3456 coincidencias, por lo que ponemos una coma después del 1, el 2 y el 3.
• Añadiendo el (?!\d) estamos haciendo coincidir cualquier cosa que viene antes que no precede a un dígito, por lo que (\d)(?=(\d\d\d)+(?!\d)) significa hacer coincidir un dígito seguido de 3 dígitos que no es seguido por un dígito. El la razón por la que esto funciona es que gsub seguirá reemplazando cosas que coincidan con la cadena. Si solo fuéramos a reemplazar el primer partido, entonces para un número como 123456789 obtendríamos 123456,789. Desde 123456,789 todavía coincide con nuestra expresión regular obtenemos 123,456,789.

Aquí es donde obtuve el código: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/number_helper.rb#L298-L300

Y aquí es donde aprendí sobre lo que está pasando en esa expresión regular: http://www.tutorialspoint.com/ruby/ruby_regular_expressions.htm

La forma directa de hacer esto, con o sin Rieles , es:

require 'active_support/core_ext/numeric/conversions'

12345.to_s(:delimited)      # => "12,345"
12345.6789.to_s(:delimited) # => "12,345.6789"

Para obtener más opciones, consulte Active Support Core Extensions - Numeric - Formatting.

Otra solución que no usa ayudantes: formatee con 2 decimales y luego reemplace . by,

puts(("%.2f" % 2.5666).gsub('.',','))
>> 2,57

Para la gente de javascript

function numberWithDelimiter(value) {
    return (value+"").split("").reverse().join("").replace(/(\d{3})(?=\d)/g, '$1,').split("").reverse().join("")
}

:)

Puedes usar métodos desde ActiveSupport

Por ejemplo:

ActiveSupport::NumberHelper::number_to_currency(10000.1234,{precision: 2,unit: ''})

  def add_commas(numstring)
    correct_idxs = (1..100).to_a.select{|n| n % 6 == 0}.map{|n| n - 1}
     numstring.reverse.chars.join(",").chars.select.with_index{|x, i| i.even? || correct_idxs.include?(i)}.join.reverse
  end

Este era mi camino en ruby

Adición editar: Básicamente agrega todas las comas entre los números y solo selecciona aquellos donde el índice + 1% 6

Me imaginé que las comas hasta 100 estaba bien, pero si quieres un número súper largo, haz 100 un número más alto