Réponses:
Vous voulez la number_with_delimiter
méthode. Par exemple:
<%= number_with_delimiter(@number, :delimiter => ',') %>
Vous pouvez également utiliser la number_with_precision
méthode pour vous assurer que le nombre est toujours affiché avec deux décimales de précision:
<%= number_with_precision(@number, :precision => 2, :delimiter => ',') %>
number_with_delimiter
est trop complexe et très lent, avec d'énormes profondeurs de piles d'appels. Il i18n
permet de formater tous les nombres connus de l'humanité et des civilisations extraterrestres (ou peut-être simplement de choisir l'un ,
ou .
pour les chiffres décimaux, même si vous le spécifiez comme argument). Il alloue des milliers d'objets (ses modèles de performances sont donc complexes et difficiles à profiler). Pensez à utiliser uniquement des expressions rationnelles si vous n'avez pas besoin de prendre en charge différentes façons de formater les nombres en fonction des paramètres régionaux.
Pour toute personne n'utilisant pas de rails:
number.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
number.to_s.reverse.scan(/(?:\d*\.)?\d{1,3}-?/).join(',').reverse
\1
suffisant? Merci.
La façon directe de le faire, avec ou sans Rails , est:
require 'active_support/core_ext/numeric/conversions'
12345.to_s(:delimited) # => "12,345"
12345.6789.to_s(:delimited) # => "12,345.6789"
Pour plus d'options, voir Extensions de base du support actif - Numérique - Formatage .
ActiveSupport::NumberHelper.number_to_delimited
. Cette réponse mérite beaucoup plus de votes positifs.
Oui, utilisez le NumberHelper . La méthode que vous recherchez est number_with_delimiter .
number_with_delimiter(98765432.98, :delimiter => ",", :separator => ".")
# => 98,765,432.98
Si vous souhaitez ajouter des virgules en dehors des vues et que vous ne souhaitez pas inclure certains modules, vous pouvez utiliser la méthode number_to_delimited (rails version> = 4.02). Par exemple:
#inside anywhere
ActiveSupport::NumberHelper.number_to_delimited(1000000) # => "1,000,000"
Si vous le faites beaucoup mais aussi pour votre information car ce n'est pas impliqué par ce qui précède, Rails a des valeurs par défaut raisonnables pour la number_with_delimiter
méthode.
#inside controller or view
number_with_delimiter(2444323.4)
#=> 2,444,323.30
#inside console
helper.number_with_delimiter(233423)
#=> 233,423
Pas besoin de fournir la valeur du délimiteur si vous le faites de la manière la plus courante.
Une meilleure façon pour ceux qui n'utilisent pas de rails qui gèrent les décimales:
parts = number.to_s.split('.')
parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
parts.join('.')
Si vous voulez un délimiteur différent, modifiez le dernier ',' dans l'expression régulière.
Pour les bonus, voici comment fonctionne l'expression régulière:
\\1
. \\1
devient une \1
fois évalué qui correspond au premier groupe de capture dans l'expression régulière. Dans ce regex qui est(\d)
.(\d)(?=(\d\d\d)+)
correspond à un chiffre suivi d'un ou plusieurs groupes de 3 chiffres. Le premier ensemble de parens est notre \1
groupe de capture, le second le serait \2
. Si nous devions en rester là, nous obtiendrions:
123456.gsub!(/(\d)(?=(\d\d\d)+)/, "\\1,") #=> 1,2,3,456
c'est parce que 1234 correspondances, 2345 correspondances et 3456 correspondances, nous mettons donc une virgule après le 1, le 2 et le 3.(\d)(?=(\d\d\d)+(?!\d))
signifie donc faire correspondre un chiffre suivi de 3 chiffres qui ne sont pas suivis d'un chiffre. La raison pour laquelle cela fonctionne est que gsub continuera de remplacer les éléments qui correspondent à la chaîne. Si nous devions seulement remplacer le premier match, alors pour un nombre comme 123456789, nous aurions 123456,789. Étant donné que 123456 789 correspond toujours à notre expression régulière, nous obtenons 123 456 789.Voici où j'ai obtenu le code: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/number_helper.rb#L298-L300
Et voici où j'ai appris ce qui se passe dans cette expression régulière: http://www.tutorialspoint.com/ruby/ruby_regular_expressions.htm
{{ value | round | replace: "(\d)(?=(\d\d\d)+(?!\d))", "$1," | prepend: "$" }}
Une autre solution qui n'utilise pas Helpers: formatez avec 2 décimales, puis remplacez. par ,
puts(("%.2f" % 2.5666).gsub('.',','))
>> 2,57
Vous pouvez utiliser des méthodes de ActiveSupport
Par exemple:
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
C'était ma voie en rubis
Addition addition: Fondamentalement, il ajoute toutes les virgules entre les nombres et ne sélectionne que celles où l'index + 1% 6
Je pensais que les virgules jusqu'à 100 étaient bien, mais si vous voulez un nombre super long, faites simplement 100 un nombre plus élevé
nouvelle syntaxe
number_with_delimeter(@number, delimeter: ",")
Si vous souhaitez utiliser le délimiteur pour de l'argent, vous pouvez le faire
number_to_currency(@number)
cela ajoutera $
aussi. Si vous utilisez money
gem, vous pouvez le faire
Money.new(@number,"USD").format
Cela mettra également $
.
Les éléments suivants font l'affaire à la fois pour le délimiteur et la précision ( référence API ).
ActiveSupport::NumberHelper.number_to_rounded(1234.532, delimiter: ',', precision: 1)
(ou simplement à partir de vues number_to_rounded
, pas besoin du suffixe)
HTH
ActionView::Helpers::NumberHelper
dans le module.