Comment faire pour formater un nombre de 1000 “1 000”

J'ai besoin d'un moyen de formater les nombres. J'ai stocké quelques numéros dans ma table DB, par exemple 12500, et que vous souhaitez imprimer dans ce format 12 500 (il y a donc un espace tous les 3 chiffres). Est-il un moyen élégant pour ce faire?

number_with_delimiter(12500, délimiteur: "")

InformationsquelleAutor user1946705 | 2011-06-23

36

voir: http://www.justskins.com/forums/format-number-with-comma-37369.html

il n'est pas construit de façon à elle ( à moins que vous à l'aide de Rails, ActiveSupport Ne disposent de méthodes pour ce faire), mais vous pouvez utiliser une expression régulière comme
```
formatted_n = n.to_s.reverse.gsub(/...(?=.)/,'\&,').reverse
```
- qui va ajouter des virgules, pas d'espaces btw
- Il suffit de remplacer le "et commercial", avec un espace (\&, avec \& ) et ça marchera.
- Merci les gars pour une aide rapide. Mais, dire la vérité, j'ai pensé qu'existe une jolie manière (par exemple, quelque chose comme cette fonction en PHP). Mais comment je suis en train de dire, merci pour la solution!
- Voici une modification qui gère les nombres négatifs trop: n.to_s.reverse.gsub(/...(?!-)(?=.)/,'\&,').reverse. Par exemple: "-174", pas "-,174".
- Les Rails / ActiveSupport méthode mentionnée est Numérique#to_formatted_s
- Voici une variante, pour éviter les deux reverse's: str=n.to_s; f=str.size%3; str[0,f] << str[f..-1].gsub(/.../, ' \&').
- Est-il un moyen de traiter avec les nombres réels? La méthode ci-dessus m'accordait le résultat suivant: "1,231,213,213,213,.33" - avec une virgule supplémentaire, puis à la fin, avec le point séparateur
- Vous pouvez modifier l' .'s pour correspondre uniquement des nombres au lieu de quoi que ce soit. Je ne me souviens plus de la syntaxe exacte de ruby regexes ces jours, mais quelque chose comme /[0-9]{3}(?=[0-9])/ ou le long de ces lignes. Voir steenslag la réponse ci-dessous
InformationsquelleAutor loosecannon
21

Activesupport utilise cette regexp (et pas de marche arrière marche arrière).
```
10000000.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\ ") #=> "10 000 000"
```
- Je ferais serait d'ouvrir la classe Integer et ajouter une méthode. Que les captures Fixnum et Bignum.
- C'est plutôt sympa. Pourrait le négatif look-ahead être éliminé avec /(\d)(?=(\d\d\d)+$)/?
InformationsquelleAutor steenslag
9

Voici une autre méthode qui est propre et assez simple si vous faites affaire avec des entiers:
```
number.to_s.reverse.scan(/\d{1,3}/).join(",").reverse

number            #=> 12345678
.to_s             #=> "12345678"
.reverse          #=> "87654321"
.scan(/\d{1,3}/)  #=> ["876","543","21"]
.join(",")        #=> "876,543,21"
.reverse          #=> "12,345,678"
```
Fonctionne très bien pour les entiers. Bien sûr, cet exemple en particulier, seront séparés par des virgules, mais le passage à des espaces ou tout autre séparateur est aussi simple que de remplacer le paramètre dans la join méthode.
- formatted_n = n.to_s.reverse.gsub(/...(?=.)/,'\&,').reverse plus vite que cette solution 😉
- ce qui est probablement la raison pour laquelle c'est le haut de répondre à cette question 🙂 je viens d'ajouter mon point de vue sur le problème. J'aime Ruby car il y a toujours une centaine de façons différentes de faire les choses!
- vous semblez prendre mon commentaire comme une attaque, il n'a pas, je viens de lire les différentes solutions, parce que le "haut" n'est pas toujours le meilleur en fait. J'ai donc fait un test de référence et je donne ma conclusion qui veut l'entendre. Rien de plus 😉
InformationsquelleAutor Jeffrey Klein
8

La document officiel suggère de trois façons différentes:

1) à l'Aide de lookbehind et d'anticipation (Nécessite oniguruma)
```
12500.to_s.gsub(/(?<=\d)(?=(?:\d{3})+\z)/, ' ')
# => "12 500"
```
2) en Utilisant seulement d'anticipation. Identique à steenslag de réponse.

3) à l'Aide de ni anticipation, ni lookbehind
```
s = 12500.to_s
nil while s.sub!(/(.*\d)(\d{3})/, ' ')
s # => "12 500"
```
- #3 semble s'appuyer sur la gourmandise. Si oui, je pense qu'il ne serait pas grave si gsub! ou sub! ont été utilisés. nil pourrait être remplacé par n'importe littérale. - Il Correct? Est-ce toujours équivalent à while s.gsub!(/(.*\d)(\d{3})/, '\1 \2'); end (qui, je pense, lit un peu mieux)?
- Oui. gsub! était inutile. J'ai édité.
InformationsquelleAutor sawa
4

très simple:

number_with_delimiter(12500, delimiter: " ")

voir: http://apidock.com/rails/ActionView/Helpers/NumberHelper/number_with_delimiter
- Ce n'est pas pour ruby, ce n'est que des rails de méthode
InformationsquelleAutor nilid

Donc, c'est assez fou et hackish, mais il fait le travail...

12500.to_s.split("").reverse.each_slice(3).map {|y| y.join("").reverse}.reverse.join(" ")
 => "12 500" 

.to_s: convert to string
.split(""): split into separate digits
.reverse: reverse order
.each_slice(3): peel of each three digits (working from back end due to reverse)
.map {|y| y.join("").reverse}: map into an array for each three digits - join back together with no delimiter and reverse order back to original
.reverse: reverse order of mapped array
.join(" "): join mapped array back together with space delimiter

C'est intelligent d'utiliser each_slice pour éviter de répéter des expressions régulières

InformationsquelleAutor Yardboy

D'une autre manière:

12500.to_s.reverse().split(//).inject() {|x,i| (x.gsub(/ /,"").length % 3 == 0 ) ? x + " " + i : x + i}.reverse()

Vous pouvez toujours Ouvrir la Fixnum de classe et d'ajouter ce pour des raisons de commodité:

module FormatNums
  def spaceify
    self.to_s.reverse().split(//).inject() {|x,i| (x.gsub(/ /,"").length % 3 == 0 ) ? x + " " + i : x + i}.reverse()
  end
end

class Fixnum
  include FormatNums
end

12500.spaceify # => "12 500"

Oh, un wiseguy, sont ya? Très sympa! +1 🙂
merci. Avec Ruby, il n'est pas intégré dans parce que vous pouvez construire vous-même si facilement. Droit?
En effet. Codant pour des raisons de codage, ce qui pourrait être mieux?

InformationsquelleAutor NullRef

Tout, mais les réponses utilisez n.to_s. @MrMorphe n'a pas, mais il crée un tableau à joined. Voici une façon qui n'utilise ni Fixnum#to_s ni Tableau#join.

def separate(n,c=' ')
  m = n
  str = ''
  loop do
    m,r = m.divmod(1000)
    return str.insert(0,"#{r}") if m.zero?
    str.insert(0,"#{c}#{"%03d" % r}")
  end
end

separate(1)       #=>         "1"
separate(12)      #=>        "12"
separate(123)     #=>       "123"
separate(1234)    #=>     "1 234"
separate(12045)   #=>    "12 045"
separate(123456)  #=>   "123 456"
separate(1234000) #=> "1 234 000"

Hmmm. C'est que la colonne sur la droite de basculement?

Une autre voie, qui utilise to_s mais pas join:

def separate(n, c=' ')
  str = n.to_s
  sz = str.size
  (3...sz).step(3) { |i| str.insert(sz-i, c) }
  str
end

InformationsquelleAutor Cary Swoveland

C'est vieux, mais la manière la plus rapide et la plus élégante que j'ai pu trouver pour faire ceci est:

def r_delim(s, e)                                                               
  (a = e%1000) > 0 ? r_delim(s, e/1000) : return; s << a                        
end

r_delim([], 1234567).join(',')

Je vais essayer et d'ajouter des repères à un certain point.

InformationsquelleAutor Mr Morphe

1

D'une autre manière:
Ici, "le délimiteur est ' '(espace), vous pouvez spécifier ',' pour de l'argent de la conversion."
```
number.to_s.reverse.gsub(%r{([0-9]{3}(?=([0-9])))}, "\#{delimiter}").reverse
```
- Merci pour l'édition.
- Hey, bienvenue à Stack Overflow! Tu es la bienvenue, et félicitations pour votre première upvote (de moi :D) Par le chemin, de prendre un tour, et vous pouvez chatter dans un salle de chat une fois que vous avez suffisamment de réputation.
InformationsquelleAutor Pavan
0

Je viens de tombé sur ce fil alors que vous cherchez un moyen format de la valeur de la devise américaine. J'ai pris une approche légèrement différente de la regex solutions proposées:
```
amt = 1234567890.12
f_amt = format("$%.2f",amt)
i = f_amt.index(".")
while i > 4
  f_amt[i-3]=","+f_amt[i-3]
  i = f_amt.index(",")
end

f_amt
=> "$1,234,567,890.12"
```
Cela pourrait être paramétrée pour la mise en forme d'autres devises.

InformationsquelleAutor user4240162

-2

Je suis conscient que c'est une vieille question, mais.

pourquoi ne pas simplement utiliser une sous-chaîne de substitution.

en pseudo-code....

String numberAsString = convertNumberToString(123456);
int numLength = V.length;//determine length of string

String separatedWithSpaces = null;

for(int i=1; i<=numlength; i++){//loop over the number
separatedWithSpaces += numberAsString.getCharacterAtPosition(i);
    if(i.mod(3)){//test to see if i when devided by 3 in an integer modulo,
    separatedWithSpaces += " ";

    }//end if

}//end loop

Je sais que ce n'est pas languange, mais j'espère que vous obtenez l'idée.

David

J'avais pense que les expressions régulières sont la meilleure et la plus propre façon de résoudre ce problème. Cette entendre ressemble de manière trop compliqué.

InformationsquelleAutor DaveM

Vous devez vous connecter pour publier un commentaire.